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 :
#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 ; } ; 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 »} } ; le set a 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 (), cmpDist) ; pour (; il ! = dist.end () ; it++) { stringstream solides solubles ; pair : : iterator, bool> p = handled.insert (it->distance) ; si (! p.second) continuent ; // a déjà manipulé si (0 < printAllEqual (dist, *it, solides solubles)) cout << setw (2) << (*it) .distance << « pieds : » << (*it) .studentName << ss.str () << endl ; } }
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 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="">et v, StudentAttempt& SA, stringstream& solides solubles 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 ; } ++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 »} } ; ensemble manipulé ; international len = sizeof) (de throwDist/sizeof (throwDist [0]) ; dist de vecteur (le throwDist, throwDist + len) ; vecteur : : 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 ; paires : : iterator, bool> p = handled.insert (it->distance) ; si (! p.second) continuent ; // déjà manipulé si (0 < printAllEqual="">