3. Lottozahlen als Array

Lottozahlen als Array

  • P
     

    #include <iostream>
#include <cstdlib> 
#include <ctime>

using namespace std;

int main()
{
    int lotto[6];
    int i, j;
    bool neueZahl;

    srand(time(0));
    for(i=0; i<6; i++) 
    {
        do  
        {   
            lotto[i] = rand() % 49 + 1;
            neueZahl = true; 
            for (j=0; j<i; j++)
            {  
                if (lotto[j]==lotto[i])
                { 
                    neueZahl = false;
                }
            }
        } while (!neueZahl);
    }
    for (i=0; i<6; i++)
    {
        cout << lotto[i] << " ";
    }
    cout << endl;
    system("PAUSE");
}

    Was ich an diesem Programm nicht verstehe ist WIE, bzw. wann, speichert das Programm die zufällig generierten Zahlen in die lotto[j] Felder?
    Arbeite dieses Programm mit einem Debugger-Einzelschritt Verfahren durch und versuche das Programm zu verstehen, jedoch sehe ich nur einen Vergleich zwischen lotto[j] und lotto[i] und keine Zuweisung.

    Eine andere Sache wäre die "srand(time(0));" Sache, hab etwas länger gebraucht bis ich verstanden habe, dass immer die gleiche Zahlenfolge kommt, wenn "srand(0)" eingetragen ist, wobei das mit dem "time"-Attribut auch nur funktioniert, wenn der zugehörige #include vorhanden ist.
    Diese Sache ist wahrscheinlich einfach so, kann man denke ich auch nicht wirklich gut erklären.

    Interessieren würde mich wirklich diese Sache mit der jeweiligen lotto[j] Zuweisung, bzw. den Prozess der Zuweisung und Speicherung der jeweiligen lotto[i] Werte auf den lotto[j] Feldern, jemand eine Idee?

    0
  • S

    Peng(uin) schrieb:

    lotto[i] = rand() % 49 + 1;

    0
  • Mod

    SG1 schrieb:

    Peng(uin) schrieb:

    lotto[i] = rand() % 49 + 1;

    Ich glaube, so einfach ist die Antwort nicht. Der Threadersteller glaubt, lotto[i] und lotto[j] wären was unterschiedliches. Jedoch weiß ich da drauf auch nicht so recht etwas zu erwiedern, außer dass er Felder völlig falsch verstanden hat und ein gutes Buch braucht, denn krasse solche Missverständnisse dürfen bei einem Programmierkurs nie auftreten.

    0
  • T

    Hallo,
    der Code-Snipped speichert die Zufahlszahl in der Zeile 18. Wie bereits schon erklährt worden ist.

    Ein kleiner Erleuterungsversucht
    z.B ist in ersten Durchlauf i = 0;
    lotto[0] zeigt auf die erste Stelle im Array.
    ("[]" wird auch als Indexoperatior bezeichnet)
    Das einfache "=" ist der Zuweisungsoperator.
    Sommit setzt man die erste Stelle im Array mit array[0] = variable.

    rand() liefert einen "zufälligen" numärischen Wert.
    Dieser Wert Modulo 49 liefert immer eine Zahl zwischen 0 und 48. Daher muss das Ergebnis mit +1 erhöhen werden, um auf die Lottozahlen zu kommen (1 - 49).

    Mit srand kann man den Startwert der Zufalszahlen definieren.
    Der aktuelle Zeitpunkt des Programmdurchlaufs brind genügend variants für Lotto-Zahlen.

    P.s if (lotto[j]==lotto[i]) wird nur dazu verwendet um die Abbruchbedingung der Schleif zu definieren, kannst du mir erklählren wozu er das benötigt? 🙂

    Ich hoffe die Schlagworte reichen dir, um dir ein besseres Verständinis via google&co aneignen zu können.

    mfg
    Thomas

    0
  • P

    SeppJ schrieb:

    SG1 schrieb:

    Peng(uin) schrieb:

    lotto[i] = rand() % 49 + 1;

    Ich glaube, so einfach ist die Antwort nicht. Der Threadersteller glaubt, lotto[i] und lotto[j] wären was unterschiedliches. Jedoch weiß ich da drauf auch nicht so recht etwas zu erwiedern, außer dass er Felder völlig falsch verstanden hat und ein gutes Buch braucht, denn krasse solche Missverständnisse dürfen bei einem Programmierkurs nie auftreten.

    Um ehrlich zu sein trifft das den Punkt völlig, arbeite gerade ein Buch durch "Einstieg in C++", es gab vor dieser Aufgabe einen Abschnitt mit Feldern, dieser Punkt wurde aber meiner Ansicht nach nicht erklärt.

    Hab jetzt versucht mit dem Programm mehr Werte beim Debugging anzuzeigen, bei den lokalen Werten bleibt dann zumindest das lotto[6] Feld offen und verschwindet nicht ständig.

    Habe versucht das Programm umzustellen, sodass es auch dieses lotto[j] Feld in seinen sechs Teilen auflistet, aber keine Chance.

    Bin mir jetzt auch nicht wirklich sicher was ich machen soll, wahrscheinlich nochmal den Abschnitt im Buch lesen, ein weiterer Post folgt noch.

    0
  • Mod

    Peng(uin) schrieb:

    Hab jetzt versucht mit dem Programm mehr Werte beim Debugging anzuzeigen, bei den lokalen Werten bleibt dann zumindest das lotto[6] Feld offen und verschwindet nicht ständig.

    Habe versucht das Programm umzustellen, sodass es auch dieses lotto[j] Feld in seinen sechs Teilen auflistet, aber keine Chance.

    Nein! Nein! Nein! Du hast so total falsche Vorstellungen von Arrays, das stimmt überhaupt nicht, was du denkst, was hier passiert. Darum klappt auch nichts.
    Aber solche Grundlagen erkläre ich nicht, das liest du dir bitte selber an. Oder vielleicht hast du Glück und jemand anderes mag dir Felder erklären (Und schonmal im Voraus an Pi: std::vector würde hier nicht helfen 😃 ).

    0
  • ?

    Vielleicht ist dieses Minibeispiel der nötige klapps auf den hinterkopf

    //ein array mit 6 "plätzen" ... nummeriert von 0 bis 5 
int lotto[6];

//alle felder durchiterieren, lotto[0] ..1,2,3,4,5 ... und jeweils 0,1,2,3,4,5 zuweisen
for(int i=0; i < 6; i++)
{
    lotto[i] = i;
}
    0
  • K

    Die Zuweisungen finden in der 18. Zeile statt.

    Peng(uin) schrieb:

    Hab jetzt versucht mit dem Programm mehr Werte beim Debugging anzuzeigen, bei den lokalen Werten bleibt dann zumindest das lotto[6] Feld offen und verschwindet nicht ständig.

    lotto[6] ist kein Feld. lotto ist ein Feld.

    Peng(uin) schrieb:

    Habe versucht das Programm umzustellen, sodass es auch dieses lotto[j] Feld in seinen sechs Teilen auflistet, aber keine Chance.

    lotto[j] ist kein Feld. lotto ist ein Feld. lotto[j] ist das j-te Element des Feldes lotto (für j=0, 1, ..., 5 -- da lotto 6 Elemente umfasst).

    0
  • P

    Danke für eure Antworten.

    Hab mir die Sache nochmal durchgelesen, im Endeffekt verstehe ich folgendes :

    Array = Kombination mehrerer Variablen gleichen Typs.
    Elemente = Die Elemente des Arrays werden über ihre Positionsnummer angesprochen.

    Aufbau = Typ des Elementes, Name des Arrays, eckige Klammer mit der Anzahl der Elemente, die das Array maximal aufnehmen kann : int lotto [6].
    Damit wird der Speicher für die sechs Integer angefordert und reserviert.

    Position = In eckigen Klammern wird die Position des Elementes angegeben, auf welches man (z.B.) zugreifen will : lotto[2] = rand() % 49+1, drittes Element wird mit einer Zufallszahl gefüllt.

    Positionsnummer = Index, beginnt immer mit 0.

    --- --- ---

    Es scheint so zu sein, als wären j und i die gleichen Elemente des gleichen Feldes "lotto", die aber durch verschiedene Variablen angesprochen werden.
    Somit greift man aus "verschiedenen Richtungen" auf die gleichen Elemente, bzw. Speicher zu, (vom Feld lotto).

    Demnach ist hier lotto[i] die Variable die immer neue Zahlen produziert und lotto[j] eine Variable die die Werte des lotto-Feldes speichert und nicht verändert, es dient zum Vergleich und löscht die Elemente/Werte auch nicht, da die for-Schleife nicht verlassen wird.

    Komme ich der Wahrheit etwas näher?

    0
  • *

    Der erste Teil ist korrekt. Allerdings sind j und i nicht Elemente eines Feldes, sondern nur variable Zahlen, die ein bestimmtes Element ansprechen.
    lotto[i] produziert nichts. Deine Schleife produziert auch nichts - sie verändert nur die Variablen (i bzw. j) und greift somit bei jedem Durchlauf auf ein anderes Element des Feldes zu. Und genau in diesem Schritt wird ein neuer Wert am i-ten Element gespeichert. Mit der j-Schleife gehst du noch mal das ganze Array durch und guckst, ob es diesen (neuen) Wert schon gibt.

    0
  • P

    [Rewind] schrieb:

    Der erste Teil ist korrekt. Allerdings sind j und i nicht Elemente eines Feldes, sondern nur variable Zahlen, die ein bestimmtes Element ansprechen.
    lotto[i] produziert nichts. Deine Schleife produziert auch nichts - sie verändert nur die Variablen (i bzw. j) und greift somit bei jedem Durchlauf auf ein anderes Element des Feldes zu. Und genau in diesem Schritt wird ein neuer Wert am i-ten Element gespeichert. Mit der j-Schleife gehst du noch mal das ganze Array durch und guckst, ob es diesen (neuen) Wert schon gibt.

    Genau, variable Zahlen/bzw. Variablen die sich auf die jeweiligen Elemente beziehen.

    Der Knackpunkt war also, dass verschiedene Variablen sich auf die gleichen Elemente eines Feldes, bzw. auf die gleichen Werte der jeweiligen Elemente, beziehen.
    Es war mir nicht klar, dass wenn ich für lotto[i] einen Wert für ein Element zuweise, dieses auch für lotto[j], oder von mir aus auch lotto[Luftpumpe], definiert wird.
    Weiterhin war mir nicht klar, wann genau diese Zuweisungen für z.B. die lotto[j] Elemente stattfindet, anscheinend werden die Werte automatisch "mitzugewiesen" wenn die Werte für die Elemente von lotto[i] zugewiesen werden.

    Stelle mich wahrscheinlich extrem langsam und dumm an, bin mir nicht sicher wieso es mir so schwer fällt die Sache zu verstehen, hoffentlich ist es so richtig verstanden worden.

    0
  • *

    Zuweisungen finden statt, wenn du Variable = Wert/Funktion/etc. hast.

    P.S. Der Anfang ist nicht immer leicht.

    0
Anmelden zum Antworten