Question : M'aider à optimiser ce code.

Comment est-ce que j'arrête l'itération quand une plus grande distance est produite ?  Je ne veux pas réitérer par le vecteur entier dans la 2ème boucle (tandis que boucle). class= > " clair " de
> de " codeSnippet " de class= de
class= " lineNumbers " de
class= de 
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 :
" de " codeSnippet840178 d'id= " de 
#include de class=
 de #include
 de #include
 de #include
 de #include
 de #include
 de #include

using namespace DST ;

struct StudentAttempt
{
   distance d'international ;
   studentName de corde ;
} ;

bool cmpEntry (StudentAttempt laissé, droit de StudentAttempt) {
   == de retour right.studentName du && left.studentName du == right.distance de left.distance ;
}
cmpAttempts de bool (StudentAttempt laissé, droit de StudentAttempt) {
   si (left.distance < right.distance) {
      de retour rectifier ;
   }
   autrement si (== right.distance de left.distance) {
      si (left.studentName < right.studentName) {
         de retour rectifier ;
      }
      autrement
         faux de retour ;
   }
   autrement
      faux de retour ;
}

bool isDistEqual (StudentAttempt laissé, droit de StudentAttempt) {
   retourner (== right.distance de left.distance
      && left.studentName ! = right.studentName) ;
}

size_t printAllEqual (vector& v, StudentAttempt& SA, stringstream& solides solubles de const de const) {

   vector : : const_iterator i = v.begin () ;
  size_t la SZ = 0 ;
  le bFirst de bool = rectifient ;

  tandis que (I ! = v.end ()) {

    si (isDistEqual (*i, SA)) {
    
      si (! bFirst) solides solubles << « , » ;
      solides solubles << i->studentName ;
      ++sz ;
    }

    ++i ; 
    bFirst = faux ;
  }

  la SZ de retour ;
}
 

force d'international () {

   throwDist de 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 manipulé ;

   international len = sizeof) (de throwDist/sizeof (throwDist [0]) ;

   dist de vector (le throwDist, throwDist + len) ;
   vector : : iterator il = dist.begin () ;

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

   unique (dist.begin (), dist.end (), cmpEntry) ; // enlève les reproductions identiques du vecteur assorti


   pour (; il ! = dist.end () ; it++) {

      stringstream solides solubles ;

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

      si (! p.second) continuent ; // déjà manipulé

      si (0 < printAllEqual (dist, *it, solides solubles)) 
        cout << setw (2) << (*it) .distance 
           << « pieds :   » << (*it) .studentName << ss.str () << endl ;
   }
}
class= de

Réponse : M'aider à optimiser ce code.

Comme dans votre autre Q, vous pourriez en faire optimisant en arrêtant l'itération quand vous rencontrez une distance qui est plus grande que celle nous vérifient (puisqu'aucune égale ne suivra de puis), par exemple.
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 (vector& v, StudentAttempt& SA, stringstream& solides solubles de const de const) {

  vecteur : : const_iterator i = v.begin () ;
  size_t la SZ = 0 ;
  le bFirst de bool = rectifient ;

  tandis que (I ! = v.end ()) {

    si (isDistEqual (*i, SA)) {
    
      si (! studentName du bFirst) <>solides solubles ;
      ++sz ;

      // que nous pouvons nous arrêter ici en rencontrant des distances
      // plus grand que celui nous sommes puisque le vecteur est
      // a assorti dans l'ordre croissant (sinon, ceci causerait des erreurs)
      Des distances plus élevées de // n'égaleront jamais le nôtre
      si (i->distance > sa.distance) coupure ;
    }

    ++i ; 
    bFirst = faux ;
  }

  la SZ de retour ;
}
Autres solutions  
  •  MS Excel 2007 et pdf - l'exportation vers le pdf prend de longues heures !
    •
  •  Dans le Perl, comment j'ajoute une valeur à la liste, puis le contrôle pour voir si la valeur existent avant d'ajouter une nouvelle valeur
    •
  •  Comment fais j'initialiser de la HP BL460c G6 de san et de la HP XP 240000
    •
  •  Comment fais j'employer une clef de permis de volume sur un ordinateur de HP avec du CD de restauration
    •
  •  Emplacement primaire de deux SCCM dans l'annuaire actif
    •
  •  L'initiateur et la HP D2D de l'iSCSI R2 du serveur 2008 de Windows GERCENT l'issue
    •
  •  Stocker le dossier dans le mysql using connector.net et le champ de goutte
    •
  •  Carte vidéo d'USB - bit 32 sur le matériel travaillant au niveau du bit 64 ?
    •
  •  asp.net que j'essaye de convertir une forme de HTML en forme d'aspx ou ? ce qui jamais. Aide du besoin sur la façon dont à à elle.
    •
  •  Winzip 12 issues de secours du travail ?
    •
     
    programming4us programming4us