Fråga : Hur uttryckligt I detta kodifierar in?

Recap: Det finns en strid mellan deltagare A-G som ser vem kan barkassen en anmärka det mest borterst i fot.  Jag önskade att identifiera anföra som exempel, när det finns ties mellan olika deltagare var dvs. deras kast är avkräva som, samma distanserar.  Jag att bry sig inte, om en deltagare binder självt.

Ok, om du kör denna, kodifierar dig ska märker att deltagare D visar upp i den 22 foten fodrar två gånger.  Hur jag får rid av denna, så att ingen deltagare upprepas två gånger på någon distsance?  Jag ser att vad är fel och kan förklara, den uttrycker in. min .but varar besvärad upp frysningar, när jag önskar att ändra den kodifiera… hjälpen?

> för 
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:
" codeBody " " för >#include för class= " för #include #include #include #include #include using namespace std; struct StudentAttempt { int distanserar; stränga studentName; }; boolcmpAttempts (lämnade StudentAttempt, högra StudentAttempt) { om (left.distance < right.distance) { återgångt true; } annars, om (left.distance-== right.distance) { om (left.studentName < right.studentName) { återgångt true; } annars återgångt falskt; } annars återgångt falskt; } isDistEqual bool (lämnade StudentAttempt, högra StudentAttempt) { gå tillbaka (left.distance-== right.distance && left.studentName! = right.studentName); } printAllEqual size_t (constvector& v, constStudentAttempt& sa, stringstream& ss) { vector:: const_iterator i = v.begin (); size_t sz = 0; boolbFirst = true; stunder (I! = v.end ()) { om (isDistEqual (*ien, sa)) { om (! bFirst) ss << ”,”; ss << i->studentName; ++sz; } ++i; bFirst = falskt; } återgång sz; } huvudsaklig int () { 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 behandlade; int len = sizeof) (för throwDist/sizeof (throwDist [0]); vectordist (throwDisten, throwDist + len); vector:: iterator det = dist.begin (); sortera (dist.begin (), dist.end (), cmpAttempts); //unique (dist.begin (), dist.end (), cmpDist); för (; det! = dist.end (); it++) { stringstream ss; pair:: iterator bool> p = handled.insert (it->distance); om (! p.second) fortsätter; // behandlade redan om (0 < printAllEqual (disten, *it, ss)) cout << setw (2) << (*it) .distance << ”fot: ” << (*it) .studentName << ss.str () << endl; } }
" klar "

Svar : Hur uttryckligt I detta kodifierar in?

Brunn in

      {33, ”B”}, {22, ”C”}, {22, ”D”}, {44, ”E”}, {22, ”D”}

du har det mycket dubbletttillträde - precis att ta det bort, efter det har sorterats, e.g.
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 std;

struct StudentAttempt
{
   int distanserar;
   stränga studentName;
};

cmpEntry bool (lämnade StudentAttempt, högra StudentAttempt) {
   återgång == right.studentName för && left.studentName för left.distance-== right.distance;
}
boolcmpAttempts (lämnade StudentAttempt, högra StudentAttempt) {
   om (left.distance < right="">& v, constStudentAttempt& sa, stringstream& ss) {

   vektor:: const_iterator i = v.begin ();
  size_t sz = 0;
  boolbFirst = true;

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

    om (isDistEqual (*ien, sa)) {
    
      om (! ss-studentName för bFirst <>);
      ++sz;
    }

    ++i; 
    bFirst = falskt;
  }

  återgång sz;
}
 

huvudsaklig int () {

   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”}
   };


   uppsättningen behandlade;

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

   vektor dist (throwDisten, throwDist + len);
   vektor:: iterator det = dist.begin ();

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

   unikt (dist.begin (), dist.end () som, är cmpEntry); // tar bort identiska dubblett från den sorterade vektorn


   för (; det! = dist.end (); it++) {

      stringstream ss;

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

      om (! p.second) fortsätter; // behandlade redan

      om (0  < printAllEqual="">
Andra lösningar  
 
programming4us programming4us