Vraag : Help me deze code optimaliseren.

Hoe houd ik de herhaling tegen wanneer een grotere afstand wordt ontmoet?  Ik wil niet door de volledige vector in de 2de lijn (terwijl lijn) herhalen.
" codeBody " 
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:
36:
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 

het gebruiken van namespace norm;

struct StudentAttempt
{
   int. afstand;
   koord studentName;
};

cmpEntry bool (recht verlaten StudentAttempt, StudentAttempt) {
   terugkeer left.distance == right.distance && left.studentName == right.studentName;
}
bool cmpAttempts (recht verlaten StudentAttempt, StudentAttempt) {
   als (left.distance < right.distance) {
      ware terugkeer;
   }
   als anders (left.distance == right.distance) {
      als (left.studentName < right.studentName) {
         ware terugkeer;
      }
      anders
         valse terugkeer;
   }
   anders
      valse terugkeer;
}

isDistEqual bool (recht verlaten StudentAttempt, StudentAttempt) {
   terugkeer (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 = waar;

  terwijl (I! = v.end ()) {

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

    ++i; 
    bFirst = vals;
  }

  terugkeer sz;
}
 

int. leiding () {

   throwDist van StudentAttempt [] = {
      {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 behandeld;

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

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

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

   uniek (dist.begin (), cmpEntry dist.end (),); // verwijdert identieke duplicaten uit de gesorteerde vector


   voor (; het! = dist.end (); it++) {

      stringstream ss;

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

      als (! p.second) ga verder; reeds behandeld //

      als (0 < printAllEqual (dist, *it, ss)) 
        cout << setw (2) << (*it) .distance 
           << „voeten:  “ << (*it) .studentName << ss.str () << endl;
   }
}

Antwoord : Help me deze code optimaliseren.

Zoals in uw ander Q, kon u sommigen doen die door de herhaling optimaliseren tegen te houden wanneer u een afstand ontmoet die groter is dan wij (aangezien geen gelijke men van dan) zal volgen, b.v. controleren.
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) {

  vector:: const_iterator i = v.begin ();
  size_t sz = 0;
  bool bFirst = waar;

  terwijl (I! = v.end ()) {

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

      // wij hier kunnen tegenhouden wanneer het ontmoeten van afstanden
      // groter dan zijn wij aangezien de vector is
      // in het stijgen orde (als niet, dit fouten die veroorzaken) wordt gesorteerd zou
      // zullen de Hogere afstanden nooit van ons evenaren
      als (i->distance > sa.distance) onderbreking;
    }

    ++i; 
    bFirst = vals;
  }

  terugkeer sz;
}
Andere oplossingen  
 
programming4us programming4us