Lösungen

struct Stadt
{
  int Platz;
  String Name;
  String KFZ_Kennzeichen;
  float Einwohner;
  String Vorwahl;
  int Hoehe;
  String Land;
};

const int MAX = 4;
/*
  \u00e4d = ä
  \u00df = ß
  \u00fc = ü
  \u00f6 = ö
*/
// Array definieren
Stadt Namen[MAX] =
{
  {1, "Berlin", "B", 3.64, "030", 30, "Berlin"},
  {2, "Hamburg", "HH", 1.84, "040", 6, "Hamburg"},
  {3, "M\u00fcnchen", "M", 1.47, "089", 519, "Bayern"},
  {4, "K\u00f6ln", "K", 1.04, "0221", 53, "NRW"}
};

void setup()
{
  // Zufallsgenerator starten
  randomSeed(analogRead(0));
  Serial.begin(115200);
  
  // auf serielle Verbindung warten
  while (!Serial) {;}

  // Info
  Serial.println("Liste der Gro\u00dfst\u00e4dte mit mehr als 1 Mio Einwohner");
  Serial.println("----------------------------------------------------------------------------------");
  Serial.println("1 = Berlin");
  Serial.println("2 = Hamburg");
  Serial.println("3 = M\u00fcnchen");
  Serial.println("4 = K\u00f6ln");
  Serial.println("5 = Zufall");
  Serial.println("----------------------------------------------------------------------------------");
  Serial.println("Platz\tStadt\t\tKFZ\tEinw. in Mio.\tH\u00f6he\tVorwahl\t\tBundesland");
}

void loop()
{
  // auf serielle Eingabe warten
  while (Serial.available() > 0)
  {
    // Eingabe im Seriellen Monitor lesen
    String Eingabe = Serial.readStringUntil(char(13));
   
    // String Eingabe nach int umwandeln
    // die Funktion ZeigeDaten kann dann direkt aufgerufen werden
    int Auswahl = Eingabe.toInt();

    // wenn Auswahl > 0 und < 5
    // weil das Array mit 0 beginnt, 1 abziehen
    if (Auswahl > 0 && Auswahl < 5) ZeigeDaten(Auswahl - 1);

    // zufällige Auswahl
    if (Auswahl == 5)
    {
      int Minimum = 0;
      int Maximum = 4;
      int Zahl =  random(Minimum, Maximum);
      ZeigeDaten(Zahl);
    }
  }
}

void ZeigeDaten(int i)
{
  // bei der Einwohnerzahl . durch , ersetzen
  String Einwohner =  String(Namen[i].Einwohner);
  Einwohner.replace(".", ",");

  // Daten anzeigen, mit Tabulator (\t) formatieren
  Serial.print(String(Namen[i].Platz) + "\t");
  Serial.print(Namen[i].Name + "\t\t");
  Serial.print(Namen[i].KFZ_Kennzeichen + "\t\t");
  Serial.print(Einwohner + "\t");
  Serial.print(String(Namen[i].Hoehe) + "\t");
  Serial.print(Namen[i].Vorwahl + "\t\t");
  Serial.println(Namen[i].Land);
}

Letzte Aktualisierung: Wei­ter lesen ...

int Zahl;
int EingabeMax = 1000;

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

  // auf serielle Verbindung warten
  while (!Serial) {;}
  Serial.println("Zahl eingeben:");
  Serial.println("Maximum ist: " + String(EingabeMax) + "!");
}

void loop()
{
  String Eingabe;
  while (Serial.available() > 0)
  {
    // solange lesen, bis return \n eingegeben wurde
    Eingabe = Serial.readStringUntil('\n');

    // das letzte Zeichen ist return → soll entfernt werden
    Eingabe = Eingabe.substring(0, Eingabe.length() - 1);

    // eingegebene Eingabe zu int umwandeln
    Zahl = Eingabe.toInt();

    // nur ausführen wenn Zahl < 1000
    // -> ansonsten ist die Rechenzeit zu lang
    if (Zahl <= EingabeMax)
    {
      int ZaehlerZeile = 0;
      Serial.println("----------------------------------------------");
      Serial.println("Primzahlen bis " + String(Eingabe)) ;
      for (int i = 2 ; i < Zahl; i++)
      {
        // Primzahl suchen -> Funktion aufrufen
        bool Suche = Primzahl(i);
        // Primzahl gefunden -> Suche = true
        if (Suche)
        {
          ZaehlerZeile++;

          // 10 Zahlen pro Zeile
          if (ZaehlerZeile % 10 == 0) Serial.println(String(i) + "," ) ;
          else Serial.print(String(i) + "," + '\t') ;
        }
      }
      Serial.println("\n---------------------------------------------");
      Serial.println(String(ZaehlerZeile) + " Primzahlen gefunden!");
    }

    else Serial.println("Die Eingabe ist >1000");
  }
}

bool Primzahl(int Zahl)
{
  // nur bis zur Hälfte der Eingabe prüfen
  for (int i = 2 ; i <= Zahl / 2; i++)
  {
    // Teilbarkeit mit modulo testen
    // wenn kein Rest → Eingabe ist teilbar → false zurückgeben
    if (Zahl % i == 0) return false;
  }
  
  // keine Teiler gefunden → Primzahl = true zurückgeben
  return true;
}

Letzte Aktualisierung: Wei­ter lesen ...

String Eingabe = "";

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

void loop()
{
  while (Serial.available() > 0)
  {
    char Zahl = Serial.read();
    if (isDigit(Zahl))
    {
      Eingabe = Eingabe + Zahl;
    }
    if (Zahl == '\n')
      if (Eingabe.length() > 0)
      {
        {
          unsigned long Reihe = Eingabe.toInt();
          ReiheAnzeigen(Reihe);
          Eingabe = "";
        }
      }
  }
}

void ReiheAnzeigen(unsigned long Reihe)
{
  Serial.print("Einmaleins der ");
  Serial.println(Reihe);
  for (int i = 1; i <= 10; i ++)
  {
    Serial.print(i);
    Serial.print(" * ");
    Serial.print(Reihe);
    Serial.print(" = ");
    Serial.print(i * Reihe);
    Serial.println();
  }
  Serial.println("-------------------------------");
}

Letzte Aktualisierung: Wei­ter lesen ...

String Eingabe;

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

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

  Serial.println("Bitte Text eingeben:");
}

void loop()
{
  // alle Zähler auf 0 setzen
  int ZaehlerA = 0;
  int ZaehlerE = 0;
  int ZaehlerO = 0;
  int ZaehlerU = 0;
  int ZaehlerI = 0;

  // String Eingabe leeren
  Eingabe = "";

  while (Serial.available() > 0)
  {
    // solange lesen, bis return \n eingegeben wurde
    String Eingabe = Serial.readStringUntil('\n');

    // das letzte Zeichen ist return
    Eingabe = Eingabe.substring(0, Eingabe.length() - 1);

    // Text sichern
    String OriginalEingabe = Eingabe;

    // in Kleinbuchstaben umwandeln
    // nur 1 Durchgang für die Zählung der Vokale erforderlich
    Eingabe.toLowerCase();

    for (int i = 0; i < Eingabe.length(); i ++)
    {
      // Vokale zählen
      if (Eingabe[i] == 'a') ZaehlerA ++;
      if (Eingabe[i] == 'e') ZaehlerE ++;
      if (Eingabe[i] == 'i') ZaehlerI ++;
      if (Eingabe[i] == 'o') ZaehlerO ++;
      if (Eingabe[i] == 'u') ZaehlerU ++;
    }

    // Text anzeigen
    Serial.println("Text:" + OriginalEingabe);

    // Ergebnis anzeigen
    Serial.println("Anzahl der Vokale:");
    Serial.println("-----------------------");
    Serial.println(String(ZaehlerA) + " mal das a");
    Serial.println(String(ZaehlerE) + " mal das e");
    Serial.println(String(ZaehlerI) + " mal das i");
    Serial.println(String(ZaehlerO) + " mal das o");
    Serial.println(String(ZaehlerU) + " mal das u");
    Serial.println("-----------------------");

    // Anzahl der Zeichen anzeigen
    Serial.println(String(Eingabe.length()) + " Zeichen!");
    Serial.println("-----------------------");

    // Text rückwärts anzeigen
    for (int i = OriginalEingabe.length(); i >= 0; i --)
    {
      Serial.print(OriginalEingabe[i]);
    }

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

    // alle Vokale durch i ersetzen     
    OriginalEingabe.replace("a", "i");     
    OriginalEingabe.replace("e", "i");   
    OriginalEingabe.replace("o", "i");     
    OriginalEingabe.replace("u", "i");    
    Serial.println(OriginalEingabe); 
    Serial.println("-----------------------");
  }
}

Letzte Aktualisierung: Wei­ter lesen ...

// Anzahl der zu ziehenden Zahlen
const int Anzahl = 6;

int LottoZahl[Anzahl];

// Array für die angekreuzten Zahlen
int SpielZahl[Anzahl];

// Minimum/Maximum der Zufallszahlen
int Minimum = 1;
int Maximum = 49;

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

  // auf serielle Verbindung warten
  while (!Serial);
  
  // Zufallsgenerator starten
  randomSeed(analogRead(0));
  Serial.println("z = Nächste Ziehung");
}

void loop()
{
  String GespielteZahlen = "";
  String GezogeneZahlen = "";
  String AnzahlTreffer = "";
  char Eingabe;

  int Treffer = 0;

  // auf serielle Eingabe warten
  while (Serial.available() > 0)
  {
    // solange lesen, bis return eingegeben wurde
    Eingabe = Serial.read();
  }

  // wenn "z" eingegeben wurde
  if (Eingabe == 'z')
  {
    // Ziehung der "angekreuzten" Zahlen
    Ziehung();

    /*
      Array Sortieren mit ArduinoSort
      sortArray(NameArray, AnzahlElemente)
      sortArrayReverse(NameArray, AnzahlElemente)
    */
    ZahlenSortieren(LottoZahl, 6);
    // String GespielteZahlen aus den Elementen des Arrays LottoZahl
    // zusammensetzen
    for (int i = 0; i < Anzahl; i++)
    {
      GespielteZahlen = GespielteZahlen + LottoZahl[i] + " ";
      SpielZahl[i] = LottoZahl[i];
    }

    // Ziehung der Lottozahlen
    Ziehung();

    ZahlenSortieren(LottoZahl, 6);

    // Vergleichen der Elemente der Arrays SpielZahl und LottoZahl
    for (int i = 0; i < Anzahl; i++)
    {
      for (int ii = 0; ii < Anzahl; ii++)
      {
        // Übereinstimmung gefunden -> Treffer um 1 erhöhen
        if (SpielZahl[i] == LottoZahl[ii])
        {
          AnzahlTreffer = AnzahlTreffer + SpielZahl[i] + " ";
          Treffer ++;
        }
      }
    }

    // String GezogeneZahlen aus den Elementen des Arrays LottoZahl
    // zusammensetzen
    for (int i = 0; i < Anzahl; i++)
    {
      GezogeneZahlen = GezogeneZahlen + LottoZahl[i] + " ";
    }

    // Anzeige Serieller Monitor
    Serial.println("Gespielte Zahlen");
    Serial.println("-----------------------------");
    Serial.println(GespielteZahlen);
    Serial.println("-----------------------------");


    // Anzeige der Zahlen Serieller Monitor
    Serial.println("Gezogene Zahlen");
    Serial.println("-----------------------------");
    Serial.println(GezogeneZahlen);
    Serial.println("-----------------------------");

    if (Treffer == 0) Serial.println("keine Treffer!");
    else Serial.println("Treffer: " + AnzahlTreffer + "");
    Serial.println("-----------------------------");
  }
}

int Ziehung()
{
  for (int i = 0; i < Anzahl; i++)
  {
    /*
      die Lottozahl gilt solange als bereits gezogen
      bis in der for-Schleife nachgewiesen wird, dass sie neu ist
      BereitsGezogen den Wert false hat
    */
    bool BereitsGezogen = true;

    while (BereitsGezogen)
    {
      // Zahl ziehen
      LottoZahl[i] = random(Minimum, Maximum);
      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
        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 (LottoZahl[i] == LottoZahl[ii]) BereitsGezogen = true;
      }
    }
  }
  return LottoZahl[Anzahl];
}

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

Letzte Aktualisierung: Wei­ter lesen ...

enum LED
{
  // Startwert Pin 3
  LED_1 = 3,
  LED_2,
  LED_3,
  LED_4,
  LED_5
};

// Zufallsbereich des Blinkintervalls
# define Minimum 100
# define Maximum 2000

void setup()
{
  // pinMode festlegen: Startwert LED_1, Endwert  LED_5
  for (int i = LED_1; i <= LED_5; i++)
  {
    pinMode(i, OUTPUT);
  }

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

void loop()
{
  LED_1_Blinken();
  LED_2_Blinken();
  LED_3_Blinken();
  LED_4_Blinken();
  LED_5_Blinken();
}

void LED_1_Blinken()
{
  /*
    die Variablen sollen den letzten Wert des Aufrufs behalten
    -> Definition als static
  */
  static bool Zustand = false;

  /*
    der Rückgabewert von millis() ist unsigned long int
    -> WarteZeit muss ebenfalls den Typ unsigned long int haben
  */
  static unsigned long int WarteZeit = 0;

  // Blinkintervall zufällig ermitteln
  int BlinkIntervall =  random(Minimum, Maximum);

  // wenn Zustand false
  if (!Zustand)
  {
    /*
      millis() ermittelt die seit Programmstart verstrichene Zeit
      prüfen, ob die Zeit schon abgelaufen ist
      millis() - WarteZeit muss größer als das BlinkIntervall sein
    */
    if (millis() - WarteZeit >= BlinkIntervall)
    {
      digitalWrite(LED_1, HIGH);

      // Wartezeit um Blinkintervall erhöhen
      WarteZeit += BlinkIntervall;
      Zustand = !Zustand;
    }
  }

  // wenn Zustand true
  if (Zustand)
  {
    if (millis() - WarteZeit >= BlinkIntervall)
    {
      digitalWrite(LED_1, LOW);
      WarteZeit += BlinkIntervall;

      // Zustand "umdrehen" true -> false, false -> true
      Zustand = !Zustand;
    }
  }
}

void LED_2_Blinken()
{
  /*
    die Variablen sollen den letzten Wert des Aufrufs behalten
    -> Definition als static
  */
  static bool Zustand = false;

  /*
    der Rückgabewert von millis() ist unsigned long int
    -> WarteZeit muss ebenfalls den Typ unsigned long int haben
  */
  static unsigned long int WarteZeit = 0;

  // Blinkintervall zufällig ermitteln
  int BlinkIntervall =  random(Minimum, Maximum);

  // wenn Zustand false
  if (!Zustand)
  {
    /*
      millis() ermittelt die seit Programmstart verstrichene Zeit
      prüfen, ob die Zeit schon abgelaufen ist
      millis() - WarteZeit muss größer als das BlinkIntervall sein
    */
    if (millis() - WarteZeit >= BlinkIntervall)
    {
      digitalWrite(LED_2, HIGH);

      // Wartezeit um Blinkintervall erhöhen
      WarteZeit += BlinkIntervall;
      Zustand = !Zustand;
    }
  }

  // wenn Zustand true
  if (Zustand)
  {
    if (millis() - WarteZeit >= BlinkIntervall)
    {
      digitalWrite(LED_2, LOW);
      WarteZeit += BlinkIntervall;

      // Zustand "umdrehen" true -> false, false -> true
      Zustand = !Zustand;
    }
  }
}

void LED_3_Blinken()
{
  /*
    die Variablen sollen den letzten Wert des Aufrufs behalten
    -> Definition als static
  */
  static bool Zustand = false;

  /*
    der Rückgabewert von millis() ist unsigned long int
    -> WarteZeit muss ebenfalls den Typ unsigned long int haben
  */
  static unsigned long int WarteZeit = 0;

  // Blinkintervall zufällig ermitteln
  int BlinkIntervall =  random(Minimum, Maximum);

  // wenn Zustand false
  if (!Zustand)
  {
    /*
      millis() ermittelt die seit Programmstart verstrichene Zeit
      prüfen, ob die Zeit schon abgelaufen ist
      millis() - WarteZeit muss größer als das BlinkIntervall sein
    */
    if (millis() - WarteZeit >= BlinkIntervall)
    {
      digitalWrite(LED_3, HIGH);

      // Wartezeit um Blinkintervall erhöhen
      WarteZeit += BlinkIntervall;
      Zustand = !Zustand;
    }
  }

  // wenn Zustand true
  if (Zustand)
  {
    if (millis() - WarteZeit >= BlinkIntervall)
    {
      digitalWrite(LED_3, LOW);
      WarteZeit += BlinkIntervall;

      // Zustand "umdrehen" true -> false, false -> true
      Zustand = !Zustand;
    }
  }
}

void LED_4_Blinken()
{
  /*
    die Variablen sollen den letzten Wert des Aufrufs behalten
    -> Definition als static
  */
  static bool Zustand = false;

  /*
    der Rückgabewert von millis() ist unsigned long int
    -> WarteZeit muss ebenfalls den Typ unsigned long int haben
  */
  static unsigned long int WarteZeit = 0;

  // Blinkintervall zufällig ermitteln
  int BlinkIntervall =  random(Minimum, Maximum);

  // wenn Zustand false
  if (!Zustand)
  {
    /*
      millis() ermittelt die seit Programmstart verstrichene Zeit
      prüfen, ob die Zeit schon abgelaufen ist
      millis() - WarteZeit muss größer als das BlinkIntervall sein
    */
    if (millis() - WarteZeit >= BlinkIntervall)
    {
      digitalWrite(LED_4, HIGH);

      // Wartezeit um Blinkintervall erhöhen
      WarteZeit += BlinkIntervall;
      Zustand = !Zustand;
    }
  }

  // wenn Zustand true
  if (Zustand)
  {
    if (millis() - WarteZeit >= BlinkIntervall)
    {
      digitalWrite(LED_4, LOW);
      WarteZeit += BlinkIntervall;

      // Zustand "umdrehen" true -> false, false -> true
      Zustand = !Zustand;
    }
  }
}

void LED_5_Blinken()
{
  /*
    die Variablen sollen den letzten Wert des Aufrufs behalten
    -> Definition als static
  */
  static bool Zustand = false;

  /*
    der Rückgabewert von millis() ist unsigned long int
    -> WarteZeit muss ebenfalls den Typ unsigned long int haben
  */
  static unsigned long int WarteZeit = 0;

  // Blinkintervall zufällig ermitteln
  int BlinkIntervall =  random(Minimum, Maximum);

  // wenn Zustand false
  if (!Zustand)
  {
    /*
      millis() ermittelt die seit Programmstart verstrichene Zeit
      prüfen, ob die Zeit schon abgelaufen ist
      millis() - WarteZeit muss größer als das BlinkIntervall sein
    */
    if (millis() - WarteZeit >= BlinkIntervall)
    {
      digitalWrite(LED_5, HIGH);

      // Wartezeit um Blinkintervall erhöhen
      WarteZeit += BlinkIntervall;
      Zustand = !Zustand;
    }
  }

  // wenn Zustand true
  if (Zustand)
  {
    if (millis() - WarteZeit >= BlinkIntervall)
    {
      digitalWrite(LED_5, LOW);
      WarteZeit += BlinkIntervall;

      // Zustand "umdrehen" true -> false, false -> true
      Zustand = !Zustand;
    }
  }
}

Letzte Aktualisierung: Wei­ter lesen ...

# include "LedControl.h"

int TASTER = 7;

int TasterLesen;
int Zahl;
int Minimum = 1;

// der Zufallsgenerator rundet nach unten → Maximum = 7
int Maximum = 7;

/*
   VCC -> 5V
   GND
   Pin 12 -> DATA IN-pin
   Pin 10 -> CLK-pin
   Pin 11 -> CS-pin
*/

LedControl LEDMatrix = LedControl(12, 11, 10, 1);

void setup()
{
  // Matrix "aufwecken"
  LEDMatrix.shutdown(0, false);

  //  mittlere Helligkeit setzen
  LEDMatrix.setIntensity(0, 8);

  // Zufallsgenerator starten
  randomSeed(A0);
  pinMode(TASTER, INPUT_PULLUP);
}

void loop()
{
  TasterLesen = digitalRead(TASTER);
  if (TasterLesen == LOW)
  {
    delay(300);

    // Würfeleffekt
    for (int i = 0; i < 8; i++)
    {
      int Zahl =  random(Minimum, Maximum);

      Wuerfeln();
      delay(200);
    }
  }
}

void Wuerfeln()
{
  Zahl = ZufallsZahl();

  switch (Zahl)
  {
    case 1:
      Eins();
      break;

    case 2:
      Zwei();
      break;

    case 3:
      Drei();
      break;

    case 4:
      Vier();
      break;

    case 5:
      Fuenf();
      break;

    case 6:
      Sechs();
      break;
  }
}


int ZufallsZahl()
{
  Zahl =  random(Minimum, Maximum);
  return Zahl;
}

void Eins()
{
  byte Zeichen[8] =
  {
    B00000000,
    B00000000,
    B00000000,
    B00011000,
    B00011000,
    B00000000,
    B00000000,
    B00000000
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}

void Zwei()
{
  byte Zeichen[8] =
  {
    B11000000,
    B11000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000011,
    B00000011
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}

void Drei()
{
  byte Zeichen[8] =
  {
    B11000000,
    B11000000,
    B00000000,
    B00011000,
    B00011000,
    B00000000,
    B00000011,
    B00000011
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}

void Vier()
{
  byte Zeichen[8] =
  {
    B11000011,
    B11000011,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B11000011,
    B11000011
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}

void Fuenf()
{
  byte Zeichen[8] =
  {
    B11000011,
    B11000011,
    B00000000,
    B00011000,
    B00011000,
    B00000000,
    B11000011,
    B11000011
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}
void Sechs()
{
  byte Zeichen[8] =
  {
    B11011011,
    B11011011,
    B00000000,
    B11011011,
    B11011011,
    B00000000,
    B11011011,
    B11011011
  };

  for (int zaehler = 0; zaehler < 8; zaehler ++)
  {
    LEDMatrix.setRow(0, zaehler, Zeichen[zaehler]);
  }
}

Letzte Aktualisierung: Wei­ter lesen ...

int Kontostand = 5000;

// Scheine, die zurück gegeben werden
int Fuenfziger;
int Zwanziger;
int Zehner;

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

  // auf serielle Verbindung warten

  while (!Serial) {;}
  KontostandAnzeigen(Kontostand);
  Serial.println();
}

void loop()
{
  // abgehobener/eingezahlter Betrag
  int Betrag;

  // auf serielle Eingabe warten
  while (Serial.available() > 0)
  {
    // Eingabe im Seriellen Monitor lesen
    String Eingabe = Serial.readStringUntil(char(13));
    Eingabe = Eingabe.substring(0, Eingabe.length());

    // Testen, ob das erste Zeichen + oder - ist
    if (Eingabe.charAt(0) == '+' || Eingabe.charAt(0) == '-')
    {
      // Auszahlung
      if (Eingabe.startsWith("-"))
      {
        Betrag = Eingabe.toInt() * -1;

        // Betrag muss durch 10 teilbar sein
        if (Betrag % 10 == 0) BetragAuszahlen(Betrag);
      }

      // Einzahlung
      if (Eingabe.startsWith("+"))
      {
        Betrag = Eingabe.toInt();

        // Betrag muss durch 10 teilbar sein
        if (Betrag % 10 == 0) BetragEinzahlen(Betrag);
      }
    }
  }
}

void BetragEinzahlen(int Betrag)
{
  Kontostand = Kontostand + Betrag;
  Serial.println("Du m\u00f6chtest " + String(Betrag) + " \u20ac einzahlen.");
  AnzahlScheine(Betrag);
  KontostandAnzeigen(Kontostand);
}

void BetragAuszahlen(int Betrag)
{
  // der auszuzahlende Betrag ist zu hoch
  if (Kontostand - Betrag < 0)
  {
    Serial.println("Auszahlung nicht m\u00f6glich!");
    Serial.println("Kontostand ist im Soll: " + String(Kontostand - Betrag) + " \u20ac");
    Serial.println("Bitte gib einen kleineren Betrag ein!");
    Serial.println("----------------------------------------");
  }

  // Betrag auszahlen
  else
  {
    Kontostand = Kontostand - Betrag;
    Serial.println("Du m\u00f6chtest " + String(Betrag) + " \u20ac abheben.");
    Serial.println("Du bekommst:");
    
    // Anzahl der Scheine (50, 20 und 10) feststellen
    AnzahlScheine(Betrag);
    KontostandAnzeigen(Kontostand);
  }
}

void KontostandAnzeigen(int Kontostand)
{
  // Kontostand anzeigen
  Serial.println("Neuer Kontostand: " + String(Kontostand) + " \u20ac");
  Serial.println("-------------------------------------------------------");
  Serial.println("Wie viel m\u00f6chtest du einzahlen oder abheben?");
  Serial.println("Der Betrag muss durch 10 teilbar sein!");
  Serial.println("Auszahlung -> dem Betrag ein - Zeichen voranstellen");
  Serial.println("Einzahlung -> dem Betrag ein + Zeichen voranstellen");
  Serial.println("-------------------------------------------------------");
}

void AnzahlScheine(int Betrag)
{
  // Anzahl der 50er
  int Rest = Betrag % 50;

  /*
    vom Betrag den Rest abziehen
    Beispiel:
    130 % 50 ergibt Rest 30
    130 - 30 = 100
    100 ist durch 50 teilbar
  */
  Fuenfziger = (Betrag - Rest) / 50;
  /*
    Rest berechnen
    wenn nicht durch 20 teilbar, kann neuerRest nur 10er sein
    30 % 20 ergibt Rest 10
  */
  int neuerRest = Rest % 20;

  /*
    Anzahl der 20er
    der neueRest muss von Rest abgezogen werden
    -> ergibt die 20er
  */
  Zwanziger = (Rest - neuerRest) / 20;

  // Anzahl der 10er
  Zehner = neuerRest / 10;

  // Anzahl der Geldscheine anzeigen
  if (Fuenfziger > 0) Serial.println(String(Fuenfziger) + " F\u00fcnfziger");
  if (Zwanziger > 0) Serial.println(String(Zwanziger) + " Zwanziger");
  if (Zehner > 0) Serial.println(String(Zehner) + " Zehner");
}

Letzte Aktualisierung: Wei­ter lesen ...

// Start mit 10 Durchläufen
double MaxDurchlauf = 10;

// statistische Wahrscheinlichkeit eine bestimmte Zahl zu wuerfeln
const double StatistischeWahrscheinlichkeit = 16.67;
String Leerzeichen;

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

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

  Serial.println("Laplace-Versuch");
  Serial.println("s -> Start");
  Serial.println("-----------------------------------------");
  randomSeed(analogRead(0));
}

void loop()
{
  // alle Variablen 0 setzen
  int Durchlauf = 0;
  int AnzahlEins = 0;
  int AnzahlZwei = 0;
  int AnzahlDrei = 0;
  int AnzahlVier = 0;
  int AnzahlFuenf = 0;
  int AnzahlSechs = 0;

  // Zahlen von 1 bis 6
  int Minimum = 1;
  int Maximum = 7;

  String AnzahlFormat;
  String AbweichungFormat;
  double Abweichung;
  String Zeichen;

  while (Serial.available() > 0)
  {
    // Eingabe im Seriellen Monitor lesen
    char Eingabe = Serial.read();

    // Enter/Senden gedrückt
    if (Eingabe == 's')
    {
      Serial.println("Anzahl der W\u00fcrfe: " + String(MaxDurchlauf));
      Serial.println("------------------------------------------------------------------");

      while (Durchlauf < MaxDurchlauf)
      {
        int Zahl = ZufallsZahl(Minimum, Maximum);

        // Anzahl der Wuerfe speichern
        if (Zahl == 1) AnzahlEins ++;
        if (Zahl == 2) AnzahlZwei ++;
        if (Zahl == 3) AnzahlDrei ++;
        if (Zahl == 4) AnzahlVier ++;
        if (Zahl == 5) AnzahlFuenf ++;
        if (Zahl == 6) AnzahlSechs ++;

        Durchlauf ++;
      }

      // Ergebnis berechnen und formatieren
      // 1
      /*
        Anzahl Leerzeichen ergaenzen
        < 10 -> 3 Leerzeichen
        > 10 und < 100 -> 2 Leerzeichen
        > 100 kein Leerzeichens
        > 10.000 nicht möglich, maximale Durchlaeufe = 20.000
      */
      Leerzeichen = "";

      if (AnzahlEins < 10) Leerzeichen = "  ";
      if (AnzahlEins < 100 && AnzahlEins > 9) Leerzeichen = " ";

      // % berechnen und als String formatieren
      AnzahlFormat = String(AnzahlEins / MaxDurchlauf * 100);

      // . durch , ersetzen
      AnzahlFormat.replace(".", ",");

      // wenn %-Wert < 10 -> Leerzeichen ergaenzen
      if (AnzahlFormat.length() < 5) AnzahlFormat = " " + AnzahlFormat;

      // Abweichung von der zu erwartenden Wahrscheinlichkeit in % berechnen
      Abweichung = StatistischeWahrscheinlichkeit - AnzahlEins / MaxDurchlauf * 100;

      /*
        die Berechnung der Abweichung hat als Ergebnis eine negative Zahl, wenn
        das Ergebnis nach oben von 16,67 abweicht und eine positive Zahl, wenn das Ergebnis
        unten abweicht
        die Abweichung soll so formatiert werden, dass
        -  die Differenz von einem niedrigen Wert als 16,67 bis 16,67
           mit dem Vorzeichen - angezeigt wird
        -  die die Differenz von einem höheren Wert als 16,67 bis 16,67
           mit dem Vorzeichen + angezeigt wird
      */
      if (AnzahlEins / MaxDurchlauf * 100 - StatistischeWahrscheinlichkeit > 0)
      {
        /*
          %-Wert < 16.67
          Wert für Abweichung soll negativ werden
          Vorzeichen - char(43) setzen
        */
        Abweichung = Abweichung * - 1;
        Zeichen = char(43);
      }

      // %-Wert > 16,67 -> Vorzeichen + char(45) setzen
      else Zeichen = char(45);

      // Abweichung in String umwandeln und . durch , ersetzen
      AbweichungFormat = String(Abweichung);
      AbweichungFormat.replace(".", ",");

      // wenn Wert < 10 -> Leerzeichen ergaenzen
      if (AbweichungFormat.length() < 5) Zeichen = Zeichen + " ";

      // Ergebnis anzeigen mit \t = Tabulator formatieren
      Serial.print("Anzahl 1: \t" + Leerzeichen + String(AnzahlEins));
      Serial.print("\t-> " + AnzahlFormat + "%" + "\t-> Abweichung ");
      Serial.println(Zeichen + AbweichungFormat + "%");
      
      // 2
      Leerzeichen = "";
      if (AnzahlZwei < 10) Leerzeichen = "  ";
      if (AnzahlZwei < 100 && AnzahlZwei > 9) Leerzeichen = " ";
      AnzahlFormat = String(AnzahlZwei / MaxDurchlauf * 100);
      AnzahlFormat.replace(".", ",");
      if (AnzahlFormat.length() < 2) AnzahlFormat = AnzahlFormat + " ";

      if (AnzahlFormat.length() < 5) AnzahlFormat = " " + AnzahlFormat;
      Abweichung = StatistischeWahrscheinlichkeit - AnzahlZwei / MaxDurchlauf * 100;

      if (AnzahlZwei / MaxDurchlauf * 100 - StatistischeWahrscheinlichkeit > 0)
      {
        Abweichung = Abweichung * - 1;
        Zeichen = char(43);
      }
      else Zeichen = char(45);
      AbweichungFormat = String(Abweichung);
      AbweichungFormat.replace(".", ",");
      if (AbweichungFormat.length() < 5) Zeichen = Zeichen + " ";
      Serial.print("Anzahl 2: \t" + Leerzeichen + String(AnzahlZwei));
      Serial.print("\t-> " + AnzahlFormat + "%" + "\t-> Abweichung ");
      Serial.println(Zeichen + AbweichungFormat + "%");
      
      // 3
      Leerzeichen = "";

      if (AnzahlDrei < 10) Leerzeichen = "  ";
      if (AnzahlDrei < 100 && AnzahlDrei > 9) Leerzeichen = " ";
      AnzahlFormat = String(AnzahlDrei / MaxDurchlauf * 100);
      AnzahlFormat.replace(".", ",");
      Abweichung = StatistischeWahrscheinlichkeit - AnzahlDrei / MaxDurchlauf * 100;

      if (AnzahlDrei / MaxDurchlauf * 100 - StatistischeWahrscheinlichkeit > 0)
      {
        Abweichung = Abweichung * - 1;
        Zeichen = char(43);
      }
      else Zeichen = char(45);
      AbweichungFormat = String(Abweichung);
      AbweichungFormat.replace(".", ",");
      if (AbweichungFormat.length() < 5) Zeichen = Zeichen + " ";
      Serial.print("Anzahl 3: \t" + Leerzeichen + String(AnzahlDrei));
      Serial.print("\t-> " + AnzahlFormat + "%" + "\t-> Abweichung ");
      Serial.println(Zeichen + AbweichungFormat + "%");
      
      // 4
      Leerzeichen = "";

      if (AnzahlVier < 10) Leerzeichen = "  ";
      if (AnzahlVier < 100 && AnzahlVier > 9) Leerzeichen = " ";

      AnzahlFormat = String(AnzahlVier / MaxDurchlauf * 100);
      AnzahlFormat.replace(".", ",");

      if (AnzahlFormat.length() < 5) AnzahlFormat = " " + AnzahlFormat;
      Abweichung = StatistischeWahrscheinlichkeit - AnzahlVier / MaxDurchlauf * 100;

      if (AnzahlVier / MaxDurchlauf * 100 - StatistischeWahrscheinlichkeit > 0)
      {
        Abweichung = Abweichung * - 1;
        Zeichen = char(43);
      }
      else Zeichen = char(45);
      AbweichungFormat = String(Abweichung);
      AbweichungFormat.replace(".", ",");
      if (AbweichungFormat.length() < 5) Zeichen = Zeichen + " ";
      Serial.print("Anzahl 4: \t" + Leerzeichen + String(AnzahlVier));
      Serial.print("\t-> " + AnzahlFormat + "%" + "\t-> Abweichung ");
      Serial.println(Zeichen + AbweichungFormat + "%");
      
      // 5
      Leerzeichen = "";
      if (AnzahlFuenf < 10) Leerzeichen = "  ";
      if (AnzahlFuenf < 100 && AnzahlFuenf > 9) Leerzeichen = " ";

      AnzahlFormat = String(AnzahlFuenf / MaxDurchlauf * 100);
      AnzahlFormat.replace(".", ",");

      if (AnzahlFormat.length() < 5) AnzahlFormat = " " + AnzahlFormat;
      Abweichung = StatistischeWahrscheinlichkeit - AnzahlFuenf / MaxDurchlauf * 100;

      if (AnzahlFuenf / MaxDurchlauf * 100 - StatistischeWahrscheinlichkeit > 0)
      {
        Abweichung = Abweichung * - 1;
        Zeichen = char(43);
      }
      else Zeichen = char(45);
      AbweichungFormat = String(Abweichung);
      AbweichungFormat.replace(".", ",");
      if (AbweichungFormat.length() < 5) Zeichen = Zeichen + " ";
      Serial.print("Anzahl 5: \t" + Leerzeichen + String(AnzahlFuenf));
      Serial.print("\t-> " + AnzahlFormat + "%" + "\t-> Abweichung ");
      Serial.println(Zeichen + AbweichungFormat + "%");
      
      // 6
      Leerzeichen = "";

      if (AnzahlSechs < 10) Leerzeichen = "  ";
      if (AnzahlSechs < 100 && AnzahlSechs > 9) Leerzeichen = " ";

      AnzahlFormat = String(AnzahlSechs / MaxDurchlauf * 100);
      AnzahlFormat.replace(".", ",");
      if (AnzahlFormat.length() < 5) AnzahlFormat = " " + AnzahlFormat;

      Abweichung = StatistischeWahrscheinlichkeit - AnzahlSechs / MaxDurchlauf * 100;

      if (AnzahlSechs / MaxDurchlauf * 100 - StatistischeWahrscheinlichkeit > 0)
      {
        Abweichung = Abweichung * - 1;
        Zeichen = char(43);
      }
      else Zeichen = char(45);
      AbweichungFormat = String(Abweichung);
      AbweichungFormat.replace(".", ",");
      if (AbweichungFormat.length() < 5) Zeichen = Zeichen + " ";
      Serial.print("Anzahl 6: \t" + Leerzeichen + String(AnzahlSechs));
      Serial.print("\t-> " + AnzahlFormat + "%" + "\t-> Abweichung ");
      Serial.println(Zeichen + AbweichungFormat + "%");
      Serial.println("------------------------------------------------------------------");

      if (MaxDurchlauf < 20000) MaxDurchlauf = MaxDurchlauf * 2;
      else MaxDurchlauf = 10;
    }
  }
}

int ZufallsZahl(int Minimum, int Maximum)
{
  int Zahl =  random(Minimum, Maximum);
  return Zahl;
}

Letzte Aktualisierung: Wei­ter lesen ...