Sortierung von Zahlen

[_matze]

DeepCopy schrieb:

Ohne Gewähr und vor allem Effizienz, siehe dazu die allseits bekannten alten Verwandten: Shell-Sort, Quick-Sort, Heap-Sort

const int Max_Zahlen = 200;
int lotto[Max_Zahlen];

for (int i = 0; i < Max_Zahlen - 1; i++)
  for (int j = i+1; j < Max_Zahlen ; j++)
  {
     if (lotto[i]>lotto[j])
     {
       int temp = lotto[j]
       lotto[j] = lotto[i]
       lotto[j] = temp;
     }
  }

Grüssle DC!

Wenn es ihm ums selbst machen geht, braucht er keine Komplettlösung, die ist dem Lernen eher weniger zuträglich. Ich hoffe, er macht es selbst (und lernt dabei ne Menge).

[DeepCopy]

Na ja, das Schleifenkonstrukt ist jetzt nicht sooo... gut, oder? Ausserdem muss er noch seinen Code einfügen, um die Schleife richtig zu bedienen, ach... und mir war halt einfach langweilig

[huso]

DeepCopy schrieb:

Na ja, das Schleifenkonstrukt ist jetzt nicht sooo... gut, oder? Ausserdem muss er noch seinen Code einfügen, um die Schleife richtig zu bedienen, ach... und mir war halt einfach langweilig

bin überfordert... gebe auf und vergess das mal liebe

[DeepCopy]

Hey, lass dich nicht entmutigen, zeig doch mal was du bisher gemacht hast.

[huso]

DeepCopy schrieb:

Hey, lass dich nicht entmutigen, zeig doch mal was du bisher gemacht hast.

das von dir hab ich nicht kopiert die for anweisung hatte ich schon....

#include <ctime>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
	int lotto[6];
    int i, j;
    bool neueZahl;

    srand(static_cast<int>(time(0)));rand();
    for (int i = 0; i < lotto[6] - 1; i++)
    {
        do
        {
            lotto[i] = rand() % 45 + 1;
            neueZahl = true;
        	for (int j = i+1; j < lotto[6] ; j++)

        	{
                if (lotto[j]==lotto[i])
                	{
                    neueZahl = false;
                	}
			}
         }
     }

        while (!neueZahl);

        cout << lotto[i] << " ";
     }
        cout << endl;

    return 0;

[DeepCopy]

for (int i = 0; i < lotto[6] - 1; i++)

Dann fangen wir mal bei der Zeile an, was glaubst passiert hier ?

[huso]

DeepCopy schrieb:

for (int i = 0; i < lotto[6] - 1; i++)

Dann fangen wir mal bei der Zeile an, was glaubst passiert hier ?

die überprüfung?

[DeepCopy]

Richtig eine Überprüfung:

aber du hast deinen Code so geschrieben:

int lotto[6]; // du hast ein Array mit 6 int elementen 
                // und einen index von 0 - 5, weil man 
                // bei arrays bei 0 (zero based) beginnt zu zählen

  // jetzt versuchst du aber folgendes, was auch 
  //semantisch falsch ist das aber später
  for (int i = 0; i < lotto[6] - 1; i++) 
   ...

[DeepCopy]

Was du eigentlich möchtest ist die Zahlen in deinem
Array zu sortieren:

int lotto[6];

// würdest du so zugreifen dann kann in lotto[5] alles 
// mögliche drinn stehen
for (int i = 0; i < lotto[5] - 1; i++) 

// du willst aber nur bis zu Arraygrenze sortieren
for (int i = 0; i < 6 /* 0 - 5 */ ; i++)

Hast du das verstanden ?

[huso]

DeepCopy schrieb:

Was du eigentlich möchtest ist die Zahlen in deinem
Array zu sortieren:

int loop[6];

// würdest du so zugreifen dann kann in lotto[5] alles 
// mögliche drinn stehen
for (int i = 0; i < lotto[5] - 1; i++) 

// du willst aber nur bis zu Arraygrenze sortieren
for (int i = 0; i < 6 /* 0 - 5 */ ; i++)

Hast du das verstanden ?

soweit so gut

[unskilled]

#include <algorithm> //sort
#include <cstdlib> //rand / srand
#include <ctime> //time
#include <iostream> //cout

using namespace std; 

const int LOTTO_ZAHLEN_COUNT = 6;
const int LOTTO_ZAHL_MAX = 49;

int main()
{ 
  int lotto[ LOTTO_ZAHLEN_COUNT ]; //hier wird das feld deklariert, wo die zahlen später gespeichert werden...

  srand(static_cast<int>(time(0))); //der zufallszahlengenerator wird initialisiert

  for(int i = 0; i < LOTTO_ZAHLEN_COUNT; i++) //über alle zahlen:
  { 
    bool neue_zahl;
    do
    {
      neue_zahl = true;
      lotto[i] = rand() % LOTTO_ZAHL_MAX + 1; 
      for(int j = 0; j < i; ++j) //für alle schon erzeugten zufallszahlen
      {  //damit wir keine doppelten zahlen bekommen
        if (lotto[j] == lotto[i]) 
        {
          neue_zahl = false;
        }
      } 
    } while(! neue_zahl); //neue_zahl == false
  } 

  sort(&lotto[0], &lotto[LOTTO_ZAHLEN_COUNT]); //sortieren

  for(int i = 0; i < LOTTO_ZAHLEN_COUNT; i++) //über alle zahlen:
    cout << lotto[i] << " "; //ausgabe der zahl

  //schließen der konsole verhindern
}

statt den konstanten kannst du auch weiterhin die zahlen nehmen - nur hattest du einmal 45 statt 49 und außerdem denke ich, dass man den quelltext so besser verstehen kann...

bb

PS: sry DC, aber ich hatte lange Weile ;o)
edit: sortieren eingefügt...

[Bubblesort0r]

Alle Sortierungen mit Erlärung findest du im kostenlosen OpenBook "C von A bis Z", Google benutzen!

[DeepCopy]

Ok, jetzt zum harten Teil:

Nebenbei:

lotto[i] = rand() % 45 + 1; // Ist lotto nicht 6 aus 49 ?

Du willst das Array noch nicht sortieren, sondern erstmal mit Zahlen füttern,
und zwar mit eindeutigen (unique) Zahlen.

Dafür brauchst du natürlich kein Sortieralgorithmus sondern einen Vergleichsalgorithmus:

Also benötigst du eine Scheife in der Neue Zahlen generiert werden und in das Array eingetragen
werden, wenn sie nocht nicht im Array sind.

Hmm.. ich sehe gerade unskilled hat fertigen code gepostet ... willst du trotzdem weiter machen?

[huso]

DeepCopy schrieb:

Ok, jetzt zum harten Teil:

Nebenbei:

lotto[i] = rand() % 45 + 1; // Ist lotto nicht 6 aus 49 ?

Du willst das Array noch nicht sortieren, sondern erstmal mit Zahlen füttern,
und zwar mit eindeutigen (unique) Zahlen.

Dafür brauchst du natürlich kein Sortieralgorithmus sondern einen Vergleichsalgorithmus:

Also benötigst du eine Scheife in der Neue Zahlen generiert werden und in das Array eingetragen
werden, wenn sie nocht nicht im Array sind.

Hmm.. ich sehe gerade unskilled hat fertigen code gepostet ... willst du trotzdem weiter machen?

gerne.... das hilft mir mehr... also nur wenn du zeit hast natürlich

[huso]

unskilled schrieb:

#include <cstdlib> //rand / srand
#include <ctime> //time
#include <iostream> //cout

using namespace std; 

const int LOTTO_ZAHLEN_COUNT = 6;
const int LOTTO_ZAHL_MAX = 49;

int main()
{ 
  int lotto[ LOTTO_ZAHLEN_COUNT ]; //hier wird das feld deklariert, wo die zahlen später gespeichert werden...

  srand(static_cast<int>(time(0))); //der zufallszahlengenerator wird initialisiert

  for(int i = 0; i < LOTTO_ZAHLEN_COUNT; i++) //über alle zahlen:
  { 
    bool neue_zahl;
    do
    {
      neue_zahl = true;
      lotto[i] = rand() % LOTTO_ZAHL_MAX + 1; 
      for(int j = 0; j < i; ++j) //für alle schon erzeugten zufallszahlen
      {  //damit wir keine doppelten zahlen bekommen
        if (lotto[j] == lotto[i]) 
        {
          neue_zahl = false;
        }
      } 
    } while(! neue_zahl); //neue_zahl == false
  } 

  for(int i = 0; i < LOTTO_ZAHLEN_COUNT; i++) //über alle zahlen:
    cout << lotto[i] << " "; //ausgabe der zahl

  //schließen der konsole verhindern
}

statt den konstanten kannst du auch weiterhin die zahlen nehmen - nur hattest du einmal 45 statt 49 und außerdem denke ich, dass man den quelltext so besser verstehen kann...

bb

PS: sry DC, aber ich hatte lange Weile ;o)

funktioniert nicht aso die sortierung findet gar nicht statt

[unskilled]

Für die Sortierung hab ich bei dir im Quelltext auch keinen Hinweis gefunden^^

aber ich bau sie mal noch mit ein...

[DeepCopy]

Ok, dann weiter was im letzten post stand ist klar, oder? Sonst einfach nochmal fragen.

Also benötigst du eine Scheife in der neue Zahlen generiert werden und in das Array eingetragen
werden, wenn sie nocht nicht im Array sind.

Also bauen wir das mal ganz einfach auf:

// als erstes definieren wir mal eine Konstante für unser Array
  const int constLottoZahlen = 6;

  // das wird von jetzt an überall verwendet
  int lotto[constLottoZahlen]; // hier wird jetzt ein Array von 6 int Elementen erstellt

  // jetzt entwickeln wir die Schleife 
  for (int i = 0; i < constLottoZahlen; i++) // wir laufen den Arrayindex von 0 - 5 durch
  {
    // bei jedem Durchlauf brauchen wir eine Zufallszahl
    // ... Das müssen wir hier machen ...

    // jede gezogene Zahl muss aber noch mit dem Array verglichen werden
    // ob diese schon vorhanden ist, dafür brauchen wir noch eine Schleife
    // j = 0 - immer vom Anfang des Arrays 
    // j < constLottoZahlen - bis vor die aktuelle Position von i die brauchen wir nicht zu überprüfen
    for (int j = 0; j < i-1; j++)
    {
      //hier findet der Vergleich statt
      // ... da müssen wir was machen ...
    }
  }

Auch verstanden ?

[huso]

DeepCopy schrieb:

Ok, dann weiter was im letzten post stand ist klar, oder? Sonst einfach nochmal fragen.

Also benötigst du eine Scheife in der neue Zahlen generiert werden und in das Array eingetragen
werden, wenn sie nocht nicht im Array sind.

Also bauen wir das mal ganz einfach auf:

// als erstes definieren wir mal eine Konstante für unser Array
  const int constLottoZahlen = 6;
  
  // das wird von jetzt an überall verwendet
  int lotto[constLottoZahlen]; // hier wird jetzt ein Array von 6 int Elementen erstellt

  // jetzt entwickeln wir die Schleife 
  for (int i = 0; i < constLottoZahlen; i++) // wir laufen den Arrayindex von 0 - 5 durch
  {
    // bei jedem Durchlauf brauchen wir eine Zufallszahl
    // ... Das müssen wir hier machen ...

    // jede gezogene Zahl muss aber noch mit dem Array verglichen werden
    // ob diese schon vorhanden ist, dafür brauchen wir noch eine Schleife
    // j = 0 - immer vom Anfang des Arrays 
    // j < constLottoZahlen - bis vor die aktuelle Position von i die brauchen wir nicht zu überprüfen
    for (int j = 0; j < i-1; j++)
    {
      //hier findet der Vergleich statt
      // ... da müssen wir was machen ...
    }
  }

Auch verstanden ?

bei mir führt es zum absturz... hab ich sicher einige fehler gemacht...

[huso]

unskilled schrieb:

Für die Sortierung hab ich bei dir im Quelltext auch keinen Hinweis gefunden^^

aber ich bau sie mal noch mit ein...

ok danke

[DeepCopy]

Nein das geht natürlich nicht, es ist doch Pseudo-Code!

Ich schreibe dir jetzt mal den fertigen Code hin, dann wenn du Fragen hast ist es vielleicht einfacher Sie zu lösen!

#include <iostream> // cin cout
#include <cstdlib>  // srand

using namespace std; // damit müssen wir nicht immer std:: vor cin oder cout schreiben

// das ist er Einstiegspunkt für unser Programm,
// diese Funktion wird immer als erstes aufgerufen!
int main()
{
    const int constLottoZahlen = 6;   // die Anzahl der Lottozahlen die wir
                                      // suchen (spiel mal damit)

    const int constAlleZahlen  = 49;  // alle möglichen Lottozahlen im Topf

    int lotto[constLottoZahlen];      // enthält alle gezogenen Lottozahen

    // Wir müssen den Zufallsgenerator initialisieren, damit der Zufall,
    // Zufall wird (ist aber trotzdem kein echter Zufall)
    srand(static_cast<int>(time(0)));

    // diese Schleife wird constLottoZahlen suchen
    for (int i = 0; i < constLottoZahlen; i++)
    {
        // wir brauchen immer eine neue Zufallszahl
        // die speichern wir praktischerweise gleich
        // auf dem nächsten freien Speicherplatz
        // rand liefert Zahlen von 0 - (größt möglicher
        // integer auf dem Rechner)
        lotto[i] = (rand() % constAlleZahlen) +1;

        // jetzt müssen wir prüfen ob die Zahl die wir gezogen
        // schon im array lotto vorhanden ist, und damit auch
        // das array durchsuchen
        // wir vergleichen also von j = 0 bis j= (ein Feld VOR der "Neuen Zahl" in lotto[i])
        // lotto[i] == lotto[j] braucht nicht mit sich selbst verglichen zu werden.
        for (int j = 0; j < i; j++)
        {
              // neue zahl   ist schon    im array?
            if (lotto[i]         ==        lotto[j])
            {
                // dann setze i wieder um -1 zurück und lasse
                // im nächsten Schleifendurchlauf eine
                // neue Zufallszahl für lotto[i] berechen
                i--;
                break; // Abbruch der for-schleife, weitere
                       //  Vergleiche mit i wären böse... :)
            }
        }
    }

    // wir wollen jetzt noch die Ausgabe sortieren
    // wir nehmen das erste int element und vergleichen
    // es mit allen anderen, es gibt natürlich auch bessere
    // Sortieralgorithmen aber der soll reichen.

    // wir verglichen immer vom anfang des arrays
    // und stellen NACH jedem Schleifendurchlauf
    // sicher, das sich loop[i] das kleinste Element
    // befindet
    for (int i = 0; i < constLottoZahlen-1; i++)
      // für den Vergleich brauchen wir immer nur
      // das nächste Element von loop[i] zu prüfen
      // da ja alle elemente vorher kleiner sind
      for (int j = i+1 ; j < constLottoZahlen; j++)
      {
         // jetzt vergleichen wir ob es im lotto[j] ein
         // Element gibt das das kleiner als lotto[i], das brauchen
         // wir, und wenn es so ist ist, dann tauschen
         // lotto[j] und lotto[i] die Plätze. In lotto[i] ist jetzt
         // garantiert das kleinste element bis zur position loop[j]
         // DIESES Schleifendurchlaufs, es können also noch weitere
         // Vertauschungen in dieser Schleife folgen.
         if (lotto[i] > lotto[j])
         {
             // lotto[i] <--> lotto[j]
             int temp = lotto[j]; // das wird noch für lotto[i] gebraucht
             lotto[j] = lotto[i]; // überschreiben von lotto[j]
                                  // lotto[i] geht an den Platz von lotto[j]
             lotto[i] = temp;     // der Wert von lotto[j] geht an den Platz
                                  // von lotto[i]
         }
     }

    for (int i = 0; i < constLottoZahlen; i++)
     cout << "Zahlen: " << lotto[i] << endl;
    // kleiner Spass :=)
    cout << "SuperZahl: " << rand() % 10 << endl;
}

Komprimiert ohne Kommentar sieht der Code dann so aus:

#include <iostream> // cin cout
#include <cstdlib>  // srand

using namespace std; 

int main()
{
    const int constLottoZahlen = 6;   
    const int constAlleZahlen  = 49;  
    int lotto[constLottoZahlen];      

    srand(static_cast<int>(time(0)));

    for (int i = 0; i < constLottoZahlen; i++)
    {
        lotto[i] = (rand() % constAlleZahlen) +1;
        for (int j = 0; j < i; j++)
        {
            if (lotto[i] == lotto[j])
            {   
                i--; 
                break; 
            }
        }
    }

    for (int i = 0; i < constLottoZahlen-1; i++)
      for (int j = i+1 ; j < constLottoZahlen; j++)
      {
         if (lotto[i] > lotto[j])
         {
             int temp = lotto[j]; 
             lotto[j] = lotto[i]; 
             lotto[i] = temp;     
         }
     }

    for (int i = 0; i < constLottoZahlen; i++)
     cout << "Zahlen: " << lotto[i] << endl;

    cout << "SuperZahl: " << rand() % 10 << endl;
}