Frage : Wie drücke ich dieses im Code aus?

Rekapitulation: Es gibt einen Wettbewerb zwischen Kursteilnehmern, AG, zum zu sehen, wer einen Gegenstand starten kann das weiteste in den Füßen.  Ich wollte Fälle kennzeichnen, wenn es Riegel zwischen verschiedenen Kursteilnehmern d.h. gibt, in denen ihre Würfe der gleiche Abstand das genaue sind.  Ich interessiere mich nicht, wenn ein Kursteilnehmer sich bindet.

Ok, wenn Sie diesen Code Sie laufen lassen, beachtet, dass Kursteilnehmer D oben zweimal in den 22 Füßen zeigt, zeichnen.  Wie werde ich dieses los, damit kein Kursteilnehmer zweimal an jedem möglichem distsance wiederholt wird?  Ich sehe, was Unrecht ist und es in den Wörtern. .but oben erklären kann meine Sinnesfröste, wenn ich die Code… Hilfe ändern möchte? 

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:

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

using namespace-Geschlechtskrankheit;

struct StudentAttempt
{
   int-Abstand;
   Schnur 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 behandelte;

   int len = sizeof (throwDist)/sizeof (throwDist [0]);
   vector dist (throwDist, throwDist + len);
   vector:: iterator es = dist.begin ();

   Art (dist.begin (), dist.end (), cmpAttempts);
   //unique (dist.begin (), dist.end (), cmpDist);


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

      stringstream SS;

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

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

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

Antwort : Wie drücke ich dieses im Code aus?

Gut innen

      {33, „B“}, {22, „C“}, {22, „D“}, {44, „E“}, {22, „D“}

Sie haben dass sehr doppelte Eintragung - sie einfach entfernen, nachdem sie sortiert, z.B.
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="">u. v, const StudentAttempt& sa, stringstream& SS) {

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

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

    wenn (isDistEqual (*i, sa)) {
    
      wenn (! bFirst) SS <>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“}
   };


   Satz behandelt;

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

   Vektor dist (throwDist, throwDist + len);
   Vektor:: 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;

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

      wenn (! p.second) fortfahren ren; // bereits behandelt

      wenn (0  < printAllEqual="">
Weitere Lösungen  
 
programming4us programming4us