C# :: Aufgabe #25
12 Lösungen
Zahlen Raten - Fortgeschrittener
Fortgeschrittener - C#
von zayc_
- 28.12.2012 um 14:00 Uhr
Das zu programmierende Programm soll eine Zufallszahl (integer, der User soll nach dem Bereich gefragt werden) generieren.
Der User soll diese erraten. Nach jedem Versuch soll der User darüber informiert werden, der wie vielte Versuch es war, ob er richtig oder falsch liegt, und wenn er falsch liegt ob die gesuchte Zahl grösser oder kleiner als die vom User eingegebene ist.
Zusatz für Fortgeschrittene:
Bei Falscheingaben (Buchstaben, Sonderzeichen, etz.) soll der User darüber informiert werden.
Bei den Versuchen >10 soll eine führende Null mit ausgegeben werden (also statt 1,2,3 soll 01, 02 ,03 ausgegeben werden.)
Bei der wiederholten Eingabe einer Zahl soll der User darüber informiert werden.
Der User soll den Bereich in dem die Zufallszahl liegen soll, selbst definieren.
Der User soll informiert werden, wenn sein Versuch ausserhalb des definierten Bereichs liegt.
Beispiel einer Konsolenausgabe:
Der User soll diese erraten. Nach jedem Versuch soll der User darüber informiert werden, der wie vielte Versuch es war, ob er richtig oder falsch liegt, und wenn er falsch liegt ob die gesuchte Zahl grösser oder kleiner als die vom User eingegebene ist.
Zusatz für Fortgeschrittene:
Bei Falscheingaben (Buchstaben, Sonderzeichen, etz.) soll der User darüber informiert werden.
Bei den Versuchen >10 soll eine führende Null mit ausgegeben werden (also statt 1,2,3 soll 01, 02 ,03 ausgegeben werden.)
Bei der wiederholten Eingabe einer Zahl soll der User darüber informiert werden.
Der User soll den Bereich in dem die Zufallszahl liegen soll, selbst definieren.
Der User soll informiert werden, wenn sein Versuch ausserhalb des definierten Bereichs liegt.
Beispiel einer Konsolenausgabe:
Konsolenausgabe:
Bitte die Untergränze wählen: 20
Bitte die Obergränze wählen: 60
Bitte erraten sie die gesuchte Zahl, sie befindet sich zwischen 20 und 60.
Ihr 01. Versuch: 5
Die eingegebene Zahl befindet sich ausserhalb des von ihnen definierten Bereich.
Ihr 02. Versuch: halloooo
Bitte nur Z A H L E N eingeben.
Ihr 03. Versuch: 55
Die gesuchte Zahl ist kleiner.
Ihr 04. Versuch: 25
Die gesuchte Zahl ist grösser.
Ihr 05. Versuch: 55
Mit dieser Zahl haben Sie es schon einmal versucht!
Ihr 06. Versuch: 40
Glückwunsch die von Ihnen eingegebene Zahl ( 40 ) stimmt mit der gesuchten Zahl überein.
Lösungen:
Hier ist meine Lösung:
C#-Code
C#-Code
void main()
{
Console.Write("Bitte die Untergrenze wählen: ");
int lower = int.Parse(Console.ReadLine());
Console.Write("Bitte die Obergrenze wählen: ");
int upper = int.Parse(Console.ReadLine());
Console.WriteLine("Bitte erraten Sie die gesuchte Zahl, sie befindet sich zwischen {0} und {1}.", lower, upper);
int random = GetRandom(lower, upper);
int versuch = 1;
List<int> eingaben = new List<int>();
do
{
Console.Write("Ihr {0:00}. Versuch: ", versuch);
string input = Console.ReadLine();
int eingabe = 0;
bool isZahl = int.TryParse(input, out eingabe);
if (isZahl)
{
if (eingabe < lower || eingabe > upper)
{
Console.WriteLine("Die eingegebene Zahl befindet sich außerhalb des von Ihnen definierten Bereichs.");
}
else
{
if (eingaben.Contains(eingabe))
{
Console.WriteLine("Mit dieser Zahl haben Sie es schon einmal versucht!");
}
else
{
eingaben.Add(eingabe);
if (eingabe > random)
{
Console.WriteLine("Die gesuchte Zahl ist kleiner.");
}
else if (eingabe < random)
{
Console.WriteLine("Die gesuchte Zahl ist größer.");
}
else
{
Console.WriteLine("Glückwunsch die von Ihnen eingegebene Zahl ({0}) stimmt mit der gesuchten Zahl überein.", random);
}
}
}
}
else
{
Console.WriteLine("Bitte nur Z A H L E N eingeben.");
}
versuch++;
} while (eingaben.LastOrDefault() != random);
}
private static int GetRandom(int lower, int upper)
{
Random r = new Random();
return r.Next(lower, upper);
}
Die Lösung ist relativ straightforward.
Screenshot der Ausgabe: Link auf imgur.com
Das Programm funktioniert in der Theorie auch mit negativen Werten. Jedoch sollte dann Z30 angepasst werden und iGeraten mit einem null Wert initialisiert werden.
C#-Code
Screenshot der Ausgabe: Link auf imgur.com
Das Programm funktioniert in der Theorie auch mit negativen Werten. Jedoch sollte dann Z30 angepasst werden und iGeraten mit einem null Wert initialisiert werden.
C#-Codestatic void Main(string[] args)
{
bool bInputOK = false;
int iUntergrenze = 0;
int iObergrenze = 0;
while (!bInputOK)
{
Console.Write("Geben Sie die Untergrenze ein: "); string strUntergrenze = Console.ReadLine();
Console.Write("Geben Sie die Obergrenze ein: "); string strObergrenze = Console.ReadLine(); Console.WriteLine();
try
{
iUntergrenze = Int32.Parse(strUntergrenze);
iObergrenze = Int32.Parse(strObergrenze);
}
catch (FormatException)
{
continue;
}
if (iUntergrenze < iObergrenze)
bInputOK = true;
}
Random rng = new Random();
int iZufallszahl = rng.Next(iUntergrenze, iObergrenze + 1);
int iGeraten = -1;
int i = 0;
List<int> lstHistory = new List<int>();
while (iGeraten != iZufallszahl)
{
i++;
if (i <= 9)
Console.Write("Ihr 0" + i + ". Versuch: ");
else
Console.Write("Ihr " + i + ". Versuch: ");
string strGeraten = Console.ReadLine();
try
{
iGeraten = Int32.Parse(strGeraten);
}
catch (FormatException)
{
Console.WriteLine("Bitte nur Ganzzahlen eingeben\r\n");
continue;
}
if (iGeraten < iUntergrenze || iGeraten > iObergrenze)
{
Console.WriteLine("Ihre Eingabe entspricht nicht dem angegebenen Bereich.\r\n");
continue;
}
if (lstHistory.Contains(iGeraten))
{
Console.WriteLine("Diese Zahl wurde schon geraten\r\n");
continue;
}
else
lstHistory.Add(iGeraten);
if (iZufallszahl > iGeraten)
Console.WriteLine("Die Zufallszahl ist grösser.\r\n");
else if (iZufallszahl < iGeraten)
Console.WriteLine("Die Zufallszahl ist kleiner.\r\n");
}
Console.WriteLine("Glückwunsch, Sie haben die Zahl erraten");
Console.ReadLine();
} C#-Code
using System;
using System.Collections.Generic;
namespace zahlenRatenFortgeschritten
{
class Program
{
static void Main(string[] args)
{
int versuch = 1;
int uGrenze = 0;
int oGrenze = 0;
int eingabe = 0;
int zuErratendeZahl = 0;
Random rnd = new Random();
List<int> versuchteZahlen = new List<int>();
do
{
Console.Write("Bitte die Untergrenze wählen: ");
}
while (!Int32.TryParse(Console.ReadLine(), out uGrenze));
do
{
Console.Write("Bitte die Obergrenze wählen: ");
}
while (!Int32.TryParse(Console.ReadLine(), out oGrenze) || oGrenze < uGrenze);
Console.WriteLine("\n");
Console.WriteLine("Bitte erraten Sie die gesuchte Zahl, sie befindet sich zwischen {0} und {1}.\n", uGrenze, oGrenze);
zuErratendeZahl = rnd.Next(uGrenze, oGrenze);
do
{
Console.Write("Ihr ");
if (versuch < 10)
Console.Write("0{0} Versuch: ", versuch);
else
Console.Write("{0} Versuch: ", versuch);
if (!Int32.TryParse(Console.ReadLine(), out eingabe))
Console.WriteLine("Bitte nur Z A H L E N eingeben.\n");
else if (eingabe < uGrenze || eingabe > oGrenze)
Console.WriteLine("Die eingegebene Zahl befindet sich außerhalb des von Ihnen definierten Bereichs.\n");
else if (versuchteZahlen.Contains(eingabe))
Console.WriteLine("Mit dieser Zahl haben Sie es schon einmal versucht!\n");
else if (eingabe < zuErratendeZahl)
{
Console.WriteLine("Die gesuchte Zahl ist größer.\n");
versuchteZahlen.Add(eingabe);
}
else if (eingabe > zuErratendeZahl)
{
Console.WriteLine("Die gesuchte Zahl ist kleiner.\n");
versuchteZahlen.Add(eingabe);
}
versuch++;
}
while (eingabe != zuErratendeZahl);
Console.WriteLine("Glückwunsch die von Ihnen eingegebene Zahl ( {0} ) stimmt mit der gesuchten Zahl überein.", eingabe);
}
}
}
C#-Code
namespace ConsoleApplication4
{
using System;
using System.Collections.Generic;
internal class Program
{
private static int GetRandom(int lower, int upper)
{
var r = new Random();
return r.Next(lower, upper);
}
private static void Main(string[] args)
{
int lower;
int upper;
while (true)
{
Console.Write("Bitte die Untergrenze wählen: ");
if (int.TryParse(Console.ReadLine(), out lower))
{
break;
}
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Bitte nur ganze Z A H L E N eingeben!");
Console.ForegroundColor = ConsoleColor.Gray;
}
while (true)
{
Console.Write("Bitte die Obergrenze wählen: ");
if (int.TryParse(Console.ReadLine(), out upper))
{
break;
}
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Bitte nur ganze Z A H L E N eingeben!");
Console.ForegroundColor = ConsoleColor.Gray;
}
Console.WriteLine("Bitte erraten Sie die gesuchte Zahl, sie befindet sich zwischen {0} und {1}.", lower, upper);
int random = GetRandom(lower, upper);
var eingaben = new List<int>();
int eingabe;
bool gefunden = false;
bool grenze = true;
int versuch = 0;
while (!gefunden)
{
Console.WriteLine("Zahl eingeben");
string input = Console.ReadLine();
versuch += 1;
if (int.TryParse(input, out eingabe))
{
if (eingabe < lower || eingabe > upper)
{
Console.WriteLine("Ihr {0}. Versuch: {1}", versuch, eingabe);
Console.WriteLine("Die Zahl liegt außerhalb der festgelegten Grenze!");
grenze = false;
}
if (eingabe < random && grenze)
{
if (!eingaben.Contains(eingabe))
{
eingaben.Add(eingabe);
Console.WriteLine("Ihr {0}. Versuch: {1}", versuch, eingabe);
Console.WriteLine("Die Zahl ist größer");
}
else
{
Console.WriteLine("Ihr {0}. Versuch: {1}", versuch, eingabe);
Console.WriteLine("Mit der Zahl haben sie es schonmal versucht!");
}
}
if (eingabe > random && grenze)
{
if (!eingaben.Contains(eingabe))
{
eingaben.Add(eingabe);
Console.WriteLine("Ihr {0}. Versuch: {1}", versuch, eingabe);
Console.WriteLine("Die Zahl ist kleiner");
}
else
{
Console.WriteLine("Ihr {0}. Versuch: {1}", versuch, eingabe);
Console.WriteLine("Mit der Zahl haben sie es schonmal versucht!");
}
}
if (eingabe == random)
{
Console.WriteLine("Ihr {0}. Versuch: {1}", versuch, eingabe);
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Glückwunsch Sie haben die gesuchte Zahl {0} gefunden!!", random);
Console.ReadLine();
gefunden = true;
}
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Bitte nur ganze Z A H L E N eingeben!");
Console.ForegroundColor = ConsoleColor.Gray;
}
grenze = true;
}
}
}
}
C#-Code
using System;
using System.Collections.Generic;
using System.Linq;
namespace Zahlen_Raten {
class Program {
static void Main() {
int untergrenze = -1, obergrenze = -1, gesuchteZahl;
List<int> GetippteZahlen = new List<int>();
while (untergrenze < 0) {
Console.Write("Bitte die Untergrenze auswählen>");
try {
untergrenze = Convert.ToInt32(Console.ReadLine());
}
catch (FormatException) { }
}
while (obergrenze <= untergrenze) {
Console.Write("Bitte die Obergrenze auswählen>");
try {
obergrenze = Convert.ToInt32(Console.ReadLine());
}
catch (FormatException) { }
}
Random rnd = new Random();
gesuchteZahl = rnd.Next(untergrenze, obergrenze + 1);
Console.WriteLine("\nBitte erraten Sie die gesuchte Zahl, sie befindet sich zwischen {0} und {1}", untergrenze, obergrenze);
int zähler = 1;
while (GetippteZahlen.LastOrDefault() != gesuchteZahl) {
Console.Write("\nIhr {0:00}. Versuch>", zähler);
try {
GetippteZahlen.Add(Convert.ToInt32(Console.ReadLine()));
if (GetippteZahlen.Count(x => x == GetippteZahlen.LastOrDefault()) > 1) {
Console.WriteLine("Mit dieser Zahl haben Sie es schon einmal versucht!");
GetippteZahlen.RemoveAt(GetippteZahlen.Count - 1);
continue;
}
if (GetippteZahlen.LastOrDefault() < untergrenze || GetippteZahlen.LastOrDefault() > obergrenze) {
Console.WriteLine("Die eingegebene Zahl befindet sich außerhalb des von Ihnen definierten Bereichs.");
continue;
}
if(GetippteZahlen.LastOrDefault() < gesuchteZahl)
Console.WriteLine("Die gesuchte Zahl ist größer.");
if (GetippteZahlen.LastOrDefault() > gesuchteZahl)
Console.WriteLine("Die gesuchte Zahl ist kleiner.");
}
catch (FormatException) {
Console.WriteLine("Bitte nur Z A H L E N eingeben");
}
finally {
zähler++;
}
}
Console.WriteLine("Glückwünsch, die von Ihnen eingegebene Zahl ( {0} ) stimmt mit der gesuchten Zahl überein.", GetippteZahlen.LastOrDefault());
Console.ReadKey(true);
}
}
}
C#-Codeusing System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZahlenratenKonsole
{
class Program
{
static void Main(string[] args)
{
Random rnd = new Random();
Console.WriteLine("Bitte die Untergränze wählen");
int a=Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Bite die Obergrenze wählen");
int b=Convert.ToInt32(Console.ReadLine());
int d = rnd.Next(a, b+1);
Console.WriteLine("Bitte erraten Sie die gesuchte Zahl, sie befindet sich zwischen "+a+" und "+b);
for (int i = 1; i > -1;++i )
{
int e = Convert.ToInt32(Console.ReadLine());
if( e > d)
{
Console.WriteLine("Die Gesuchte Zahl ist kleiner als die eingegebene");
}
else if (e < d)
{
Console.WriteLine("Die Gesuchte Zahl ist Größer als die eingegebene");
}
else if (e == d)
{
Console.WriteLine("GLÜCKWUNSCH! DU HAST GEWONNEN!!!");
break;
}
else if (e > b) { Console.WriteLine("Deine Zahl fällt voll aus dem rahmen"); }
Console.WriteLine("Das war der " + i + " versuch");
}
Console.ReadKey();
}
}
} C#-Codeusing System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace MoreLikeIt
{
class Program
{
static void Main(string[] args)
{
string antwort = "";
do
{
Random rnd = new Random();
int versuch = 0, zahl, raten, unter, ober;
string eingabe = "-1";
bool valid = false;
ArrayList liste = new ArrayList();
Console.Clear();
do
{
Console.Clear();
Console.WriteLine("Untergrenze: ");
valid = int.TryParse(Console.ReadLine(), out unter);
} while (valid != true);
do
{
Console.Clear();
Console.WriteLine("Obergrenze: ");
valid = int.TryParse(Console.ReadLine(), out ober);
} while (valid != true || ober < unter);
zahl = rnd.Next(unter, ober+1);
Console.WriteLine("Erraten sie die Pseudozufallszahl zwischen {0} und {1}", unter, ober);
while (int.Parse(eingabe) != zahl)
{
do
{
if (versuch + 1 < 10)
{
Console.Write("Deine 0{0}. Versuch: ", ++versuch);
}
else
{
Console.Write("Deine {0}. Versuch: ", ++versuch);
}
eingabe = Console.ReadLine();
valid = int.TryParse(eingabe, out raten);
if (valid == false)
{
Console.WriteLine("Ungültige Eingabe.");
continue;
}
if (raten < unter || raten > ober)
{
valid = false;
Console.WriteLine("Eingabe liegt außerhalb des Wertebereichs.");
continue;
}
if (liste.Contains(raten))
{
valid = false;
Console.WriteLine("Diese Eingabe haben Sie bereits versucht.");
continue;
}
} while (valid != true);
liste.Add(raten);
if (raten < zahl)
{
Console.WriteLine("Die Zufallszahl ist größer.");
}
else if (raten > zahl)
{
Console.WriteLine("Die Zufallszahl ist kleiner.");
}
else
{
Console.WriteLine("Richtig :)\nWillst du noch einmal spielen? (N - Nein)");
antwort = Console.ReadLine().ToUpper();
}
}
} while (antwort[0] != 'N');
}
}
}
C#-Codeusing System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZahlenRaten_Fortgeschrittener
{
class Program
{
static void Main(string[] args)
{
// Deklaration der Variablen
int obergrenze, untergrenze, zufallZahl, rateZahl, anzahlVersuch = 1, durchlauf = 0;
Random rnd = new Random();
int[] eingegebeneZahlen;
Console.Write("Bitte die Untergrenze wählen:\t");
untergrenze = Convert.ToInt32(Console.ReadLine()); // Inistalisierung von untergrenze
Console.Write("Bitte die Obergrenze wählen:\t");
obergrenze = Convert.ToInt32(Console.ReadLine()); // Inistalisierung von obergrenze
eingegebeneZahlen = new int[obergrenze - untergrenze]; // Initalisierung von eingegebeneZahlen -> Array ist so größ, wie Zahlen im Wertebereich gibt
Console.WriteLine("\nBitte erraten Sie die gesuchte Zahl, sie befindet sich zwischen " + Convert.ToString(untergrenze) + " und " + Convert.ToString(obergrenze));
zufallZahl = rnd.Next(untergrenze, obergrenze + 1); // Inistalisierung von rateZahl
do
{
if (anzahlVersuch < 10) // Bei den ersten 9 Versuchen eine 0 vor anzahlVersuch ausgeben
if (anzahlVersuch == 1) // erste Ausgabe ohne Zeilenumbruch
Console.Write("Ihr 0" + Convert.ToString(anzahlVersuch) + ". Versuch: ");
else
Console.Write("\nIhr 0" + Convert.ToString(anzahlVersuch) + ". Versuch: ");
else
Console.Write("\nIhr " + Convert.ToString(anzahlVersuch) + ". Versuch: ");
if (Int32.TryParse(Console.ReadLine(), out rateZahl)) // TryParse überprüft ob eingabe ein int ist und ob es in rateZahl gespeichert werden kann und tut dies falls es möglich ist
{
if (rateZahl < untergrenze || rateZahl > obergrenze)
Console.Write("Die eingegebene Zahl befindet sich ausserhalb des von ihnen definierten Bereich.");
else if (DoppelteZahl(eingegebeneZahlen, rateZahl) == true) // Überprüfung auf doppelte Eingabe
Console.Write("Mit dieser Zahl haben Sie es schon einmal versucht!\n");
else if (rateZahl < zufallZahl)
{
Console.Write("Die gesuchte Zahl ist grösser.\n");
eingegebeneZahlen[durchlauf] = rateZahl;
durchlauf++;
}
else if (rateZahl > zufallZahl)
{
Console.Write("Die gesuchte Zahl ist kleiner.\n");
eingegebeneZahlen[durchlauf] = rateZahl;
durchlauf++;
}
}
else
Console.Write("Bitte nur Z A H L E N eingeben.\n");
anzahlVersuch++;
} while (zufallZahl != rateZahl);
Console.WriteLine("Glückwunsch die von Ihnen eingegebene Zahl ( " + Convert.ToString(rateZahl) + " ) stimmt mit der gesuchten Zahl überein.");
Console.Read();
}
static bool DoppelteZahl(int[] eingebeneZahlen, int zahl)
{
for (int i = 0; i < eingebeneZahlen.Length; i++)
if (eingebeneZahlen[i] == zahl) // wurde die Zahl schon einmal eingegeben wird der Wert true zurückgegeben
return true; // Funktion wird damit beendet
return false; // werden keine Dopplungen gefunden wird false zurückgegeben
}
}
} C#-Codeclass Program
{
static void main(string[] args)
{
Console.Write("Untere Grenze: ");
int min = Convert.ToInt32(Console.ReadLine());
Console.Write("Obere Grenze: ");
int max = Convert.ToInt32(Console.ReadLine());
StartGame();
}
static void StartGame(int min, int max)
{
Random rand = new Random();
int number = rand.Next(min, max);
Console.WriteLine("Das Spiel startet.. Viel Glück!");
Check();
}
static bool DoesExist(List<int> eingaben, int userinput)
{
for(int i = 0; i < eingaben.Count<int>(); i++)
{
if(userinput.ToString() == eingaben[i].ToString())
return true;
}
return false;
}
static void Check(int number)
{
List<int> eingaben = new List<int>();
int userinput = null, counter = 0;
while(true)
{
counter++;
if(counter < 10)
Console.Write("Ihr " + "0"+ counter + "Versuch: ");
Console.Write("Ihr " + counter + "Versuch: ");
try //if !int { catch -> print error};
userinput = Convert.ToInt32(Console.ReadLine());
if(DoesExist(eingaben, userinput))
Console.WriteLine("Mit dieser Zahl haben Sie es schon einmal versucht!");
eingaben.Add(userinput);
catch
Console.WriteLine("Bitte nur Z A H L E N eingeben.");
if(userinput > number && userinput < max && userinput > min)
Console.WriteLine("Die gesuchte Zahl ist kleiner.");
else if(userinput < number && userinput < max && userinput > min)
Console.WriteLine("Die gesuchte Zahl ist größer.");
else if(userinput == number)
break;
else
Console.WriteLine("Die gesuchte Zahl befindet sich nicht in ihrem definierten Bereich!");
}
Console.WriteLine("Glückwunsch die von Ihnen eingegebene Zahl ( " + userinput + ") stimmt mit der gesuchten Zahl überein");
}
} C#-Code
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace TrainYourProgrammer25
{
class Program
{
static void Main(string[] args)
{
bool gesucht = true, grenzen = true;
int versuch = 01, zahl, untergrenze = 0, obergrenze = 9999;
while (grenzen)
{
Console.Write("Bitte die Untergrenze wählen: ");
untergrenze = Convert.ToInt32(Console.ReadLine());
Console.Write("\nBitte die Obergrenze eingeben: ");
obergrenze = Convert.ToInt32(Console.ReadLine());
if (untergrenze > obergrenze)
{
Console.WriteLine("Bitte geben Sie eine kleinere Untergrenze als Obergrenze ein.");
}
else
{
grenzen = false;
}
}
int[] zahlen = new int[obergrenze - untergrenze];
Console.WriteLine("\nBitte erraten Sie die gesuchte Zahl, sie befindet sich zwischen {0} und {1}.\n", untergrenze, obergrenze);
Random rnd = new Random();
int zufall = rnd.Next(untergrenze, obergrenze +1);
while (gesucht)
{
if (versuch < 10)
{
Console.Write("Ihr 0{0}. Versuch: ", versuch);
}
else
{
Console.Write("Ihr {0}. Versuch: ", versuch);
}
string eingabe = Console.ReadLine();
if (Int32.TryParse(eingabe, out zahl))
{
if (zahl > obergrenze || zahl < untergrenze)
{
Console.WriteLine("\nDie eingegebene Zahl befindet sich ausserhalb des von Ihnen definierten Bereiches.");
versuch--;
}
else
{
zahlen[versuch-1] = zahl;
if (Array.IndexOf(zahlen, zahl) < 0)
{
if (zahl > zufall)
{
Console.WriteLine("\nDie gesuchte Zahl ist kleiner.");
}
else if (zahl < zufall)
{
Console.WriteLine("\nDie gesuchte Zahl ist größer.");
}
else
{
Console.WriteLine("\nGlückwunsch, die von Ihnen eingegebene Zahl {0} stimmt mit der gesuchten Zahl überein.", zahl);
gesucht = false;
}
}
else
{
Console.WriteLine("Mit dieser Zahl haben Sie es bereits versucht.");
versuch--;
}
}
}
else
{
Console.WriteLine("\nBitte nur Z A H L E N eingeben.");
versuch --;
}
versuch++;
}
Console.ReadKey();
}
}
}
C#-Code static void Aufgabe_25()
{
int zufallsZahl = 0, gerateneZahl, startWert, endWert, counter = 1;
ArrayList zahlen = new ArrayList();
Random random = new Random();
Boolean erraten = false, richtigeEingabe;
Console.Write("Bitte die Untergrenze wählen: ");
startWert = Convert.ToInt16(Console.ReadLine());
Console.Write("Bitte die Obergrenze wählen: ");
endWert = Convert.ToInt16(Console.ReadLine());
Console.WriteLine();
Console.WriteLine("Bitte erraten Sie die gesuchte Zahl, sie befindet sich zwischen {0} und {1}.", startWert, endWert);
Console.WriteLine();
zufallsZahl = random.Next(startWert, endWert + 1);
while (!erraten)
{
if (counter < 10)
{
Console.Write("Ihr 0{0}. Versuch: ", counter);
}
else
{
Console.Write("Ihr {0}. Versuch: ", counter);
}
richtigeEingabe = Int32.TryParse(Console.ReadLine(), out gerateneZahl);
if (!richtigeEingabe)
{
Console.WriteLine("Bitte nur Z A H L E N eingeben.");
}
else
{
for (int i = 0; i <= zahlen.Count - 1; i++)
{
if (gerateneZahl == Convert.ToInt16(zahlen[i]))
{
Console.WriteLine("Mit dieser Zahl haben Sie es schon einmal versucht!");
continue;
}
}
if (gerateneZahl > endWert || gerateneZahl < startWert)
{
Console.WriteLine("Die eingegebene Zahl befindet sich außerhalb des von Ihnen definierten Bereichs.");
}
else
{
if (gerateneZahl > zufallsZahl)
{
Console.WriteLine("Die gesuchte Zahl ist kleiner.");
}
else if (gerateneZahl < zufallsZahl)
{
Console.WriteLine("Die gesuchte Zahl ist größer.");
}
else if (gerateneZahl == zufallsZahl)
{
Console.WriteLine("Glückwunsch die von Ihnen eingegebene Zahl ( {0} ) stimmt mit der gesuchten Zahl überein.", gerateneZahl);
erraten = true;
}
}
zahlen.Add(gerateneZahl);
}
counter++;
}
} C#-Codenamespace ZahlenRaten
{
class ZahlenRaten
{
static void Main(string[] args)
{
var enginge = new Engine();
enginge.ValidateSpan();
}
}
}
C#-Codeusing System;
using System.Linq;
namespace ZahlenRaten
{
class Engine
{
string underS;
string upperS;
string guessS;
int under;
int upper;
int attempts;
int rndNumber;
int guessedNumber;
int[] guessedNumbers = new int[0];
public void ValidateSpan()
{
do
{
Console.Write("Bitte die Untergrenze angeben: ");
underS = (Console.ReadLine());
Console.Write("Bitte die Obergrenze angeben: ");
upperS = (Console.ReadLine());
if (TryParseInt(underS) && TryParseInt(upperS))
{
under = Int32.Parse(underS);
upper = Int32.Parse(upperS);
rndNumber = this.GenerateRndNumber(under, upper);
this.ValidateUserInput(under, upper);
}
else Console.WriteLine("Bitte nur Zahlen eingeben");
} while (!TryParseInt(underS) || !TryParseInt(upperS));
}
private void ValidateUserInput(int under, int upper)
{
do
{
Console.WriteLine("Bitte erraten Sie die gesuchte Zahl, sie befindet sich zwischen {0} und {1}: ", under, upper);
guessS = Console.ReadLine();
if (TryParseInt(guessS))
{
guessedNumber = Int32.Parse(guessS);
this.DetermineCorrectGuess(guessedNumber, under, upper);
}
else Console.WriteLine("Bitte nur Zahlen eingeben");
}
while (!TryParseInt(guessS) || guessedNumber != rndNumber);
}
private void DetermineCorrectGuess(int guessedNumber, int under, int upper)
{
attempts++;
if (guessedNumbers.Contains(guessedNumber))
{
var attempt = attempts.ToString().PadLeft(2, '0');
Console.Clear();
Console.WriteLine("Versuch {0}: Mit dieser Zahl {1} haben sie es schon einmal versucht!", attempts, guessedNumber);
}
else if (guessedNumber < under || guessedNumber > upper)
{
var attempt = attempts.ToString().PadLeft(2, '0');
Console.Clear();
Console.WriteLine("Versuch {0}: Die gesuchte Zahl liegt außerhalb des Definitionbereichs", attempt);
}
else if (guessedNumber < rndNumber)
{
var attempt = attempts.ToString().PadLeft(2, '0');
Console.Clear();
Console.WriteLine("Versuch {0}: Die gesuchte Zahl ist größer", attempt);
Array.Resize(ref guessedNumbers, guessedNumbers.Length + 1);
guessedNumbers[guessedNumbers.GetUpperBound(0)] = guessedNumber;
}
else if (guessedNumber > rndNumber)
{
var attempt = attempts.ToString().PadLeft(2, '0');
Console.Clear();
Console.WriteLine("Versuch {0}: Die gesuchte Zahl ist kleiner", attempt);
Array.Resize(ref guessedNumbers, guessedNumbers.Length + 1);
guessedNumbers[guessedNumbers.GetUpperBound(0)] = guessedNumber;
}
else if (guessedNumber == rndNumber)
{
var attempt = attempts.ToString().PadLeft(2, '0');
Console.Clear();
Console.WriteLine("Versuch {0}: Glückwunsch! Die von Ihnen eingegebene Zahl {1} ist korrekt!", attempt, guessedNumber);
Console.ReadKey();
}
}
private int GenerateRndNumber(int under, int upper)
{
var rndNumber = new Random();
return rndNumber.Next(under, upper++);
}
private bool TryParseInt(String s)
{
int i;
bool valid = Int32.TryParse(s, out i);
return valid;
}
}
}
Konsolenausgabe:
Bitte die Untergrenze angeben: 20
Bitte die Obergrenze angeben: 50
Bitte erraten Sie die gesuchte Zahl, sie befindet sich zwischen 20 und 50:
Versuch 03: Mit dieser Zahl 22 haben sie es schon einmal versucht!
Versuch 08: Die eingegebene Zahl liegt außerhalb des Definitionbereichs
Versuch 12: Die gesuchte Zahl ist größer
Versuch 16: Die gesuchte Zahl ist kleiner
Versuch 18: Glückwunsch! Die von Ihnen eingegebene Zahl 47 ist korrekt!
Fehlermeldung:
Ungültige Spanne, Untergrenze muss größer oder gleich der Obergrenze sein!
Bitte nur Zahlen eingeben!