Frage : Wie gelange ich von diesem Code an meinen gewünschten Ausgang?

Dieses ist EINE NICHT akademische Übung, aber ein tatsächliches Problem, die ich versuche zu lösen.  

A Bündel Kursteilnehmer (AG) teilnehmen an einer werfenden Konkurrenz, zu sehen en, wie weit sie einen Gegenstand werfen können (gemessen in den Füßen).  Ich betroffen mit der Bestimmung der RIEGEL im Abstand, der zwischen verschiedene Kursteilnehmer geworfen.  Das heißt, wenn 2 oder mehr Kursteilnehmer einen Riegel ich haben, möchten aufmerksam gemacht werden ihm.  

Please sehen angebrachtes code.

From dieser Code, den ich den Ausgang anzeigen wünsche, um wie dieses auszusehen:
44 Füße: C, E
33 Füße: B, D
22 Füße: A, C, D, F

Given, dass wir jetzt iterator es… haben, wie ich meinen gewünschten Ausgang erhalte? 
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:

#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);
}

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“},
   };
   int len = sizeof (throwDist)/sizeof (throwDist [0]);
   vector dist (throwDist, throwDist + len);
   vector:: iterator es = dist.begin ();

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

   für (; es! = dist.end (); it++) {
      cout << setw (2) << (*it) .distance 
         << „Füße:  “ << (*it) .studentName << endl;
   }

   es = adjacent_find (dist.begin (), dist.end (), isDistEqual);
}

Antwort : Wie gelange ich von diesem Code an meinen gewünschten Ausgang?

OKAY, folgender Versuch; O)

Dieses Mal beseitigen wir die Abstände, die wir bereits behandelten:
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 cmpDist (StudentAttempt gelassen, StudentAttempt Recht) {
   wenn (left.distance == right.distance) {
      Rückhol ausrichten;
   }

  falsches zurückbringen;
}

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;

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

    wenn (isDistEqual (*i, sa)) {
    
      SS <>studentName;
      ++sz;
    }

    ++i;
  }

  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“},
   };

   Satz behandelte;

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

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


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

      stringstream SS;

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

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

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