Frage : Mir helfen, diesen Code zu optimieren.

Wie stoppe ich die Wiederholung, wenn ein grösserer Abstand angetroffen wird?  Ich möchte nicht durch den gesamten Vektor in der 2. Schleife wiederholen (während Schleife). 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
6:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:

#include 
#include 
#include 
#include 
#include 
#include 
#include 

using namespace-Geschlechtskrankheit;

struct StudentAttempt
{
   int-Abstand;
   Schnur studentName;
};

bool cmpEntry (StudentAttempt gelassen, StudentAttempt Recht) {
   Rückholleft.distance == right.distance && left.studentName == right.studentName;
}
bool cmpAttempts (StudentAttempt gelassen, StudentAttempt Recht) {
   wenn (left.distance < right.distance) {
      Rückhol ausrichten;
   }
   sonst, wenn (left.distance == right.distance) {
      wenn (left.studentName < right.studentName) {
         Rückhol ausrichten;
      }
      sonst
         Rückholfalsches;
   }
   sonst
      Rückholfalsches;
}

bool isDistEqual (StudentAttempt gelassen, StudentAttempt Recht) {
   zurückgehen (left.distance == right.distance
      && left.studentName! = right.studentName);
}

size_t printAllEqual (const vector& V, const StudentAttempt& sa, stringstream& SS) {

   vector:: const_iterator I = v.begin ();
  size_t SZ = 0;
  bool bFirst = richten aus;

  während (i! = v.end ()) {

    wenn (isDistEqual (*i, sa)) {
    
      wenn (! bFirst) SS << „,“;
      SS << i->studentName;
      ++sz;
    }

    ++i; 
    bFirst = falsch;
  }

  Rückholsz;
}
 

int-Hauptleitung () {

   StudentAttempt throwDist [] = {
      {50, „A“}, {22, „A“}, {16, „B“}, {44, „C“},
      {33, „D“}, {34, „E“}, {22, „F“}, {21, „G“},
      {49, „A“}, {5, „B“}, {2, „C“}, {22, „A“},
      {33, „B“}, {22, „C“}, {22, „D“}, {44, „E“}, {22, „D“}
   };


   set behandelt;

   int len = sizeof (throwDist)/sizeof (throwDist [0]);

   vector dist (throwDist, throwDist + len);
   vector:: iterator es = dist.begin ();

   Art (dist.begin (), dist.end (), cmpAttempts);

   einzigartig (dist.begin (), dist.end (), cmpEntry); // entfernt identische Duplikate vom sortierten Vektor


   für (; es! = dist.end (); it++) {

      stringstream SS;

      pair:: iterator, bool> p = handled.insert (it->distance);

      wenn (! p.second) fahren fort; // bereits behandelt

      wenn (0 < printAllEqual (dist, *it, SS)) 
        cout << setw (2) << (*it) .distance 
           << „Füße:  “ << (*it) .studentName << ss.str () << endl;
   }
}

Antwort : Mir helfen, diesen Code zu optimieren.

Wie in Ihrem anderen Q, konnten Sie einiges tun, das indem Sie die Wiederholung optimiert, stoppten, wenn Sie einen Abstand, der größer ist, als der wir auf überprüfen (da kein gleiches man von dann folgt), z.B. antreffen.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:

size_t printAllEqual (const vector& V, const StudentAttempt& sa, stringstream& SS) {

  Vektor:: const_iterator I = v.begin ();
  size_t SZ = 0;
  bool bFirst = richten aus;

  während (i! = v.end ()) {

    wenn (isDistEqual (*i, sa)) {
    
      wenn (! bFirst) SS <>studentName;
      ++sz;

      //, das wir hier stoppen können, wenn wir Abstände antreffen
      //, das sind wir größer als das ist, da der Vektor ist
      // sortierte in aufsteigender Sequenz (wenn nicht, würde dieses Störungen verursachen)
      //-höhere Abstände entsprechen nie unseren
      wenn (i->distance > sa.distance) Bruch;
    }

    ++i; 
    bFirst = falsch;
  }

  Rückholsz;
}
Weitere Lösungen  
 
programming4us programming4us