ich bin neu hier im Forum und habe direkt mal eine Frage.
Und zwar habe ich 10 Edit Felder wo beliebige Zhalen stehen ( maximal 150 ).

Wenn ich nun ein Button drücke sollen die Zahlen miteinander verglichen werden.
^^Also nach der größe der Zahlen.

wenn alles verglichen wurde wird neben den Editfeldern eine Platzierung angezeigt.

zB:
Summer Platzierung
[ 40 ] [ 6 ]
[ 44 ] [ 5 ]
[ 4 ] [ 8 ]
[ 12 ] [ 7 ]
[ 100 ] [ 3 ]
[ 150 ] [ 1 ]
[ 140 ] [ 2 ]
[ 1 ] [ 9 ]
[ 0 ] [ 10 ]
[ 90 ] [ 4 ]

^^ So sieht es auch auf dem Formular aus
Hier der Quellcode:

void __fastcall TForm1::Button11Click(TObject *Sender)
{
int zahl1, zahl2, zahl3, zahl4, zahl5, zahl6, zahl7, zahl8, zahl9, zahl10;

zahl1 = Edit51->Text.ToInt();
zahl2 = Edit52->Text.ToInt();
zahl3 = Edit53->Text.ToInt();
//zahl4 = Edit54->Text.ToInt();
//zahl5 = Edit55->Text.ToInt();
//zahl6 = Edit56->Text.ToInt();
//zahl7 = Edit57->Text.ToInt();
//zahl8 = Edit58->Text.ToInt();
//zahl9 = Edit59->Text.ToInt();
//zahl10 = Edit60->Text.ToInt();

if (zahl1 > zahl2 && zahl1 > zahl3)
        {
        Edit61->Text = 1;
        }
else
        {
        Edit61->Text = 3;
        }
}

Ich habe erstmal versucht 3 Zhalen miteinander zuvergleichen aber wenn ich das mit 10 zhalen mache wird das sehr kompliziert mit meiner if methode

Ich brauche drigend hilfe.

Danke im vorraus

#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
#include <functional>
using namespace std;

int main()
{
    vector<int> dieZahlen;
    vector<int> dieSortiertenZahlen;
    map<int, int> dieZahlenMitPlatzierung;

    dieZahlen.push_back(5543);
    dieZahlen.push_back(4711);
    dieZahlen.push_back(7150);
    dieZahlen.push_back(8432);
    //oder noch mehr

    for (size_t i = 0; i < dieZahlen.size(); ++i)
    	cout << dieZahlen[i] << "\n";

    dieSortiertenZahlen.resize(dieZahlen.size());
    copy(dieZahlen.begin(), dieZahlen.end(), dieSortiertenZahlen.begin());
    sort(dieSortiertenZahlen.begin(), dieSortiertenZahlen.end(), greater<int>());

    for (size_t i = 0; i < dieSortiertenZahlen.size(); ++i)
    	dieZahlenMitPlatzierung[dieSortiertenZahlen[i]] = i;

    for (size_t i = 0; i < dieZahlen.size(); ++i)
    	cout << dieZahlen[i] << ": " << (dieZahlenMitPlatzierung[dieZahlen[i]]+1) << "\n";
}

Würde es nicht etwas einfacher funktionieren mit einer einfachen if verschachtelung ?

zB.

if (zahl1 > zahl2) <-- so zB.

Das halt nur mit 10 Zahlen

Würde es nicht etwas einfacher funktionieren mit einer einfachen if verschachtelung ?

Nein. Die Bedingungen in den if-Anweisungen würden sehr lang werden.

Da ich noch relativ unerfahren bin bringt mir dieser Quelltext nicht viel.

Würde es nicht etwas einfacher funktionieren mit einer einfachen if verschachtelung ?

zB.

if (zahl1 > zahl2) <-- so zB.

Das halt nur mit 10 Zahlen

Du hast doch schon selbst erkannt, dass es so sehr kompliziert wird:

ploRa schrieb:

Ich habe erstmal versucht 3 Zhalen miteinander zuvergleichen aber wenn ich das mit 10 zhalen mache wird das sehr kompliziert mit meiner if methode

Ich brauche drigend hilfe.

#include <iostream>
#include <iomanip>

#include <vector>
#include <map>
#include <algorithm>
#include <functional>
using namespace std;

//Eine Klasse für Zahlen mit Platzierung

class ZahlMitPlatzierung
{
public:
	ZahlMitPlatzierung(int zahl, int platzierung);

	int zeigeZahl() const;
	int zeigePlatzierung() const;

private:
	int m_zahl, m_platzierung;
};

ZahlMitPlatzierung::ZahlMitPlatzierung(int zahl, int platzierung)
: m_zahl(zahl), m_platzierung(platzierung)
{
}

int ZahlMitPlatzierung::zeigeZahl() const
{
    return m_zahl;
}

int ZahlMitPlatzierung::zeigePlatzierung() const
{
    return m_platzierung;
}

//Eine Funktion zur Ermittlung von Zahlenplatzierungen

void ermittleZahlenMitPlatzierung(vector<ZahlMitPlatzierung> &ergebnis, vector<int> zahlen)
{
    vector<int> sortierteZahlen;
    map<int, int> zahlenMitPlatzierung;

    sortierteZahlen.resize(zahlen.size());
    copy(zahlen.begin(), zahlen.end(), sortierteZahlen.begin());
    sort(sortierteZahlen.begin(), sortierteZahlen.end(), greater<int>());

    for (size_t i = 0; i < sortierteZahlen.size(); ++i)
    	zahlenMitPlatzierung[sortierteZahlen[i]] = i;

    for (size_t i = 0; i < zahlen.size(); ++i)
        ergebnis.push_back(ZahlMitPlatzierung(zahlen[i], zahlenMitPlatzierung[zahlen[i]]+1));
}

//Hauptprogramm

int main()
{
    vector<int> dieZahlen;
    vector<ZahlMitPlatzierung> dieZahlenMitPlatzierung;

    dieZahlen.push_back(40);
    dieZahlen.push_back(44);
    dieZahlen.push_back(4);
    dieZahlen.push_back(12);
    dieZahlen.push_back(100);
    dieZahlen.push_back(150);
    dieZahlen.push_back(140);
    dieZahlen.push_back(1);
    dieZahlen.push_back(0);
    dieZahlen.push_back(90);
    //oder noch mehr

    //Platzierungen ermitteln (unabhängig von der Anzahl der Zahlen!!!)
    ermittleZahlenMitPlatzierung(dieZahlenMitPlatzierung, dieZahlen);

    //Anstatt cout zu verwenden, können "Edit-Platzierungsfelder" gefüllt werden
    for (size_t i = 0; i < dieZahlenMitPlatzierung.size(); ++i)
    	cout << "Zahl: " << setw(3)
            << dieZahlenMitPlatzierung[i].zeigeZahl() //einfacher Zugriff über zeigeZahl
            << ",\tPlatzierung: " << setw(2)
            << dieZahlenMitPlatzierung[i].zeigePlatzierung() << "\n"; //einfacher Zugriff über zeigePlatzierung
}

pseudo c# code

SortedList<int, int> allSorted = new SortedList<int, int>();
for(int i = 0; i < allNumbers.Count; ++i)
    allSorted.insert(allNumbers[i], i);
foreach(int number in allNumbers)
    Console.WriteLine("Number: " + number + "; Position: " + allSorted[number]);

duerte mit c++ genauso gehen mit einer std::map
keine manuelle fummelei - sowas nervt doch einfach nur

//dazuedit: seh grad - meine version ist die kurze darstellung was mein vorredner auch macht #gg

warum nicht die zahlen in eine sortierte liste packen, schon hat man die reihenfolge #gg

pseudo c# code

SortedList<int, int> allSorted = new SortedList<int, int>();
for(int i = 0; i < allNumbers.Count; ++i)
    allSorted.insert(allNumbers[i], i);
foreach(int number in allNumbers)
    Console.WriteLine("Number: " + number + "; Position: " + allSorted[number]);

duerte mit c++ genauso gehen mit einer std::map
keine manuelle fummelei - sowas nervt doch einfach nur

ähm, wieso sollte man die liste bei jedem einfügen sortieren lassen, wenn es reicht am ende des einfügens nur 1 mal sortieren zu lassen?

daher wird die performance identisch sein und man kann erst recht das einfachere nehmen find ich {o;

zudem hast du

- einfuegen
- sortieren
- positionen zuweisen

ich habe
- sortiert einfuegen + position zuweisen in einem schritt

koennen ja mal ne umfrage starten was besser ist #ggg

...
Würde es nicht etwas einfacher funktionieren mit einer einfachen if verschachtelung ?

zB.

if (zahl1 > zahl2) <-- so zB.

Das halt nur mit 10 Zahlen

Dann mach's doch einfach.

BTW: 10 Zahlen zu sortieren, braucht per Hand weniger Zeit als Du hier schon im Forum verbracht hast.... oder man macht's per Excel.

Gruß,

Simon2.

Aber die Quellcodes sagen mir nichts und somit kann ich diese nicht in mein Programm einpflegen.

Ich habe die 10 Zahlen vom EditFeld jetzt in 10 Variablen zahl1..zahl10

Diese will ich ganz einfach mit Borland c++ builder vergleichen.
Sodass zB. Neben dem Ersten Editfeld wo die Zahl 150 drin steht ( zahl1 ) eine 1 erscheint ( ebenfallss in einem Editfeld ), da 150 die maximal erreichende Punktezahl ist.

if (zahl1 > zahl2 && zahl1 > zahl2 && zahl1 > zahl3 .....

Nur soweit bis alle 10 Zahlen ihre Platzierungen haben ( Punktegleichheit wäre möglich ).

Kann mir nicht jmd freundlicherweise mir was leichtverständliches sagen ?
Ich bräuchte es sehr dringend, da ich heute abend in der Firma das Programm bedienen soll. Und es wäre sehr hilfreich wenn diese Funktion funktionieren würde.

Danke schonmal an euch.
Mfg

Gruß, smasher

Memo1->Lines->Clear();

zahl1 = Edit51->Text.ToInt();
zahl2 = Edit52->Text.ToInt();
zahl3 = Edit53->Text.ToInt();
zahl4 = Edit54->Text.ToInt();
zahl5 = Edit55->Text.ToInt();
zahl6 = Edit56->Text.ToInt();
zahl7 = Edit57->Text.ToInt();
zahl8 = Edit58->Text.ToInt();
zahl9 = Edit59->Text.ToInt();
zahl10 = Edit60->Text.ToInt();

int iArray[] = {zahl1, zahl2, zahl3, zahl4, zahl5, zahl6, zahl7, zahl8, zahl9, zahl10};

for(int i = 0; i < 10; i++) {
  for(int j = 0; j < (10 - 1); j++) {
    if(iArray[j] > iArray[j + 1]) {
      int iTemp = iArray[j];
      iArray[j] = iArray[j + 1];
      iArray[j + 1] = iTemp;
    }
  }
 }
for(int k = 0;k < 10;k++) {
         Memo1->Lines->Add(iArray[k]); }

Die Editfelder in eine Variable geschrieben
Diese dann in ein Array
Und dann werden diese im Array sortiert und in eine Memo geschrieben

Edit71->Text = Memo1->Lines->IndexOf(zahl1);
int __zahl1 = Edit71->Text.ToInt();
__zahl1 = __zahl1 + 1;
if      (__zahl1 == 10)
                __zahl1 = 1;
else if (__zahl1 == 9)
                __zahl1 = 2;
else if (__zahl1 == 8)
                __zahl1 = 3;
else if (__zahl1 == 7)
                __zahl1 = 4;
else if (__zahl1 == 6)
                __zahl1 = 5;
else if (__zahl1 == 5)
                __zahl1 = 6;
else if (__zahl1 == 4)
                __zahl1 = 7;
else if (__zahl1 == 3)
                __zahl1 = 8;
else if (__zahl1 == 2)
                __zahl1 = 9;
else if (__zahl1 == 1)
                __zahl1 = 10;
Edit61->Text = __zahl1;

Als letztes wird die reihenfolge ausgelesen. Und der dazugehörige Platz im Editfeld ausgegeben.

Klingt vllt. anfängerisch aber anders hätte ich es nicht hinbekommen.
Bzw. ist meine Logik auch nicht die beste

ploRa schrieb:

...

#include <algorithm>

Memo1->Lines->Clear();

{
   int iArray[10] = {Edit51->Text.ToInt(),
      Edit52->Text.ToInt(),
      Edit53->Text.ToInt(),
      Edit54->Text.ToInt(),
      Edit55->Text.ToInt(),
      Edit56->Text.ToInt(),
      Edit57->Text.ToInt(),
      Edit58->Text.ToInt(),
      Edit59->Text.ToInt(),
      Edit60->Text.ToInt()};

      std::sort(iArray, iArray+10);
      for(int k = 0;k < 10;k++) {
         Memo1->Lines->Add(iArray[k]); 
      }
}

?
(mal abgesehen davon, dass ich die "10" noch durch eine entsprechende Konstante ersetzen würde)

Gruß,

Simon2.

P.S.: Und was spricht gegen die richtige Tags ("C/C++" statt "Code") ?