Fuß­ball­tipp

Lese­zeit: 6 Minu­ten
Lösung
Seite als PDF
Navi­ga­ti­on

Im Seri­el­len Moni­tor sol­len zufäl­lig aus­ge­wähl­te Spie­le mit zufäl­li­gen Ergeb­nis „getippt“ wer­den, anschlie­ßend wer­den die Punk­te ver­ge­ben.
Außer­dem kön­nen die Gesamt­punk­te jeder Mann­schaft ange­zeigt wer­den.
So sieht es aus:

Spie­le
Tabel­le

Für die­se Anlei­tung brauchst du nur den Arduino.

Defi­nie­re die ➨ Arrays und die Varia­blen. Beach­te die Kommentare.

// die Mannschaften
// \u00fc = ü
// \u00f6 = ö

// Größe der Arrays: muss als Konstante definiert werden
const byte AnzahlMannschaften = 18;

// Array wird benötigt, um zwei unterschiedliche Mannschaften zu bestimmen
int ZufallsZahlen[AnzahlMannschaften];

// Arrays für Punkte und Tore
int AnzahlPunkte[AnzahlMannschaften];
int AnzahlTore[AnzahlMannschaften];

// Array der Mannschaften
String Mannschaften[AnzahlMannschaften] =
{
  "Mainz 05", "RB Leipzig", "Arminia Bielefeld", "Union Berlin",
  "VFL Bochum", "VFL Wolfsburg", "Borussia Dortmund", "Bayern M\u00fcnchen",
  "Eintracht Frankfurt", "Hertha BSC", "Borussia M\u00f6nchengladbach",
  "1. FC K\u00f6ln", "SC Freiburg", "Greuther F\u00fcrth",
  "Bayer Leverkusen", "FC Augsburg", "1899 Hoffenheim", "VFB Stuttgart"
};

// Anzahl der Tore Minimum/Maximum
int Minimum = 0;
int Maximum = 4;

Der setup-Teil zeigt das Menü und star­tet den Zufallsgenerator:

void setup()
{
  Serial.begin(9600);

  // auf serielle Verbindung warten
  while (!Serial) { ; }
  delay(500);

  // Info
  Serial.println("Ergebnisse tippen: -> <s>");
  Serial.println("Gesamtpunkte anzeigen: -> <t>");
  Serial.println("-------------------------------------------");

  // Zufallsgenerator starten
  randomSeed(analogRead(0));
}

Der loop-Teil. Beach­te die Kommentare.

void loop()
{
  // auf serielle Eingabe warten
  while (Serial.available() > 0)
  {
    // Eingabe im Seriellen Monitor lesen
    String Zeichen = Serial.readStringUntil('\n');
    {
      // Spielpaarung ziehen
      if (Zeichen == "s")
      {
        // 2 unterschiedliche Mannschaften bestimmen
        for (int i = 0; i < 2; i ++)
        {
          /*
            die Mannschaft gilt solange als bereits gezogen
            bis in der for-Schleife nachgewiesen wird, dass sie neu ist
            und BereitsGezogen den Wert false hat
          */
          bool BereitsGezogen = true;
          while (BereitsGezogen)
          {
            // Zahl ziehen
            ZufallsZahlen[i] = random(0, AnzahlMannschaften);
            BereitsGezogen = false;           
           /*
              Zufallszahl mit den bereits gezogenen Zahlen vergleichen
              i wird in der ersten for-Schleife hochgezählt
              alle bisherigen Zahlen (ii) werden mit den bisher gezogenen Zahlen
              (außer der gerade gezogenen) verglichen (ii < i)
              ist sie identisch, erhält BereitsGezogen den Wert true
              es wird erneut eine Zufallszahl bestimmt
              wenn die Zahl neu ist, (BereitsGezogen hat noch den Wert false)
              wird die while-Schleife verlassen und die nächste Zahl
              gezogen
            */
            for (int ii = 0; ii < i; ii ++)
            {
              if (ZufallsZahlen[i] == ZufallsZahlen[ii]) BereitsGezogen = true;
            }
          }
        }

        /*
          nach Aufruf der Funktion steht ein Array mit 2 Elementen zur Verfügung
          es beinhaltet die zufällig ausgewählten Mannschaften:
          ZufallsZahlen[0] und ZufallsZahlen[1]
          hiermit wird die Paarung des Spiels bestimmt
        */
        Serial.print(Mannschaften[ZufallsZahlen[0]]);
        Serial.print(" - " + Mannschaften[ZufallsZahlen[1]]);

        // Anzahl der Tore bestimmen
        AnzahlTore[ZufallsZahlen[0]] = random(Minimum, Maximum);
        AnzahlTore[ZufallsZahlen[1]] = random(Minimum, Maximum);

        // Sieger ermitteln: Sieger erhält 3 Punkte
        // Sieger 1. Mannschaft
        if (AnzahlTore[ZufallsZahlen[0]] > AnzahlTore[ZufallsZahlen[1]])
        {
          AnzahlPunkte[ZufallsZahlen[0]] = AnzahlPunkte[ZufallsZahlen[0]] + 3;
        }

        // Sieger 2. Mannschaft
        else if (AnzahlTore[ZufallsZahlen[0]] < AnzahlTore[ZufallsZahlen[1]])
        {
          AnzahlPunkte[ZufallsZahlen[1]] = AnzahlPunkte[ZufallsZahlen[1]] + 3;
        }

        // unentschieden: beide Mannschaften 1 Punkt
        else if (AnzahlTore[ZufallsZahlen[0]] == AnzahlTore[ZufallsZahlen[1]])
        {
          AnzahlPunkte[ZufallsZahlen[0]] = AnzahlPunkte[ZufallsZahlen[0]] + 1;
          AnzahlPunkte[ZufallsZahlen[1]] = AnzahlPunkte[ZufallsZahlen[1]] + 1;
        }

        // Ergebnis anzeigen
        Serial.print(" ");
        Serial.print(AnzahlTore[ZufallsZahlen[0]]);
        Serial.print(" : ");
        Serial.println(AnzahlTore[ZufallsZahlen[1]]);

        // Punkte anzeigen
        Serial.print(Mannschaften[ZufallsZahlen[0]]);
        Serial.println(": " + String(AnzahlPunkte[ZufallsZahlen[0]]) + " Punkt(e)");
        Serial.print(Mannschaften[ZufallsZahlen[1]]);
        Serial.println(": " + String(AnzahlPunkte[ZufallsZahlen[1]]) + " Punkt(e)");
      }

      // Gesamtpunkte anzeigen
      if (Zeichen == "t")
      {
        // Mannschaften nach Anzahl der Punkte sortieren
        ZahlenSortieren();

        Serial.println("-------------------------------------------");

        // Mannschaften in der Reihenfolge der Punkte anzeigen
        // die Mannschaft mit den meisten Punkte zuerst
        for (int i = AnzahlMannschaften - 1; i >= 0; i--)
        {
          Serial.print(Mannschaften[i]);
          Serial.println(": " + String(AnzahlPunkte[i]) + " Punkt(e)");
        }
        Serial.println("-------------------------------------------");
      }
    }
  }
}

Für die „Tabel­le“ wird die Metho­de Zah­len­Sor­tie­ren benö­tigt. Beach­te die Kommentare.

void ZahlenSortieren()
{
  // unsortierten Bereich des Arrays durchlaufen
  for (int i = 0; i < (AnzahlMannschaften - 1); i++)
  {
    // bei jedem Durchlauf wird das jeweils letzte Element weggelassen
    for (int ii = 0; ii < (AnzahlMannschaften - (i + 1)); ii++)
    {
      /*
        wenn die aktuelle Zahl größer als die nachfolgende Zahl ist
        -> aktuelle AnzahlPunkte temporär speichern
        -> aktuelle Mannschaft temporär speichern
        -> AnzahlPunkte/Mannschaften vertauschen
        -> temporäre AnzahlPunkte/Mannschaften 
           den nachfolgenden AnzahlPunkte/Mannschaften zuweisen
      */
      if (AnzahlPunkte[ii] > AnzahlPunkte[ii + 1])
      {
        int zwischengespeicherteZahl = AnzahlPunkte[ii];
        String zwischengespeicherteMannschaft = Mannschaften[ii];
        AnzahlPunkte[ii] = AnzahlPunkte[ii + 1];
        Mannschaften[ii] = Mannschaften[ii + 1];
        AnzahlPunkte[ii + 1] = zwischengespeicherteZahl;
        Mannschaften[ii + 1] = zwischengespeicherteMannschaft;
      }
    }
  }
}

Startseite
Aufgaben A-Z
Suchen
Downloads
Fehlermeldungen
Seite als PDF

Ver­wand­te Aufgaben:


Letzte Aktualisierung: 15. Mai 2022 @ 10:55