C# :: Aufgabe #13
14 Lösungen
Lotto - Simulation - 6 aus 49
Anfänger - C#
von Gustl
- 25.11.2012 um 16:16 Uhr
Schreiben Sie ein Programm, welches 6 Zahlen zwischen 1 und 49 abfrägt. Danach soll das Programm solange 6 Zufallszahlen berechnen bis alle 6 eingegebenen Zahlen übereinstimmen. Natürlich darf eine Zahl nicht zweimal vorkommen.
Dann soll ausgegeben werden nach wie vielen "Spielen" ein 6er erzielt wurde und wie hoch die Chance auf einen 3er, einen 4er und einen 5er war.
Dann soll ausgegeben werden nach wie vielen "Spielen" ein 6er erzielt wurde und wie hoch die Chance auf einen 3er, einen 4er und einen 5er war.
Lösungen:
Hier ist eine alternative Lösung:
Da hier sehr viele Schleifendurchläufe erforderlich sind, kann durch Parallelisieren eine höhere Performance (bei Mehrkern-CPUs) erreicht werden.
Diese Lösung nutzt die TPL, welche ab .NET Framework 4 enthalten ist.
Da bei parallelen Aufrufen kein direkter Zugriff aus den Methoden (direkt)möglich ist bzw. auch nicht verwendet werden soll schaut der Aufbau im ersten Moment wahrscheinlich etwas komplizierter aus. Die Grundfunktionen sind allerdings die gleichen zur vorherigen Lösung.
C#-Code
Da hier sehr viele Schleifendurchläufe erforderlich sind, kann durch Parallelisieren eine höhere Performance (bei Mehrkern-CPUs) erreicht werden.
Diese Lösung nutzt die TPL, welche ab .NET Framework 4 enthalten ist.
Da bei parallelen Aufrufen kein direkter Zugriff aus den Methoden (direkt)möglich ist bzw. auch nicht verwendet werden soll schaut der Aufbau im ersten Moment wahrscheinlich etwas komplizierter aus. Die Grundfunktionen sind allerdings die gleichen zur vorherigen Lösung.
C#-Code
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Security.Cryptography;
using System.Threading.Tasks;
namespace UE13Parallel
{
internal class Program
{
private static List<int> Moeglichkeiten;
private static readonly object mylock = new object();
private static readonly clsLotto Lotto = new clsLotto();
internal static void Main(string[] args)
{
const int minZahl = 1;
const int maxZahl = 49;
//Lottokugeln anlegen
Moeglichkeiten = Enumerable.Range(minZahl, maxZahl).ToList();
List<int> tipps = new List<int>();
while (tipps.Count < 6)
{
Console.Write("Bitte die {0}. Zahl des Tipps eingeben: ", tipps.Count + 1);
int tipp;
if (int.TryParse(Console.ReadLine(), out tipp))
{
if (tipp >= minZahl && tipp <= maxZahl)
{
tipps.Add(tipp);
}
}
}
Console.WriteLine("Lotto wird simuliert. Bitte warten.");
Stopwatch sw = new Stopwatch();
sw.Start();
//Parallele "While"-Schleife mit den unten beschriebenen Methoden
Parallel.ForEach(Extensions.Infinite(), () => new clsLotto(tipps, Moeglichkeiten), RunIteration, FinishThread);
sw.Stop();
Console.WriteLine("Simulation beendet nach {0:#,##0.000} Sekunden.", sw.ElapsedMilliseconds / 1000m);
Console.WriteLine("Nach {0} Spielen wurde ein 6er erziehlt", Lotto.Durchlaeufe);
Console.WriteLine("Die Chance auf einer 3er lag bei {0:#0.000}%", Lotto.Dreier / (decimal)Lotto.Durchlaeufe * 100m);
Console.WriteLine("Die Chance auf einer 4er lag bei {0:#0.000}%", Lotto.Vierer / (decimal)Lotto.Durchlaeufe * 100m);
Console.WriteLine("Die Chance auf einer 5er lag bei {0:#0.000}%", Lotto.Fuenfer / (decimal)Lotto.Durchlaeufe * 100m);
Console.ReadKey();
}
/// <summary>
/// Methode für einen Schleifendurchlauf
/// </summary>
/// <param name="i"></param>
/// <param name="state">Wird zum Abbrechen der Schleife bei 6er benötigt</param>
/// <param name="localLotto">das lokale Objekt - muss am Ende noch weiterverarbeitet werden</param>
/// <returns></returns>
private static clsLotto RunIteration(bool i, ParallelLoopState state, clsLotto localLotto)
{
var ziehung = localLotto.Moeglichkeiten.ToList().Shuffle().Take(6);
//Anzahl der Übereinstimmungen zählen
int gleiche = localLotto.Tipps.Intersect(ziehung).Count();
switch (gleiche)
{
case 3: { localLotto.Dreier++; break; }
case 4: { localLotto.Vierer++; break; }
case 5: { localLotto.Fuenfer++; break; }
case 6: { state.Break(); break; }
}
localLotto.Durchlaeufe++;
return localLotto;
}
/// <summary>
/// Abschlussmethode des SchleifenThreads. Addition der Teilergebnisse.
/// </summary>
/// <param name="localLotto"></param>
private static void FinishThread(clsLotto localLotto)
{
lock (mylock)
{
Lotto.Dreier += localLotto.Dreier;
Lotto.Vierer += localLotto.Vierer;
Lotto.Fuenfer += localLotto.Fuenfer;
Lotto.Durchlaeufe += localLotto.Durchlaeufe;
}
}
}
/// <summary>
/// Hilfsklasse, bei paralleler Ausführung kann nur ein Objekt übergeben werden.
/// </summary>
internal class clsLotto
{
public clsLotto()
{}
public clsLotto(List<int> tipps, List<int> moeglichkeiten)
{
Tipps = tipps;
Moeglichkeiten = moeglichkeiten;
}
public List<int> Tipps { get; set; }
public List<int> Moeglichkeiten { get; set; }
public int Durchlaeufe { get; set; }
public int Dreier { get; set; }
public int Vierer { get; set; }
public int Fuenfer { get; set; }
}
internal static class Extensions
{
/// <summary>
/// Random ordering of a list.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="list"></param>
internal static List<T> Shuffle<T>(this List<T> list)
{
var provider = new RNGCryptoServiceProvider();
int n = list.Count;
while (n > 1)
{
var box = new byte[1];
do
{
provider.GetBytes(box);
}
while (!(box[0] < n * (Byte.MaxValue / n)));
var k = (box[0] % n);
n--;
var value = list[k];
list[k] = list[n];
list[n] = value;
}
return list;
}
/// <summary>
/// Hilfsmethode um von einer ForEach zu einer While-Schleife zu kommen.
/// Bemerkung: in TPL gibts keine While-Schleife
/// </summary>
/// <returns></returns>
internal static IEnumerable<bool> Infinite()
{
while (true) yield return true;
}
}
}
C#-Code
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace lotto_generator
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Willkommen zum Warscheinlichkeitsrechner für Lottozahlen");
Console.Write("Geben Sie Ihre 6 Lottozahlen, mit Komma getrennt, ein: ");
string eingabe = Console.ReadLine();
string[] sechsZahlen = new string[6];
sechsZahlen = eingabe.Split(',');
int[] getippteZahlen = new int[6];
int[] gezogeneZahlen = new int[6];
int ziehungen = 0, dreier = 0, vierer = 0, fuenfer =0;
decimal warDreier, warVierer, warFuenfer;
bool sechsRichtige = false;
Random r = new Random();
for (int i = 0; i < sechsZahlen.Length; i++)
{
getippteZahlen[i] = Int16.Parse(sechsZahlen[i]);
}
for (int i = 0; i < getippteZahlen.Length; i++)
{
bool fehler = true;
int zahlNr1=0, zahlNr2, zahlNr3, zahlNr4, zahlNr5;
string zahl;
switch (i)
{
case 0:
zahlNr1 =1;
zahlNr2 =2;
zahlNr3 =3;
zahlNr4 =4;
zahlNr5 =5;
zahl= "Erste";
fehler = Zahlen_Pruefen(getippteZahlen, i, fehler,zahlNr1, zahlNr2,zahlNr3, zahlNr4,zahlNr5, zahl);
break;
case 1:
zahlNr1 = 0;
zahlNr2 = 2;
zahlNr3 = 3;
zahlNr4 = 4;
zahlNr5 = 5;
zahl= "Zweite";
fehler = Zahlen_Pruefen(getippteZahlen, i, fehler,zahlNr1, zahlNr2,zahlNr3, zahlNr4,zahlNr5, zahl);
break;
case 2:
zahlNr1 = 0;
zahlNr2 = 1;
zahlNr3 = 3;
zahlNr4 = 4;
zahlNr5 = 5;
zahl= "Dritte";
fehler = Zahlen_Pruefen(getippteZahlen, i, fehler,zahlNr1, zahlNr2,zahlNr3, zahlNr4,zahlNr5, zahl);
break;
case 3:
zahlNr1 = 0;
zahlNr2 = 1;
zahlNr3 = 2;
zahlNr4 = 4;
zahlNr5 = 5;
zahl= "Vierte";
fehler = Zahlen_Pruefen(getippteZahlen, i, fehler,zahlNr1, zahlNr2,zahlNr3, zahlNr4,zahlNr5, zahl);
break;
case 4:
zahlNr1 = 0;
zahlNr2 = 1;
zahlNr3 = 2;
zahlNr4 = 3;
zahlNr5 = 5;
zahl= "Fünfte";
fehler = Zahlen_Pruefen(getippteZahlen, i, fehler,zahlNr1, zahlNr2,zahlNr3, zahlNr4,zahlNr5, zahl);
break;
case 5:
zahlNr1 = 0;
zahlNr2 = 1;
zahlNr3 = 2;
zahlNr4 = 3;
zahlNr5 = 4;
zahl= "Sechste";
fehler = Zahlen_Pruefen(getippteZahlen, i, fehler,zahlNr1, zahlNr2,zahlNr3, zahlNr4,zahlNr5, zahl);
break;
}
}
while (!sechsRichtige)
{
int treffer = 0;
for (int i = 0; i < gezogeneZahlen.Length; i++)
{
gezogeneZahlen[i] = r.Next(1, 49);
}
for (int i = 0; i < gezogeneZahlen.Length; i++)
{
bool fehler = true;
int zahlNr1, zahlNr2, zahlNr3, zahlNr4, zahlNr5;
switch (i)
{
case 0:
zahlNr1 = 1;
zahlNr2 = 2;
zahlNr3 = 3;
zahlNr4 = 4;
zahlNr5 = 5;
fehler = gezogene_Zahlen_Pruefen(r, gezogeneZahlen, i, fehler, zahlNr1, zahlNr2, zahlNr3, zahlNr4, zahlNr5);
break;
case 1:
zahlNr1 = 0;
zahlNr2 = 2;
zahlNr3 = 3;
zahlNr4 = 4;
zahlNr5 = 5;
fehler = gezogene_Zahlen_Pruefen(r, gezogeneZahlen, i, fehler, zahlNr1, zahlNr2, zahlNr3, zahlNr4, zahlNr5);
break;
case 2:
zahlNr1 = 0;
zahlNr2 = 1;
zahlNr3 = 3;
zahlNr4 = 4;
zahlNr5 = 5;
fehler = gezogene_Zahlen_Pruefen(r, gezogeneZahlen, i, fehler, zahlNr1, zahlNr2, zahlNr3, zahlNr4, zahlNr5);
break;
case 3:
zahlNr1 = 0;
zahlNr2 = 1;
zahlNr3 = 2;
zahlNr4 = 4;
zahlNr5 = 5;
fehler = gezogene_Zahlen_Pruefen(r, gezogeneZahlen, i, fehler, zahlNr1, zahlNr2, zahlNr3, zahlNr4, zahlNr5);
break;
case 4:
zahlNr1 = 0;
zahlNr2 = 1;
zahlNr3 = 2;
zahlNr4 = 3;
zahlNr5 = 5;
fehler = gezogene_Zahlen_Pruefen(r, gezogeneZahlen, i, fehler, zahlNr1, zahlNr2, zahlNr3, zahlNr4, zahlNr5);
break;
case 5:
zahlNr1 = 0;
zahlNr2 = 1;
zahlNr3 = 2;
zahlNr4 = 3;
zahlNr5 = 4;
fehler = gezogene_Zahlen_Pruefen(r, gezogeneZahlen, i, fehler, zahlNr1, zahlNr2, zahlNr3, zahlNr4, zahlNr5);
break;
}
}
for (int i = 0; i < getippteZahlen.Length; i++)
{
for (int j = 0; j < gezogeneZahlen.Length; j++)
{
if (getippteZahlen[i] == gezogeneZahlen[j])
{
treffer++;
}
}
}
switch (treffer)
{
case 3:
dreier++;
break;
case 4:
vierer++;
break;
case 5:
fuenfer++;
break;
case 6:
sechsRichtige = true;
break;
default:
break;
}
ziehungen++;
}
warDreier = ziehungen/ dreier;
warVierer = ziehungen/ vierer;
warFuenfer =ziehungen/fuenfer;
for (int i = 0; i < gezogeneZahlen.Length ; i++)
{
Console.WriteLine("Getippte Zahl: " + getippteZahlen[i] + " Gezogene Zahl: " + gezogeneZahlen[i]);
}
Console.WriteLine("Herzlichen Glückwunsch, Sie haben nach "+ziehungen+" Ziehungen 6 Richtige gehabt");
Console.WriteLine("Die Warscheinlichkeit auf \neinen Dreier war: 1:" + warDreier + "\neinen Vierer war: 1:" + warVierer + "\neinen Fünfer war: 1:" + warFuenfer);
}
private static bool gezogene_Zahlen_Pruefen(Random r, int[] gezogeneZahlen, int i, bool fehler, int zahlNr1, int zahlNr2, int zahlNr3, int zahlNr4, int zahlNr5)
{
while (fehler)
{
if ((gezogeneZahlen[i] != gezogeneZahlen[zahlNr1]) &&
(gezogeneZahlen[i] != gezogeneZahlen[zahlNr2]) &&
(gezogeneZahlen[i] != gezogeneZahlen[zahlNr3]) &&
(gezogeneZahlen[i] != gezogeneZahlen[zahlNr4]) &&
(gezogeneZahlen[i] != gezogeneZahlen[zahlNr5]))
{
fehler = false;
}
else
{
gezogeneZahlen[i] = r.Next(1, 49);
}
}
return fehler;
}
private static bool Zahlen_Pruefen(int[] getippteZahlen, int i, bool fehler, int zahlNr1, int zahlNr2, int zahlNr3, int zahlNr4, int zahlNr5, string zahl)
{
while (fehler)
{
if (((getippteZahlen[i] != getippteZahlen[zahlNr1]) &&
(getippteZahlen[i] != getippteZahlen[zahlNr2]) &&
(getippteZahlen[i] != getippteZahlen[zahlNr3]) &&
(getippteZahlen[i] != getippteZahlen[zahlNr4]) &&
(getippteZahlen[i] != getippteZahlen[zahlNr5])) &&
getippteZahlen[i] > 0 && getippteZahlen[i] < 50)
{
fehler = false;
}
else
{
Console.WriteLine(zahl+" Zahl ist ungültig!");
Console.Write("Bitte korrigieren Sie Ihre Eingabe: ");
getippteZahlen[i] = Int16.Parse(Console.ReadLine());
}
}
return fehler;
}
}
}
C#-Codeusing System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Lotto
{
class Program
{
static void Main(string[] args)
{
#region"Variablen
string sEingabe1;
string sEingabe2;
string sEingabe3;
string sEingabe4;
string sEingabe5;
string sEingabe6;
int iEingabe1 = 0;
int iEingabe2 = 0;
int iEingabe3 = 0;
int iEingabe4 = 0;
int iEingabe5 = 0;
int iEingabe6 = 0;
int durchgänge = 1;
int minWert = 1;
int maxWert = 25;
bool stimmt = true;
bool ja = true;
#endregion
#region"Zahlen Abfragen"
#region"ERSTE ZAHL"
do
{ try
{
Console.WriteLine("Geben Sie die erste Zahl ein!");
sEingabe1 = Console.ReadLine();
iEingabe1 = Convert.ToInt32(sEingabe1);
if (iEingabe1 < minWert ||iEingabe1 > maxWert)
{
Console.WriteLine("Die Zahl liegt außerhalb des werte-Bereichs!");
ja = true;
}
else
{
ja = false;
}
}
catch (Exception) { Console.WriteLine("Die eingegebene Zahl ist ungültig"); ja = true; }
}while(ja);
#endregion
#region"ZWEITE ZAHL"
do
{
try
{
Console.WriteLine("Geben Sie die zweite Zahl ein!");
sEingabe2 = Console.ReadLine();
iEingabe2 = Convert.ToInt32(sEingabe2);
ja = false;
if (iEingabe2 < minWert || iEingabe2 > maxWert)
{
Console.WriteLine("Die Zahl liegt außerhalb des Werte-Bereichs!");
ja = true;
}
if (iEingabe2 == iEingabe1)
{
Console.WriteLine("Diese Zahl haben sie schon einmal eingegeben");
ja = true;
}
}
catch (Exception) { Console.WriteLine("Die eingegebene Zahl ist ungültig"); ja = true; }
} while (ja == true);
#endregion
#region"DRITTE ZAHL"
do
{
try
{
Console.WriteLine("Geben Sie die dritte Zahl ein!");
sEingabe3 = Console.ReadLine();
iEingabe3 = Convert.ToInt32(sEingabe3);
ja = false;
if (iEingabe3 < minWert || iEingabe3 > maxWert)
{
Console.WriteLine("Die Zahl liegt außerhalb des werte-Bereichs!");
ja = true;
}
if (iEingabe3 == iEingabe1 || iEingabe3 == iEingabe2)
{
Console.WriteLine("Diese Zahl haben sie schon einmal eingegeben");
ja = true;
}
}
catch (Exception) { Console.WriteLine("Die eingegebene Zahl ist ungültig"); ja = true; }
} while (ja == true);
#endregion
#region"VIERTE ZAHL"
do
{
try
{
Console.WriteLine("Geben Sie die vierte Zahl ein!");
sEingabe4 = Console.ReadLine();
iEingabe4 = Convert.ToInt32(sEingabe4);
ja = false;
if (iEingabe4 < minWert || iEingabe4 > maxWert)
{
Console.WriteLine("Die Zahl liegt außerhalb des werte-Bereichs!");
ja = true;
}
if (iEingabe4 == iEingabe3 ||
iEingabe4 == iEingabe2 ||
iEingabe4 == iEingabe1)
{
Console.WriteLine("Diese Zahl haben sie schon einmal eingegeben");
ja = true;
}
}
catch (Exception) { Console.WriteLine("Die eingegebene Zahl ist ungültig"); ja = true; }
} while (ja == true);
#endregion
#region"FÜNFTE ZAHL"
do
{
try
{
Console.WriteLine("Geben Sie die fünfte Zahl ein!");
sEingabe5 = Console.ReadLine();
iEingabe5 = Convert.ToInt32(sEingabe5);
ja = false;
if (iEingabe5 < minWert ||
iEingabe5 > maxWert)
{
Console.WriteLine("Die Zahl liegt außerhalb des werte-Bereichs!");
ja = true;
}
if (iEingabe5 == iEingabe4 ||
iEingabe5 == iEingabe3 ||
iEingabe5 == iEingabe2 ||
iEingabe5 == iEingabe1)
{
Console.WriteLine("Diese Zahl haben sie schon einmal eingegeben");
ja = true;
}
}
catch (Exception) { Console.WriteLine("Die eingegebene Zahl ist ungültig"); ja = true; }
} while (ja == true);
#endregion
#region"SECHSTE ZAHL"
do
{
try
{
Console.WriteLine("Geben Sie die sechste Zahl ein!");
sEingabe6 = Console.ReadLine();
iEingabe6 = Convert.ToInt32(sEingabe6);
ja = false;
if (iEingabe6 < minWert || iEingabe6 > maxWert)
{
Console.WriteLine("Die Zahl liegt außerhalb des werte-Bereichs!");
ja = true;
}
if (iEingabe6 == iEingabe5 ||
iEingabe6 == iEingabe4 ||
iEingabe6 == iEingabe3 ||
iEingabe6 == iEingabe2 ||
iEingabe6 == iEingabe1)
{
Console.WriteLine("Diese Zahl haben sie schon einmal eingegeben");
ja = true;
}
}
catch (Exception) { Console.WriteLine("Die eingegebene Zahl ist ungültig"); ja = true; }
} while (ja == true);
#endregion
#endregion
#region"Zufall generieren"
do
{
Random rnd = new Random();
int Zahl1 = rnd.Next(maxWert);
int Zahl2 = rnd.Next(maxWert);
int Zahl3 = rnd.Next(maxWert);
int Zahl4 = rnd.Next(maxWert);
int Zahl5 = rnd.Next(maxWert);
int Zahl6 = rnd.Next(maxWert);
int[] intarr = new int[6] {Zahl1, Zahl2, Zahl3, Zahl4, Zahl5, Zahl6};
Console.WriteLine("Bitte Warten sie...");
durchgänge++;
#region "Sechser"
if (intarr.Contains(iEingabe1) & intarr.Contains(iEingabe2) & intarr.Contains(iEingabe3) & intarr.Contains(iEingabe4) & intarr.Contains(iEingabe5) & intarr.Contains(iEingabe6))
{
Console.WriteLine("Sie Haben Gewonnen");
Console.WriteLine("Es wurden " + durchgänge + " benötigt");
Console.ReadLine();
stimmt = false;
}
#endregion
}while(stimmt == true);
#endregion
}
}
}
C#-Code/*
* Erstellt mit SharpDevelop.
* Benutzer: especk
* Datum: 28.01.2015
* Zeit: 10:20
*
* Sie können diese Vorlage unter Extras > Optionen > Codeerstellung > Standardheader ändern.
*/
using System;
using System.Collections.Generic;
namespace Lotto_Simulation_6_aus_49
{
class Program
{
public static void Main(string[] args)
{
Console.Title = "Lotto - Simulation - 6 aus 49";
Console.WriteLine("Geben sie die erste Zahle ein");
int z1= int.Parse(Console.ReadLine());
while(z1<1 || z1>49){Console.WriteLine("Nur Zahlen Zwischen 1 und 49");
Console.WriteLine("Geben sie die erste Zahle ein");
z1=int.Parse(Console.ReadLine());
}
Console.WriteLine("Geben sie die zweite Zahle ein");
int z2= int.Parse(Console.ReadLine());
while(z2<1 || z2>49 || z2==z1)
{ Console.WriteLine("Nur Zahlen Zwischen 1 und 49 und keine Doppelten");
Console.WriteLine("Geben sie die zweite Zahle ein");
z2=int.Parse(Console.ReadLine());
}
Console.WriteLine("Geben sie die dritte Zahle ein");
int z3= int.Parse(Console.ReadLine());
while(z3<1 || z3>49 || z3==z2 || z3==z1)
{ Console.WriteLine("Nur Zahlen Zwischen 1 und 49 und keine Doppelten");
Console.WriteLine("Geben sie die dritte Zahle ein");
z3=int.Parse(Console.ReadLine());
}
Console.WriteLine("Geben sie die vierte Zahle ein");
int z4= int.Parse(Console.ReadLine());
while(z4<1 || z4>49 || z4==z1 || z4==z2 || z4==z3)
{ Console.WriteLine("Nur Zahlen Zwischen 1 und 49 und keine Doppelten");
Console.WriteLine("Geben sie die vierte Zahle ein");
z4=int.Parse(Console.ReadLine());
}
Console.WriteLine("Geben sie die fünfte Zahle ein");
int z5= int.Parse(Console.ReadLine());
while(z5<1 || z5>49 || z5==z1 || z5==z2 || z5==z3 || z5==z4)
{ Console.WriteLine("Nur Zahlen Zwischen 1 und 49 und keine Doppelten");
Console.WriteLine("Geben sie die fünfte Zahle ein");
z5=int.Parse(Console.ReadLine());
}
Console.WriteLine("Geben sie die sechste Zahle ein");
int z6= int.Parse(Console.ReadLine());
while(z6<1 || z6>49 || z6==z1 || z6==z2 || z6==z3 || z6==z4 || z6==z5)
{ Console.WriteLine("Nur Zahlen Zwischen 1 und 49 und keine Doppelten");
Console.WriteLine("Geben sie die sechste Zahle ein");
z6=int.Parse(Console.ReadLine());
}
Random Zr = new Random();
List<int> gefZahlen =new List<int>();
List<int> gegZahlen =new List<int>();
gegZahlen.Add(z1);
gegZahlen.Add(z2);
gegZahlen.Add(z3);
gegZahlen.Add(z4);
gegZahlen.Add(z5);
gegZahlen.Add(z6);
int zv1=0;
int ii=0;
int ee=0;
long iii=0;
do{
while (ii!=6)
{zv1 = Zr.Next(1,50);
if (gefZahlen.Contains(zv1)){zv1 = Zr.Next(1,50);}
else{gefZahlen.Add(zv1);ii++;}
}
gefZahlen.Sort();
gegZahlen.Sort();
iii++;
for (int i =0; i<=5;i++)
{
if (gegZahlen[i]==gefZahlen[i]){ee++;}
}
if(ee!=6){gefZahlen.Clear(); ii=0;ee=0;}
if (iii%1000 == 0) {
Console.WriteLine(iii);
}
}
while (ee!=6);
Console.WriteLine("Es hat {0} Versuche gebraucht um Ihre Zahlen zu ziehen",iii);
foreach (int item in gefZahlen)
{
Console.Write("{0} ",item);
}
Console.WriteLine();
Console.Write("Press any key to continue . . . ");
Console.ReadKey(true);
}
}
}
Hier noch eine etwas kompaktere Lösung:
C#-Code
C#-Codeusing System;
using System.Collections.Generic;
using System.Linq;
namespace trainYourProgrammer
{
class Program
{
private static Random random = new Random();
private static HashSet<int> randomNumbers(int n, int k) {
HashSet<int> result = new HashSet<int> ();
for (int i = 0; i < k; i++) {
int tmp;
do {
tmp = random.Next(n)+1;
} while (result.Contains(tmp));
result.Add(tmp);
}
return result;
}
private static int singleGame(int n, int k, HashSet<int> guessed) {
HashSet<int> winning = randomNumbers (n, k);
int result = 0;
foreach (int g in guessed) {
if (winning.Contains (g)) {
result++;
}
}
return result;
}
private static HashSet<int> userNumbers(int n, int k) {
HashSet<int> result = new HashSet<int> ();
while (result.Count < k) {
Console.Write ((result.Count + 1) + ". Zahl: ");
int userNumber = int.Parse(Console.ReadLine ());
if (result.Contains(userNumber)) {
Console.WriteLine("Diese Zahl wurde bereits getippt");
}
else if (userNumber <= 0 || userNumber > n) {
Console.WriteLine("Zahl muss im Bereich [1;" + n + "] liegen");
}
else {
result.Add(userNumber);
}
}
return result;
}
static void Main (string[] args)
{
HashSet<int> guessed = userNumbers (49, 6);
Console.WriteLine ("Starte Simulation...");
int[] hits = new int[7];
while (hits[6] < 1) {
hits [singleGame (49, 6, guessed)]++;
}
for (int i = 0; i < 7; i++) {
Console.WriteLine (i + " Richtige: " + 100f * hits [i] / hits.Sum () + "%");
}
}
}
} C#-Code
class Program
{
static void Main(string[] args)
{
Random zufall = new Random();
int[] zahlen = new int[6];
List<int> ranZahlen = new List<int>();
while (ranZahlen.Count != zahlen.Length)
{
int z = ((zufall.Next(1, 50) + zufall.Next(1, 50)) % 49) + 1;
if (!ranZahlen.Contains(z)) ranZahlen.Add(z);
}
zahlen = ranZahlen.ToArray();
Lotto loto = new Lotto(zahlen);
loto.run();
Console.WriteLine("0 Richtige: " + ((double)loto.richtigeZahlen[0] / (double)loto.richtigeZahlen.Sum() * 100f).ToString("00.00") + "%");
Console.WriteLine("1 Richtige: " + ((double)loto.richtigeZahlen[1] / (double)loto.richtigeZahlen.Sum() * 100f).ToString("00.00") + "%");
Console.WriteLine("2 Richtige: " + ((double)loto.richtigeZahlen[2] / (double)loto.richtigeZahlen.Sum() * 100f).ToString("00.00") + "%");
Console.WriteLine("3 Richtige: " + ((double)loto.richtigeZahlen[3] / (double)loto.richtigeZahlen.Sum() * 100f).ToString("00.00") + "%");
Console.WriteLine("4 Richtige: " + ((double)loto.richtigeZahlen[4] / (double)loto.richtigeZahlen.Sum() * 100f).ToString("00.00") + "%");
Console.WriteLine("5 Richtige: " + ((double)loto.richtigeZahlen[5] / (double)loto.richtigeZahlen.Sum() * 100f).ToString("00.00") + "%");
Console.WriteLine("6 Richtige: " + ((double)loto.richtigeZahlen[6] / (double)loto.richtigeZahlen.Sum() * 100f).ToString("00.00") + "%");
Console.ReadKey();
}
}
class Lotto
{
private int[] zahlen;
private long count;
public int[] richtigeZahlen;
public Lotto(int[] zahlen)
{
this.zahlen = zahlen;
}
public void run()
{
Random zufall = new Random();
count = 0;
int richtig = 0;
richtigeZahlen = new int[zahlen.Length+1];
while(richtig != zahlen.Length && count != int.MaxValue){
List<int> ranZahlen = new List<int>();
while (ranZahlen.Count != zahlen.Length)
{
int z = zufall.Next(1, 50);
if (!ranZahlen.Contains(z)) ranZahlen.Add(z);
}
count++;
richtig = richtige(ranZahlen.ToArray());
richtigeZahlen[richtig]++;
}
Console.WriteLine("Finished");
}
private int richtige(int[] lottoZahlen)
{
return lottoZahlen.Where(x => zahlen.Contains(x)).Count();
}
}
C#-Codeusing System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Lotto1
{
class Program
{
static void Main(string[] args)
{
Random c = new Random();
int numberOne = Convert.ToInt32(Console.ReadLine());
int numberTwo = Convert.ToInt32(Console.ReadLine());
int numberThree = Convert.ToInt32(Console.ReadLine());
int numberfour = Convert.ToInt32(Console.ReadLine());
int numberfive = Convert.ToInt32(Console.ReadLine());
int numbersix = Convert.ToInt32(Console.ReadLine());
for (long i = 0; i < 10000000000; i++)
{
int firstGuess =c.Next(0, 50);
int secondGuess =c.Next(0, 50);
int firthGuess = c.Next(0, 50);
int fourthGuess = c.Next(0, 50);
int fifthGuess = c.Next(0, 50);
int sixthGuess = c.Next(0, 50);
if (firstGuess == numberOne
&& secondGuess == numberTwo
&& firthGuess == numberThree
&& numberOne!=numberTwo
&& numberOne!=numberThree
&& numberTwo!=numberThree
&& fourthGuess== numberfour
&& fifthGuess==numberfive
&& sixthGuess ==numbersix
) {
Console.WriteLine("You won!! After {0} guesses",i);
break;
}
Console.WriteLine(i);
}
Console.ReadKey();
}
}
} C#-Codeusing System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LottoProgramm
{
class Program
{
public static void SpieleLotto(int[] arr)
{
Random rnd = new Random();
int[] ziehung = new int[6];
int anzahl, anzahlZiehungen = 0;
int dreier = 0, vierer = 0, fuenfer = 0;
do
{
for (int i = 0; i < 6; i++)
{
ziehung[i] = rnd.Next(1, 50);
for (int j = 0; j < i; j++)
{
while (ziehung[i] == ziehung[j]) // Eingabe bereits in der Ziehung
{
ziehung[i] = rnd.Next(1, 50);
}
}
}
anzahl = 0;
for (int i = 0; i < 6; i++)
{
for (int j = 0; j < 6; j++)
{
if (ziehung[i] == arr[j])
{
anzahl++;
}
}
}
if (anzahl == 3) { dreier++; }
else if (anzahl == 4) { vierer++; }
else if (anzahl == 5) { fuenfer++; }
anzahlZiehungen++;
} while (anzahl != 6);
Console.WriteLine("Nach {0} Ziehungen hättest du gewonnen.\nDer Jackpot lag bei {1} Mio.", anzahlZiehungen, rnd.Next(1000));
Console.WriteLine("Bis dahin hättest du {0} 3er, {1} 4er & {2} 5er gehabt", dreier, vierer, fuenfer);
}
static void Main(string[] args)
{
int[] zahlen = new int[6];
int zahl;
bool valid = false;
Console.WriteLine("Wilkommen bei Lotto!\n\n\nDrücken Sie eine beliebige Tase, um fortzufahren");
Console.ReadKey();
for(int i = 0; i < 6; i++){
do
{
Console.Clear();
Console.WriteLine("Geben Sie ihre {0}. Zahl ein: ", (i+1));
valid = Int32.TryParse(Console.ReadLine(), out zahl);
if (valid != true // Eingabe ungültig
|| Array.Exists<int>(zahlen, element => element == zahl) // Eingabe bereits enthalten
|| zahl < 1 || zahl > 49) // Eingabe keine Lottozahl
{
valid = false;
Console.WriteLine("Diese Eingabe ist ungültig. Versuche erneut ...\nDrücke beliebige Taste, um fortzufahren.");
Console.ReadKey();
continue;
}
else
{
zahlen[i] = zahl;
}
} while (valid != true);
}
SpieleLotto(zahlen);
Console.ReadLine();
}
}
}
C#-Code
namespace Exercise_13
{
using System;
using System.Linq;
using static System.Console;
public static class Program
{
private static int _three;
private static int _four;
private static int _five;
private static int _six;
private static int _runs;
public static void Main()
{
int[] numbers = new int[6];
while (true)
{
for (var i = 0; i < 6; i++)
{
WriteLine($"Geben Sie die {i + 1}. Zahl ein (1-49):");
numbers[i] = int.Parse(ReadLine());
}
if (!numbers.Count())
{
WriteLine("Jede Zahl darf nur einmal vorkommen.");
continue;
}
break;
}
Run(numbers);
}
private static void Run(int[] numbers)
{
_runs = 0;
while (_six == 0)
{
int[] draw;
do
{
draw = GetDraw();
} while (!draw.Count());
WriteLine($"Mein LOS : {numbers[0]} | {numbers[1]} | {numbers[2]} | {numbers[3]} | {numbers[4]} | {numbers[5]}");
WriteLine($"Heutige Ziehung : {draw[0]} | {draw[1]} | {draw[2]} | {draw[3]} | {draw[4]} | {draw[5]}");
switch (Compare(numbers, draw))
{
case 3:
WriteLine("3 Richtige.");
_three++;
break;
case 4:
WriteLine("4 Richtige.");
_four++;
break;
case 5:
WriteLine("5 Richtige.");
_five++;
break;
case 6:
WriteLine("JACKPOTT");
_six++;
break;
}
_runs++;
}
Result();
}
private static void Result()
{
WriteLine($"Zu{_runs.GetPercent(_three)} Prozent hast du 3 Richtige!");
WriteLine($"Zu{_runs.GetPercent(_four)} Prozent hast du 4 Richtige!");
WriteLine($"Zu{_runs.GetPercent(_five)} Prozent hast du 5 Richtige!");
WriteLine($"Zu{_runs.GetPercent(_six)} Prozent hast du 6 Richtige!");
WriteLine($"Nach {_runs} Ziehungen");
Read();
}
private static bool Count(this int[] array)
{
foreach (var i in array)
{
var counter = 0;
foreach (var a in array)
{
if (a == i)
{
counter++;
}
}
if (counter > 1)
{
return false;
}
}
return true;
}
private static double GetPercent(this int runs, int points) => 100 / (double) runs * points;
private static int[] GetDraw()
{
int[] draw = new int[6];
var r = new Random();
for (var i = 0; i < 6; i++)
{
draw[i] = r.Next(0, 50);
}
return draw;
}
private static int Compare(int[] numbers, int[] draw)
{
var counter = 0;
foreach (var v in numbers)
{
if (draw.Contains(v))
{
counter++;
}
}
return counter;
}
}
}
C#-Code
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace TrainYourProgrammer13
{
class Program
{
static Random random = new Random();
static void Main(string[] args)
{
decimal zähler = 1;
decimal spiel5 = 0;
decimal spiel4 = 0;
decimal spiel3 = 0;
int[] eingabeZahlen = new int[6];
int[] zufallZahlen = new int[6];
zufallZahlen = NeueZahlen();
for (int i = 0; i <= 5; i++)
{
Console.WriteLine("Geben Sie die {0}. Zahl zwischen 1 und 49 ein: ", i + 1);
int eingabe = Convert.ToInt16(Console.ReadLine());
if (Array.IndexOf(eingabeZahlen, eingabe) < 0 && Convert.ToInt32(eingabe) > 0 && Convert.ToInt32(eingabe) < 50)
{
eingabeZahlen[i] = eingabe;
}
else
{
Console.WriteLine("Ungültige Eingabe. Bitte wiederholen Sie Ihre Eingabe.");
i--;
}
}
for (int i = 0; i < eingabeZahlen.Length; i++)
{
if (Array.IndexOf(eingabeZahlen, zufallZahlen[i]) >= 0)
{
//i = 0;
}
else
{
switch (i)
{
case 5:
spiel5++;
break;
case 4:
spiel4++;
break;
case 3:
spiel3++;
break;
default:
break;
}
zufallZahlen = NeueZahlen();
zähler += 1;
if (zähler % 1000000 == 0)
{
Console.WriteLine(zähler);
}
i = -1;
}
}
spiel5 = spiel5 / zähler * 100;
spiel4 = spiel4 / zähler * 100;
spiel3 = spiel3 / zähler * 100;
Console.WriteLine("Alle Zahlen Stimmen nach {0} Versuchen überein!", zähler);
Console.WriteLine("Dabei lag die Chance auf einen 5er bei {0:F4}%.", spiel5);
Console.WriteLine("Dabei lag die Chance auf einen 4er bei {0:F4}%.", spiel4);
Console.WriteLine("Dabei lag die Chance auf einen 3er bei {0:F4}%.", spiel3);
Console.ReadLine();
}
private static int[] NeueZahlen()
{
int[] zufallZahlen = new int[6];
int zahl;
for (int i = 0; i < zufallZahlen.Length; i++ )
{
zahl = random.Next(1, 50);
if (Array.IndexOf(zufallZahlen, zahl) < 0)
{
zufallZahlen[i] = zahl;
}
else
{
i--;
}
}
return zufallZahlen;
}
}
}
C#-Codeusing System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace TrainYourProgrammer
{
class Program
{
static void Main(string[] args)
{
Aufgabe_13();
Console.ReadKey();
}
static void Aufgabe_13()
{
int[] abgefragteZahlen = new int[6];
int[] lottoZahlen = new int[6];
Random rnd = new Random();
int counter = 0, richtige = 0, randomZahl, abgefragteZahl, dreier = 0, vierer = 0, fünfer = 0;
DateTime start = DateTime.Now, end;
Console.WriteLine("Es wird Lotto gespielt! Geben sie 6 Zahlen zwischen 1 und 49 ein!");
for (int i = 0; i <= 5; i++)
{
Console.Write(i+1 + ". : ");
abgefragteZahl = Convert.ToInt16(Console.ReadLine());
if (1 <= abgefragteZahl && abgefragteZahl <= 49)
{
abgefragteZahlen[i] = abgefragteZahl;
}
else
{
i--;
}
for (int k = 0; k < i; k++)
{
if (abgefragteZahlen[i] == abgefragteZahlen[k])
{
i--;
}
}
}
while (richtige != 6)
{
richtige = 0;
for (int i = 0; i <= 5; i++)
{
randomZahl = rnd.Next(1, 50);
lottoZahlen[i] = randomZahl;
for (int k = 0; k < i; k++)
{
if (lottoZahlen[i] == lottoZahlen[k])
{
randomZahl = rnd.Next(1, 50);
lottoZahlen[i] = randomZahl;
k = -1;
}
}
}
//Console.WriteLine(lottoZahlen[0] + " " + lottoZahlen[1] + " " + lottoZahlen[2] + " " + lottoZahlen[3] + " " + lottoZahlen[4] + " " + lottoZahlen[5]);
for (int i = 0; i <= abgefragteZahlen.Length - 1; i++)
{
for (int k = 0; k <= lottoZahlen.Length - 1; k++)
{
if (abgefragteZahlen[i] == lottoZahlen[k])
{
richtige++;
}
}
}
switch (richtige)
{
case 3:
dreier++;
break;
case 4:
vierer++;
break;
case 5:
fünfer++;
break;
}
counter++;
}
end = DateTime.Now;
Console.WriteLine("Es wurden 6 richtige nach {0} Versuchen erzielt.", counter);
Console.Write("\nDie richtigen Zahlen lauten ");
for (int i = 0; i <= lottoZahlen.Length - 1; i++)
{
Console.Write(lottoZahlen[i] + " ");
}
Console.WriteLine("\nEs wurden {0} mal 3 richtige, {1} mal 4 richtige und {2} mal 5 richtige erreicht.", dreier, vierer, fünfer);
Console.WriteLine("Die Berechnung hat {0} gedauert.", end-start);
}
}
}
Ich habe die Aufgabe minimal abgewandelt. So nutze ich eine Zufallszahlenmethode, um eine Tippreihe zu erstellen und um die Tippdurchläufe zu gestalten.
Bis auf die Auswertung nach explizit Dreier, Vierer, Fünfer ist die Prüf- und Durchlaufroutine (6 aus 49) per Variable steuerbar (oder per Abfrage flexibel gestaltbar).
C#-Code
Bis auf die Auswertung nach explizit Dreier, Vierer, Fünfer ist die Prüf- und Durchlaufroutine (6 aus 49) per Variable steuerbar (oder per Abfrage flexibel gestaltbar).
C#-Code
using System;
namespace Übung13_Lotto
{
class Program
{
static void Main(string[] args)
{
Random rnd = new Random();
int zugZahl = 6, kugelZahl = 49, versuchAnzahl=0;
int zaehler = 0;
int[] lottoMatrix = Zufallszahl(zugZahl, kugelZahl, rnd);
int[] gewinn = new int[zugZahl+1];
double dreier, vierer, fünfer;
Console.WriteLine("Lottozahlen: ");
foreach (int ii in lottoMatrix)
{
Console.WriteLine(ii);
}
do
{
int[] tippMatrix = Zufallszahl(zugZahl, kugelZahl, rnd);
versuchAnzahl++;
foreach (int lotto in lottoMatrix)
{
foreach (int tipp in tippMatrix)
{
if (lotto == tipp)
{
zaehler++;
break;
}
}
}
gewinn[zaehler]++;
zaehler = 0;
} while (gewinn[zugZahl] == 0);
Console.WriteLine();
Console.WriteLine("Sechser!!!, Durchlauf wird beendet!");
Console.WriteLine("Anzahl Versuche: " + versuchAnzahl);
Console.WriteLine();
for (int zahl=3; zahl<=zugZahl; zahl++)
{
Console.WriteLine((zahl)+": "+gewinn[zahl]);
}
Console.WriteLine();
dreier = Math.Round(((double)gewinn[3] * 100 / versuchAnzahl), 2);
vierer = Math.Round(((double)gewinn[4] * 100 / versuchAnzahl), 2);
fünfer = Math.Round(((double)gewinn[5] * 100 / versuchAnzahl), 2);
Console.WriteLine("Die Wahrscheinlichkeit für einen Dreier beträgt {0}%, \nfür einen Vierer {1}% und \nfür einen Fünfer {2}%", dreier, vierer, fünfer);
Console.ReadKey();
}
static public int[] Zufallszahl(int anzahl, int grenze, Random rnd)
{
int zzahl;
int[] lottozahlen = new int[anzahl];
bool einschreiben = false;
for (int i = 0; i < anzahl; i++)
{
zzahl = rnd.Next(1, grenze + 1);
for (int j = 0; j <= i; j++)
{
if (zzahl == lottozahlen[j])
{
i--;
einschreiben = false;
break;
}
else einschreiben = true;
}
if (einschreiben)
{
lottozahlen[i] = zzahl;
einschreiben = false;
}
}
Array.Sort(lottozahlen);
return lottozahlen;
}
}
}
Mit NET Core 3.x erstellt:
C#-Code
C#-Codeusing System;
using System.Linq;
using System.Collections.Generic;
using System.Diagnostics;
namespace CS_Aufgabe_13_Lotto
{
class Program
{
static void Main(string[] args)
{
var arrLottery = new int[7];
var lstNumbers = Generator().ToList();
var counter = 0;
var sw = new Stopwatch();
Console.WriteLine($"Meine Lottozahlen: {string.Join(" | ", lstNumbers.OrderBy(x => x).Select(x => x.ToString("00")))}\n{new string('=', 46)}\n");
Console.Write("\nLottoziehungen gestartet...");
sw.Start();
while (counter < int.MaxValue)
{
counter++;
var lstCompare = Generator().ToList();
var comp = lstNumbers.Intersect(lstCompare).Count();
arrLottery[comp]++;
if (comp == 6) break;
if (counter % 100_000 == 0)
Console.Write(".");
}
sw.Stop();
Console.WriteLine($"\n\nEs wurden {counter} Versuche benötigt! ({sw.Elapsed.Minutes:00}:{sw.Elapsed.Seconds:00})\n");
for (int i = 3; i < arrLottery.Length; i++)
{
Console.WriteLine($"{i}er: {arrLottery[i],-6} ({100 * arrLottery[i] / (double)counter:0.0000} %)");
}
}
static IEnumerable<int> Generator() => Enumerable.Range(1, 49).OrderBy(x => Guid.NewGuid()).Take(6);
}
} C#-Codestatic void Main(string[] args)
{
Random rnd = new Random();
int treffer = 0;
int anzahlZiehungen = 0;
List<double> Auswertung = new List<double>() { 0, 0, 0, 0, 0, 0, 0 };
List<int> meinTip = TipAbgeben();
//Ziehungen durchführen
do
{
treffer = 0;
anzahlZiehungen++;
List<int> ziehung = SechsAusNeunundvierzig(rnd);
foreach (int Zahl in meinTip)
{
if (ziehung.Contains(Zahl))
{
treffer++;
}
}
Auswertung[treffer]++;
} while (treffer!=6 || anzahlZiehungen > int.MaxValue-1);
//Auflistung der Werte
Console.WriteLine("Nach {0:0,0} Ziehungen wurden 6 richtige getippt.", anzahlZiehungen);
Console.WriteLine("Chancen auf: \n3 richtige: {0:0.0000}%\n4 richtige: {1:0.0000}%\n5 richtige: {2:0.0000}%",
Auswertung[2] / (anzahlZiehungen*100),
Auswertung[3] / (anzahlZiehungen*100),
Auswertung[4] / (anzahlZiehungen*100));
Console.ReadKey();
}
private static List<int> SechsAusNeunundvierzig(Random rnd)
{
List<int> sechsZufallsZahlen = new List<int>();
for (int i = 0; i < 6; i++)
{
int meineZahl;
do
{
meineZahl = rnd.Next(1, 49);
} while (sechsZufallsZahlen.Contains(meineZahl));
sechsZufallsZahlen.Add(meineZahl);
}
return sechsZufallsZahlen;
}
private static List<int> TipAbgeben()
{
List<int> tip = new List<int>();
int eingabe;
Console.WriteLine("Werte zwischen 1 und 49 werden aktzeptiert");
do
{
Console.WriteLine("Bitte die {0}. Zahl eingaben", tip.Count+1);
if (int.TryParse(Console.ReadLine(), out eingabe) && eingabe < 50 && eingabe >0 && !tip.Contains(eingabe))
{
tip.Add(eingabe);
}
else
{
Console.WriteLine("Fehlerhafte Eingabe");
}
} while (tip.Count!=6);
Console.WriteLine("Tip wurde aktzeptiert. Bitte warten.");
return tip;
}