3. Sortierung von Zahlen

Sortierung von Zahlen

  • H

    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

    0
  • U

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

    aber ich bau sie mal noch mit ein...

    0
  • D

    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 ?

    0
  • H

    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... 😞

    0
  • H

    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

    0
  • D

    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;
}
    0
  • H

    DeepCopy schrieb:

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

    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] 
         } 
     }

    Das verstehe ich noch nicht so ganz 😕

    0
  • _

    huso schrieb:

    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] 
         } 
     }

    Das verstehe ich noch nicht so ganz 😕

    Da werden einfach die zwei Elemente lotto[i] und lotto[j] getauscht (zum Zweck der aufsteigenden Sortierung).

    Am einfachsten versteht man Programmabläufe, indem man sich an gewissen Stellen Breakpoints (Haltepunkte) setzt und mit dem Debugger schrittweise durch das Programm geht. Dabei kann man sich dann alle Variableninhalte ansehen. Das solltest du vielleicht mal machen.

    0

  • EDIT: blödsinn geschrieben 😃

    0
  • _

    It0101 schrieb:

    EDIT: blödsinn geschrieben 😃

    Glück gehabt! Normalerweise zitiere ich Blödsinn gerne, bevor er gelöscht wird. 😃 😉

    0

  • _matze schrieb:

    It0101 schrieb:

    EDIT: blödsinn geschrieben 😃

    Glück gehabt! Normalerweise zitiere ich Blödsinn gerne, bevor er gelöscht wird. 😃 😉

    ich weiß. Im allgemeinen wird das sofort brutalst-möglich ausgenutzt, wenn man mal auf Zeug von Seite 1 antworten will und man dabei vergisst, dass das Thema schon bis Seite 4 fortgeschritten ist 😃

    naja es ist früh...
    es ist freitag...
    und ich bin auch schon fast 30... 😡

    0
  • D

    huso schrieb:

    Das verstehe ich noch nicht so ganz 😕

    if (lotto[i] > lotto[j])
{
    int temp = lotto[j];
    lotto[j] = lotto[i];
    lotto[i] = temp;    
}

    Stellen wir uns ein unsortiertes Array mit Zahlen vor etwa so:

    +-+-+-+-+-+
 |9|2|5|4|8|
 +-+-+-+-+-+

    dann findet im jedem Durchlauf folgende Sortierung statt:

    i = 0 (Anfangszustand)
 +-+-+-+-+-+
 |9|2|5|4|8|
 +-+-+-+-+-+
  |
     // wir betreten die innere Scheife j = 0 + 1 (Anfangszustand)
     // jetzt prüfen wir lotto[i] > lotto[j] - und tauschen wenns so ist
     j = 0 + 1    
     +-+-+-+-+-+
     |2|9|5|4|8| ( 2 <-> 9 )
     +-+-+-+-+-+
      | ^

     j = 1 + 1
     +-+-+-+-+-+
     |2|9|5|4|8| (keine Vertauschung)
     +-+-+-+-+-+
      |   ^ 

     j = 2 + 1
     +-+-+-+-+-+
     |2|9|5|4|8| (keine Vertauschung)
     +-+-+-+-+-+
      |     ^

     j = 3 + 1
     +-+-+-+-+-+
     |2|9|5|4|8| (keine Vertauschung)
     +-+-+-+-+-+
      |       ^

     // hier ist der Schleifendurchlauf für j beendet
     // und loop[i] enthält hat garantiert die kleinste Zahl 

 // auf die nächste Position
 i = 1 
 +-+-+-+-+-+
 |2|9|5|4|8|
 +-+-+-+-+-+
    |

     // ab jetzt ohne ausführliche Kommentare 
     j = 1 + 1
     +-+-+-+-+-+
     |2|5|9|4|8| ( 9 <-> 5 )
     +-+-+-+-+-+
        | ^ 

     j = 2 + 1   
     +-+-+-+-+-+
     |2|4|9|5|8| (5 <--> 4)
     +-+-+-+-+-+
        |   ^
     j = 3 + 1
     +-+-+-+-+-+
     |2|4|9|5|8| (keine Vertauschung)
     +-+-+-+-+-+
        |     ^
 i = 2
 +-+-+-+-+-+
 |2|4|9|5|8|
 +-+-+-+-+-+
      |

     j = 2 + 1
     +-+-+-+-+-+
     |2|4|5|9|8| ( 9 <-> 5 )
     +-+-+-+-+-+
          | ^
     j = 3 + 1
     +-+-+-+-+-+
     |2|4|5|9|8| (keine Vertauschung)
     +-+-+-+-+-+
          |   ^
 i = 3  
 +-+-+-+-+-+
 |2|4|5|9|8|
 +-+-+-+-+-+
        |

     j = 3 + 1
     +-+-+-+-+-+
     |2|4|5|8|9| ( 9 <-> 8)
     +-+-+-+-+-+
            | ^

// die äussere Schleife for(int i = 0; i < 5 -1; i++) wird hier verlassen
// und damit ist das Sortieren beendet weil in diesem 
// Beispiel( i < (5 - 1)) | i < 4, denn unser Beispiel array 
// auch nur 5  Elemente

    Das ist der Sortiervorgang, wenn du ihn noch nicht verstehst dann siehe dir Zeile für Zeile und versuche das Nachzuvollziehen, mal dir ein Array mit 4-6 Elemente auf ein Blatt Papier mit Bleistift und vertausche
    diese mal selbst.

    Aber einfach gesprochen passiert das:
    "Ich Zeige mit meinem linken finger auf eine Stelle und fahre mit dem rechten Finger über das Array, immer wenn mein rechter Finger auf eine Zahl stösst die größer ist, als die Zahl unter meinem linken Finger, tausche ich die Zahlen miteinander. Das mache ich dann für jede Postion im Array von links nach rechts"

    0
Anmelden zum Antworten