Lottospiel 6 aus 49 - in C# Konsolenanwendung

Magixx · Hält's aus hier Beiträge: 3

Hallo liebe C# Community. Ich studiere BWL mit Schwerpunkt Wirtschaftsinformatik, wo wir als Aufgabe gestellt bekommen haben auf Basis von C# ein Lottospiel zu Programmieren.

Ich wollte das ganze einfachheitshalber, da ich noch nicht viele Vorkentnisse habe , dies in einer Konsolenanwendung umsetzen.

Zur Zeit bin ich auch recht weit gekommen ( für meine Anfängerverhältnisse). Nun stehe ich leider auf dem Schlauch.

Meine Probleme:

1. Ich würde gerne die 2 Arrays ( 1 von den getippten Zahlen und 2. das von den zufallszahlen erzeugtem Array) mit einander vergleichen, um dem Programm beizubringen, wieviel richtige der Nutzer getippt hat.

2. Der Zahlenbereich der zu tippenden Zahlen sollen noch eingegrenzt werden (1-49 eben ;-)

)

Leider habe ich derzeit keine Ahnung wie ich dies realisieren soll.

Über eine genaue Erklärung evtl auch mit Syntaxhilfe währe ich schwer erfreut.

Hier der Auszug des Quellcodes der Programm.cs:

markieren

C#-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Hausübung_1__.Klassen;

namespace Hausübung_1__
{
    class Program
    {
        static void Main(string[] args)
        {
            Lottospiel();
        }

        private static void Lottospiel()
        {
            //Array für das Speichern der 6 Getippten Zahlen + Superzahl
            Zahlen[] getippte_Zahlen = new Zahlen[7];
            for (int i = 0; i < 7; i++)
            {
                getippte_Zahlen[i] = new Zahlen();
            }
            //6 Spielzahlen + Superzahl erfassen
            Zahlen zahlenErfassen = new Zahlen();

            Console.WriteLine("---------------------------------------------------");
            Console.WriteLine("Herzlich Willkommen zum Lottospiel 6 aus 49");
            Console.WriteLine("---------------------------------------------------");

            // Eingabe Tipp 1
            Console.WriteLine("Bitte geben Sie den ersten Tipp zwischen 1-49 ein:");
            getippte_Zahlen[0].Tipp1 = Console.ReadLine();
            //Console.WriteLine("Ihre erste getippte Zahl lautet:" + getippte_Zahlen[0].Tipp1);
           
           
            //Eingabe Tipp 2 + Dopplungscheck
            Console.WriteLine("Bitte geben Sie den zweiten Tipp zwischen 1-49 ein:");
            getippte_Zahlen[1].Tipp2 = Console.ReadLine();

            if ((getippte_Zahlen[1].Tipp2 == getippte_Zahlen[0].Tipp1)
                || (getippte_Zahlen[1].Tipp1 == getippte_Zahlen[2].Tipp3)
                || (getippte_Zahlen[1].Tipp2 == getippte_Zahlen[3].Tipp4)
                || (getippte_Zahlen[1].Tipp2 == getippte_Zahlen[4].Tipp5)
                || (getippte_Zahlen[1].Tipp2 == getippte_Zahlen[5].Tipp6))
                {
                Console.WriteLine("Sie haben eine Zahl Doppelt eingegeben,bitte geben Sie einen anderen Tipp ein:");
                Console.WriteLine("Bitte geben Sie den zweiten Tipp zwischen 1-49 ein:");
                getippte_Zahlen[1].Tipp2 = Console.ReadLine();
                }


            //Eingabe Tipp 3 + Dopplungscheck
            Console.WriteLine("Bitte geben Sie den dritten Tipp zwischen 1-49 ein:");
            getippte_Zahlen[2].Tipp3 = Console.ReadLine();

            if ((getippte_Zahlen[2].Tipp3 == getippte_Zahlen[0].Tipp1)
                || (getippte_Zahlen[2].Tipp3 == getippte_Zahlen[1].Tipp2)
                || (getippte_Zahlen[2].Tipp3 == getippte_Zahlen[3].Tipp4)
                || (getippte_Zahlen[2].Tipp3 == getippte_Zahlen[4].Tipp5)
                || (getippte_Zahlen[2].Tipp3 == getippte_Zahlen[5].Tipp6))
                {
                Console.WriteLine("Sie haben eine Zahl Doppelt eingegeben,bitte geben Sie einen anderen Tipp ein:");
                Console.WriteLine("Bitte geben Sie den dritten Tipp zwischen 1-49 ein:");
                getippte_Zahlen[2].Tipp3 = Console.ReadLine();
                }

            //Eingabe Tipp 4 + Dopplungscheck
            Console.WriteLine("Bitte geben Sie den vierten Tipp zwischen 1-49 ein:");
            getippte_Zahlen[3].Tipp4 = Console.ReadLine();

            if ((getippte_Zahlen[3].Tipp4 == getippte_Zahlen[0].Tipp1)
               || (getippte_Zahlen[3].Tipp4 == getippte_Zahlen[1].Tipp2)
               || (getippte_Zahlen[3].Tipp4 == getippte_Zahlen[2].Tipp3)
               || (getippte_Zahlen[3].Tipp4 == getippte_Zahlen[4].Tipp5)
               || (getippte_Zahlen[3].Tipp4 == getippte_Zahlen[5].Tipp6))
               {
                Console.WriteLine("Sie haben eine Zahl Doppelt eingegeben,bitte geben Sie einen anderen Tipp ein:");
                Console.WriteLine("Bitte geben Sie den vierten Tipp zwischen 1-49 ein:");
                getippte_Zahlen[3].Tipp4 = Console.ReadLine();
               }

            //Eingabe Tipp 5 + Dopplungscheck
            Console.WriteLine("Bitte geben Sie den fünften Tipp zwischen 1-49 ein:");
            getippte_Zahlen[4].Tipp5 = Console.ReadLine();

            if ((getippte_Zahlen[4].Tipp5 == getippte_Zahlen[0].Tipp1)
               || (getippte_Zahlen[4].Tipp5 == getippte_Zahlen[1].Tipp2)
               || (getippte_Zahlen[4].Tipp5 == getippte_Zahlen[2].Tipp3)
               || (getippte_Zahlen[4].Tipp5 == getippte_Zahlen[3].Tipp4)
               || (getippte_Zahlen[4].Tipp5 == getippte_Zahlen[5].Tipp6))
               {
                Console.WriteLine("Sie haben eine Zahl Doppelt eingegeben,bitte geben Sie einen anderen Tipp ein:");
                Console.WriteLine("Bitte geben Sie den fünften Tipp zwischen 1-49 ein:");
                getippte_Zahlen[4].Tipp5 = Console.ReadLine();
               }

            //Eingabe Tipp 6 + Dopplungscheck
            Console.WriteLine("Bitte geben Sie den sechsten Tipp zwischen 1-49 ein:");
            getippte_Zahlen[5].Tipp6 = Console.ReadLine();

            if ((getippte_Zahlen[5].Tipp6 == getippte_Zahlen[0].Tipp1)
               || (getippte_Zahlen[5].Tipp6 == getippte_Zahlen[1].Tipp2)
               || (getippte_Zahlen[5].Tipp6 == getippte_Zahlen[2].Tipp3)
               || (getippte_Zahlen[5].Tipp6 == getippte_Zahlen[3].Tipp4)
               || (getippte_Zahlen[5].Tipp6 == getippte_Zahlen[4].Tipp5))
               {
                Console.WriteLine("Sie haben eine Zahl Doppelt eingegeben,bitte geben Sie einen anderen Tipp ein:");
                Console.WriteLine("Bitte geben Sie den fünften Tipp zwischen 1-49 ein:");
                getippte_Zahlen[5].Tipp6 = Console.ReadLine();
               }

            Console.WriteLine("-----------------------------------------------------");

            Console.WriteLine("Bitte geben Sie ihre gewünschte Superzahl ein:");
            getippte_Zahlen[6].Superzahl = Console.ReadLine();

            //Wiedervorkommen der getippten Zahlen ausschließen

            

            // Daten zur Kontrolle Ausgeben
            Console.WriteLine("------------------------------------------------------");
            Console.WriteLine("Bitte überprüfen Sie ihre Daten auf Korrektheit!");
            Console.WriteLine("------------------------------------------------------");
            Console.WriteLine("getippte Zahlen:" + getippte_Zahlen[0].Tipp1
                                            + " " + getippte_Zahlen[1].Tipp2
                                            + " " + getippte_Zahlen[2].Tipp3
                                            + " " + getippte_Zahlen[3].Tipp4
                                            + " " + getippte_Zahlen[4].Tipp5
                                            + " " + getippte_Zahlen[5].Tipp6);
            Console.WriteLine("Superzahl:" + getippte_Zahlen[6].Superzahl);
            Console.WriteLine("------------------------------------------------------");
            Console.WriteLine("Sind die Von ihnen getippten Zahlen alle korrekt?");
            Console.WriteLine("------------------------------------------------------");
            //Rekrusiver Funktionsaufruf
            string antwort = "";
            antwort = Console.ReadLine();
            if(antwort.ToUpper()=="J")
                {
                Console.WriteLine("------------------------------------------------------");
                Console.WriteLine("Okay, fahren wir fort - Die Lottozahlen werden gezogen!");
                Console.WriteLine("------------------------------------------------------");
                Lottozahlen_ausgeben();
                }
            else
            {
                Console.WriteLine("------------------------------------------------------");
                Console.WriteLine("Geben Sie ihre gewünschten Zahlen erneut ein:");
                Console.WriteLine("------------------------------------------------------");
                Lottospiel();
            }
           }
           
            // Ziehung der Lottozahlen
        private static void Lottozahlen_ausgeben()
        {
        //    long anzahlTipps = 7;
           
           
        //int[] LottoErgebnisse = new int [anzahlTipps];
           
        //Random Lotto = new Random();

        //for (long i = 0; i < anzahlTipps; i++)
        // {
        //int ergebnis = Lotto.Next(1,49);
        //LottoErgebnisse[i] = ergebnis;
        // }
        //    //Ausgabe der Lottozahlen
        //Console.WriteLine("------------------------------------------------------");
        //Console.WriteLine("Die Ergebnisse lauten:" + LottoErgebnisse.ToString() );
        //Console.WriteLine("------------------------------------------------------");
        //Console.ReadLine();

            int r;
            Random zufall = new Random();
            int[] lotto = new int[7];
            Console.Clear();
            Console.WriteLine("\t\tErgebnisse der Lottoziehung:");
            Console.WriteLine("\t\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
            for (int i = 0; i < 6; i++)
            {



                    lotto[i] = zufall.Next(0, 50);


                    Console.WriteLine("\t\t" + (i + 1) + ".Zahl: {0}", lotto[i]);

            }
            Random test = new Random();
            r = test.Next(0, 50);
            Console.WriteLine("\t\tZusatzzahl: {0}", r);
            Console.WriteLine("\t\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~");

            //Richtige Tipps vergleichen
            Console.WriteLine("Anzahl der richtigen Tipps");
            Console.ReadLine();



    }
    }
}

Klasse COde:

markieren

C#-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Hausübung_1__.Klassen
{
    class Zahlen
    {
        //Interne Variablen
        int[] _tipps = new int[7];
        private string tipp1;
        private string tipp2;
        private string tipp3;
        private string tipp4;
        private string tipp5;
        private string tipp6;
        private string superzahl;
        public int MIN = 1;
        public int MAX = 49;

        //TIPP[] gewaehlter_Tipp = new TIPP[7];

        //for (i = 0; i < 7; i++)
        //{
        //gewaehlter_Tipp[i] = new TIPP();
        //}
        //gewaehlter_Tipp



        public int[] tipps
        {
            set {_tipps = value;}
            get { return _tipps; }
            }


        public string Tipp1
        {
            get
            {
                return tipp1;
            }
            set
            {
                tipp1 = value;
            }
        }

        public string Tipp2
        {
            get
            {
                return tipp2;
            }
            set
            {
                tipp2 = value;
            }
        }

        public string Tipp3
        {
            get
            {
                return tipp3;
            }
            set
            {
                tipp3 = value;
            }
        }

        public string Tipp4
        {
            get
            {
                return tipp4;
            }
            set
            {
                tipp4 = value;
            }
        }


        public string Tipp5
        {
            get
            {
                return tipp5;
            }
            set
            {
                tipp5 = value;
            }
        }

        public string Tipp6
        {
            get
            {
                return tipp6;
            }
            set
            {
                tipp6 = value;
            }
        }

        public string Superzahl
        {
            get
            {
                return superzahl;
            }
            set
            {
                superzahl = value;
            }
        }


    }
}

Moderiert von Kha: C#-Tags hinzugefügt, doppelten Text gelöscht

Kha · Verfasst: Di 26.05.09 11:48

Ein paar Hinweise wurden dir ja hier schon gegeben. Mir fällt vor allem ein gedanklicher Fehler auf: Zahlen nimmt doch schon sieben Werte auf, mit einem Array davon hast du 49 Tipps!
Ich würde die Zahlen-Klasse außen vor lassen, versuch es erst einmal einfach mit einem int[] tipps = new int[7];. Danach liest du in einer Schleife die Tipps in das Array ein - kann doch nicht sein, dass dort siebenmal quasi der gleiche Quelltext steht :zwinker:

. Falls das Erkennen von doppelten Tipps zu schwierig wird (dazu wirst du innerhalb der Schleife eine zweite benötigen), lass es erstmal weg, darüber können wir danach noch reden.

Zitat:

Wir lernen alles im Schnelldurchgang und lediglich Abtippen des Quelltexxtes unseres Profs.

Dann wirst du unbedingt weitere Quellen benötigen, z.B. das beliebte Open-Book C#: openbook.galileocomp...ng.de/visual_csharp/

_________________
>λ=

JüTho · Verfasst: Di 26.05.09 14:13

Und ich bin vor allem sauer, weil die einzelnen Tipps immer noch als Strings deklariert werden. Wie man nur auf diese Idee kommen kann (zumal _tipps als int[7] zusätzlich existiert).

Zum dritten (und letzten) Mal verweise ich darauf, dass man bei List<int> mit Contains arbeiten kann und ich dies deshalb vorziehen würde.

Jürgen

Magixx · Hält's aus hier Beiträge: 3

Ruhig großer ;D

So ich habe eure Tipps denke ich mal beherzigt und habe die Klasse Zahlen komplett aus dem Code rausgeschmissen. Hätte ich gewusst dass 2 Arrays mit einander vergleichbar sind, wenn man keine neue Funktion gründet wäre mir auch ein licht aufgegangen, was die vergleichsmöglichkeit anbetrifft.

Ich habe mal veruscht ein Konstrukt zu entwerfen, was mir die richtigen Tipps ausgibt, bin aber noch nicht so weit gekommen, da bei dieser Grundüberlegung ein (oder) in einer if funktion mit (und) wohl nicht ausgeführt wird.

Nun gehts weiter mit dem Vergleichen wo ich aufm Schlauch stehe

Mein Code sieht derzeit wie folgt aus:

markieren

C#-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Hausübung_1__
{
    class Program
    {
        static void Main(string[] args)
        {
            Lottospiel();
        }

        private static void Lottospiel()
        {
            //Array für das Speichern der 6 Getippten Zahlen
            int[] Tipps_Array = new int[6];
            //Array für die Superzahl
            int[] Zusatzzahl_Array = new int[1];

            //6 Spielzahlen + Superzahl erfassen
            Console.WriteLine("---------------------------------------------------");
            Console.WriteLine("Herzlich Willkommen zum Lottospiel 6 aus 49");
            Console.WriteLine("---------------------------------------------------");

            // Eingabe Tipp 1
            Console.WriteLine("Bitte geben Sie den ersten Tipp zwischen 1-49 ein:");
            Tipps_Array [0] = Convert.ToInt32(Console.ReadLine());
            //Console.WriteLine("Ihre erste getippte Zahl lautet:" + getippte_Zahlen[0].Tipp1);
            
            
            //Eingabe Tipp 2 + Dopplungscheck
            Console.WriteLine("Bitte geben Sie den zweiten Tipp zwischen 1-49 ein:");
            Tipps_Array[1] = Convert.ToInt32(Console.ReadLine());

            if ((Tipps_Array[1] == Tipps_Array[0])
                || (Tipps_Array[1] == Tipps_Array[2])
                || (Tipps_Array[1] == Tipps_Array[3])
                || (Tipps_Array[1]== Tipps_Array[4])
                || (Tipps_Array[1] == Tipps_Array[5]))
                {
                Console.WriteLine("Sie haben eine Zahl Doppelt eingegeben,bitte geben Sie einen anderen Tipp ein:");
                Console.WriteLine("Bitte geben Sie den zweiten Tipp zwischen 1-49 ein:");
                Tipps_Array[1] = Convert.ToInt32(Console.ReadLine());
                }


            //Eingabe Tipp 3 + Dopplungscheck
            Console.WriteLine("Bitte geben Sie den dritten Tipp zwischen 1-49 ein:");
            Tipps_Array[2] = Convert.ToInt32(Console.ReadLine());

            if ((Tipps_Array[2] == Tipps_Array[0])
                || (Tipps_Array[2] == Tipps_Array[1])
                || (Tipps_Array[2] == Tipps_Array[3])
                || (Tipps_Array[2] == Tipps_Array[4])
                || (Tipps_Array[2] == Tipps_Array[5]))
                {
                Console.WriteLine("Sie haben eine Zahl Doppelt eingegeben,bitte geben Sie einen anderen Tipp ein:");
                Console.WriteLine("Bitte geben Sie den dritten Tipp zwischen 1-49 ein:");
                Tipps_Array[2] = Convert.ToInt32(Console.ReadLine());
                }

            //Eingabe Tipp 4 + Dopplungscheck
            Console.WriteLine("Bitte geben Sie den vierten Tipp zwischen 1-49 ein:");
            Tipps_Array[3] = Convert.ToInt32(Console.ReadLine());

            if ((Tipps_Array[3] == Tipps_Array[0])
               || (Tipps_Array[3] == Tipps_Array[1])
               || (Tipps_Array[3] == Tipps_Array[2])
               || (Tipps_Array[3] == Tipps_Array[4])
               || (Tipps_Array[3] == Tipps_Array[5]))
               {
                Console.WriteLine("Sie haben eine Zahl Doppelt eingegeben,bitte geben Sie einen anderen Tipp ein:");
                Console.WriteLine("Bitte geben Sie den vierten Tipp zwischen 1-49 ein:");
                Tipps_Array[3] = Convert.ToInt32(Console.ReadLine());
               }

            //Eingabe Tipp 5 + Dopplungscheck
            Console.WriteLine("Bitte geben Sie den fünften Tipp zwischen 1-49 ein:");
            Tipps_Array[4] = Convert.ToInt32(Console.ReadLine());

            if ((Tipps_Array[4] == Tipps_Array[0])
               || (Tipps_Array[4] == Tipps_Array[1])
               || (Tipps_Array[4] == Tipps_Array[2])
               || (Tipps_Array[4] == Tipps_Array[3])
               || (Tipps_Array[4] == Tipps_Array[5]))
               {
                Console.WriteLine("Sie haben eine Zahl Doppelt eingegeben,bitte geben Sie einen anderen Tipp ein:");
                Console.WriteLine("Bitte geben Sie den fünften Tipp zwischen 1-49 ein:");
                Tipps_Array[4] = Convert.ToInt32(Console.ReadLine());
               }

            //Eingabe Tipp 6 + Dopplungscheck
            Console.WriteLine("Bitte geben Sie den sechsten Tipp zwischen 1-49 ein:");
            Tipps_Array[5] = Convert.ToInt32(Console.ReadLine());

            if ((Tipps_Array[5] == Tipps_Array[0])
               || (Tipps_Array[5] == Tipps_Array[1])
               || (Tipps_Array[5] == Tipps_Array[2])
               || (Tipps_Array[5] == Tipps_Array[3])
               || (Tipps_Array[5] == Tipps_Array[4]))
               {
                Console.WriteLine("Sie haben eine Zahl Doppelt eingegeben,bitte geben Sie einen anderen Tipp ein:");
                Console.WriteLine("Bitte geben Sie den fünften Tipp zwischen 1-49 ein:");
                Tipps_Array[5] = Convert.ToInt32(Console.ReadLine());
               }

            Console.WriteLine("-----------------------------------------------------");
            Console.WriteLine("Bitte geben Sie ihre gewünschte Superzahl ein:");
            Console.WriteLine("-----------------------------------------------------");
            Zusatzzahl_Array[0] = Convert.ToInt32(Console.ReadLine());

            //Wiedervorkommen der getippten Zahlen ausschließen

             

            // Daten zur Kontrolle Ausgeben
            Console.WriteLine("------------------------------------------------------");
            Console.WriteLine("Bitte überprüfen Sie ihre Daten auf Korrektheit!");
            Console.WriteLine("------------------------------------------------------");
            Console.WriteLine("getippte Zahlen:" + Tipps_Array[0]
                                            + " " + Tipps_Array[1]
                                            + " " + Tipps_Array[2]
                                            + " " + Tipps_Array[3]
                                            + " " + Tipps_Array[4]
                                            + " " + Tipps_Array[5]);
            Console.WriteLine("Superzahl:" + Zusatzzahl_Array[0]);
            Console.WriteLine("------------------------------------------------------");
            Console.WriteLine("Sind die Von ihnen getippten Zahlen alle korrekt?");
            Console.WriteLine("------------------------------------------------------");
            //Rekrusiver Funktionsaufruf
            string antwort = "";
            antwort = Console.ReadLine();
            if(antwort.ToUpper()=="J")
                {
                Console.WriteLine("------------------------------------------------------");
                Console.WriteLine("Okay, fahren wir fort - Die Lottozahlen werden gezogen!");
                Console.WriteLine("drücken sie bitte eine beliebige Taste um fortzufahren");
                Console.WriteLine("------------------------------------------------------");
                Console.ReadLine();
                }
            else
            {
                Console.WriteLine("------------------------------------------------------");
                Console.WriteLine("Geben Sie ihre gewünschten Zahlen erneut ein:");
                Console.WriteLine("------------------------------------------------------");
                Lottospiel();
            }
           

        //Ausgabe der Lottozahlen
            int r;
            Random zufall = new Random();
            int[] lotto = new int[7];
            Console.Clear();
            Console.WriteLine("\t\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
            Console.WriteLine("\t\t Die Ergebnisse der heutigen Lottoziehung:");
            Console.WriteLine("\t\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
            for (int i = 0; i < 6; i++)
            {



                    lotto[i] = zufall.Next(1, 49);


                    Console.WriteLine("\t\t" + (i + 1) + ".Zahl: {0}", lotto[i]);

            }
            Random test = new Random();
            r = test.Next(0, 50);
            Console.WriteLine("\t\tZusatzzahl: {0}", r);
            Console.WriteLine("\t\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~");

            //Richtige Tipps vergleichen
            Console.WriteLine("Anzahl der richtigen Tipps");
            
            //Überprüfung mit Tipp 1

            if ((Tipps_Array[0] == lotto[0])
               || (Tipps_Array[0] == lotto[1])
               || (Tipps_Array[0] == lotto[2])
               || (Tipps_Array[0] == lotto[3])
               || (Tipps_Array[0] == lotto[4])
               || (Tipps_Array[0] == lotto[5]))
            {
                Console.WriteLine("Herzlichen Glückwunsch, Sie haben einen richtigen!");
                
            }
            else if
                ((Tipps_Array[0] == lotto[0])
               && (Tipps_Array[0] == lotto[1])
               || (Tipps_Array[0] == lotto[2])
               || (Tipps_Array[0] == lotto[3])
               || (Tipps_Array[0] == lotto[4])
               || (Tipps_Array[0] == lotto[5]))
            {
                Console.WriteLine("Herzlichen Glückwunsch, Sie haben zwei richtige!");

            }
            else if
                ((Tipps_Array[0] == lotto[0])
               || (Tipps_Array[0] == lotto[1])
               && (Tipps_Array[0] == lotto[2])
               || (Tipps_Array[0] == lotto[3])
               || (Tipps_Array[0] == lotto[4])
               || (Tipps_Array[0] == lotto[5]))
            {
                Console.WriteLine("Herzlichen Glückwunsch, Sie haben zwei richtige!");

            }
            else if
                ((Tipps_Array[0] == lotto[0])
               || (Tipps_Array[0] == lotto[1])
               || (Tipps_Array[0] == lotto[2])
               && (Tipps_Array[0] == lotto[3])
               || (Tipps_Array[0] == lotto[4])
               || (Tipps_Array[0] == lotto[5]))
            {
                Console.WriteLine("Herzlichen Glückwunsch, Sie haben zwei richtige!");

            }
            else if
                ((Tipps_Array[0] == lotto[0])
               || (Tipps_Array[0] == lotto[1])
               || (Tipps_Array[0] == lotto[2])
               || (Tipps_Array[0] == lotto[3])
               && (Tipps_Array[0] == lotto[4])
               || (Tipps_Array[0] == lotto[5]))
            {
                Console.WriteLine("Herzlichen Glückwunsch, Sie haben zwei richtige!");

            }
            else if 
                ((Tipps_Array[0] == lotto[0])
               || (Tipps_Array[0] == lotto[1])
               || (Tipps_Array[0] == lotto[2])
               || (Tipps_Array[0] == lotto[3])
               || (Tipps_Array[0] == lotto[4])
               && (Tipps_Array[0] == lotto[5]))
            {
                Console.WriteLine("Herzlichen Glückwunsch, Sie haben zwei richtige!");

            }
            Console.ReadLine();



    }
    }
}

Kha · Verfasst: Di 26.05.09 16:43

Magixx hat folgendes geschrieben :

So ich habe eure Tipps denke ich mal beherzigt und habe die Klasse Zahlen komplett aus dem Code rausgeschmissen.

Gut, aber eine Schleife zum Einlesen wäre immer noch um einiges eleganter

.

Und beim Vergleichen wirst du um eine Schleife nicht herumkommen. Du musst für jeden Tipp schauen, ob er im lotto-Array vorhanden ist - was du entweder über eine weitere Schleife oder über Array.IndexOf erledigen kannst.

_________________
>λ=

Mystica · Hält's aus hier Beiträge: 1

Hallo,

ich habe ein kleines Programm in Visual Studio C# zum Lottospiel 6 aus 45 erstellt und ich habe versucht eure Tipps zu beherzigen, doch ich komme dennoch nicht auf einen grünen Zweig. Denn es wird mir kein Fehler angezeigt, wenn ich das Programm ausführen und beim ersten Tipp habe ich auch noch kein Problem. Doch wenn ich erneut eine beliebige Zahl eingebe, dann kommt immer, egal ob die Zahl doppelt ist oder nicht, die Meldung "Sie haben einen Tipp doppelt eingeben, geben Sie bitte eine anderen Tipp zwischen 1-46 ein:".

Also habe ich nach dem 1. Tipp einen Fehler, den ich einfach seit 3 Tagen nicht finde. Ich hoffe es kann mir jemand helfen, wäre sehr dankbar.

Liebe Grüße
Mystica

markieren

C#-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Lotto
{
    class Program
    {
        static void Main(string[] args)
        {
            Lottospiel();
        }

        private static void Lottospiel()
        {
            //Array für das Speichern der 6 Getippten Zahlen
            int[] lotto = new int[45];

            // lotto[0]=1;
            // lotto[1]=2;
            // lotto[2]=3;
            // lotto[3]=4;
            // lotto[4]=5;
            // lotto[5]=6;
            // lotto[6]=7;
            // lotto[7]=8;
            // lotto[8]=9;
            // lotto[9]=10;
            // ...
            // ...

            Random random = new Random();
            int ra;
            string input;
            Console.Clear();

            // 1. Lottozahl zwischen 1-46:
            do
            {
                ra = random.Next(1, 46);
                Console.WriteLine("Bitte geben Sie den 1. Tipp zwischen 1-46 ein: ");
                input = (Console.ReadLine());

            } while ((input == "j") || (input == "J"));


            // 2. Lottozahl zwischen 1-46:
            do
            {
                ra = random.Next(1, 46);
                Console.WriteLine("Bitte geben Sie den 2. Tipp zwischen 1-46 ein: ");
                input = (Console.ReadLine());


            } while ((input == "j") || (input == "J"));

            if ((lotto[1] == lotto[0])
                || (lotto[1] == lotto[2])
                || (lotto[1] == lotto[3])
                || (lotto[1] == lotto[4])
                || (lotto[1] == lotto[5]))
            {
                Console.WriteLine("Sie haben einen Tipp doppelt eingeben, geben Sie bitte einen anderen Tipp zwischen 1-46 ein: ");
                Console.WriteLine("Bitte geben Sie den 2. Tipp zwischen 1-46 ein: ");
                input = (Console.ReadLine());
            }


            // 3. Lottozahl zwischen 1-46:
            do
            {
                ra = random.Next(1, 46);
                Console.WriteLine("Bitte geben Sie den 2. Tipp zwischen 1-46 ein: ");
                input = (Console.ReadLine());

            } while ((input == "j") || (input == "J"));

            if ((lotto[2] == lotto[0])
                || (lotto[2] == lotto[1])
                || (lotto[2] == lotto[3])
                || (lotto[2] == lotto[4])
                || (lotto[2] == lotto[5]))
            {
                Console.WriteLine("Sie haben einen Tipp doppelt eingeben, geben Sie bitte einen anderen Tipp zwischen 1-46 ein: ");
                Console.WriteLine("Bitte geben Sie den 2. Tipp zwischen 1-46 ein: ");
                input = (Console.ReadLine());
            }


            // 4. Lottozahl zwischen 1-46:
            do
            {
                ra = random.Next(1, 46);
                Console.WriteLine("Bitte geben Sie den 2. Tipp zwischen 1-46 ein: ");
                input = (Console.ReadLine());

            } while ((input == "j") || (input == "J"));

            if ((lotto[3] == lotto[0])
                || (lotto[3] == lotto[1])
                || (lotto[3] == lotto[2])
                || (lotto[3] == lotto[4])
                || (lotto[3] == lotto[5]))
            {
                Console.WriteLine("Sie haben einen Tipp doppelt eingeben, geben Sie bitte einen anderen Tipp zwischen 1-46 ein: ");
                Console.WriteLine("Bitte geben Sie den 2. Tipp zwischen 1-46 ein: ");
                input = (Console.ReadLine());
            }


            // 5. Lottozahl zwischen 1-46:
            do
            {
                ra = random.Next(1, 46);
                Console.WriteLine("Bitte geben Sie den 2. Tipp zwischen 1-46 ein: ");
                input = (Console.ReadLine());

            } while ((input == "j") || (input == "J"));

            if ((lotto[4] == lotto[0])
                || (lotto[4] == lotto[1])
                || (lotto[4] == lotto[2])
                || (lotto[4] == lotto[3])
                || (lotto[4] == lotto[5]))
            {
                Console.WriteLine("Sie haben einen Tipp doppelt eingeben, geben Sie bitte einen anderen Tipp zwischen 1-46 ein: ");
                Console.WriteLine("Bitte geben Sie den 2. Tipp zwischen 1-46 ein: ");
                input = (Console.ReadLine());
            }


            // 6. Lottozahl zwischen 1-46:
            do
            {
                ra = random.Next(1, 46);
                Console.WriteLine("Bitte geben Sie den 2. Tipp zwischen 1-46 ein: ");
                input = (Console.ReadLine());

            } while ((input == "j") || (input == "J"));

            if ((lotto[4] == lotto[0])
                || (lotto[4] == lotto[1])
                || (lotto[4] == lotto[2])
                || (lotto[4] == lotto[3])
                || (lotto[4] == lotto[5]))
            {
                Console.WriteLine("Sie haben einen Tipp doppelt eingeben, geben Sie bitte einen anderen Tipp zwischen 1-46 ein: ");
                Console.WriteLine("Bitte geben Sie den 2. Tipp zwischen 1-46 ein: ");
                input = (Console.ReadLine());
            }
        }
    }
}

Moderiert von Christian S.: C#-Tags hinzugefügt

Trashkid2000 · Beiträge: 561 Erhaltene Danke: 137

Hi,

@Mystica
Dass in Deinem Code bis auf die erste Abfrage immer Bitte geben Sie den 2. Tipp...steht, ist Dir noch nicht aufgefallen? Das kommt durch das Copy & Paste, wenn man viel doppelten Code drin hat und zu faul zum schreiben ist. Ist ja auch nicht Sinn der Sache. Stell Dir mal vor, es wäre eine Ziehung von 1.000 aus 100.000.000!
Würdest Du dann 1.000 Mal das gleiche schreiben?

Wozu gibt es Schleifen? Und das int[] lotto = new int[45]. Wozu eigentlich? Und warum immer die neu generierte Zufallszahl? An der Stelle.

Also, ich würde so vorgehen:
1. int-Array mit 6 Stellen
2. vielleicht noch eine int-Variable für die Zusatzzahl.
3. Schleife von 0 bis 6 (aber keine for)
3.1 prüfen, ob eingegebener string Zahl, ansonsten Fehlermeldung
3.2 prüfen, ob Zahl > 0 und < 50, ansonsten Fehlermeldung
3.3 prüfen, ob Zahl schon in der Liste existiert. Wenn ja, Fehlermeldung, wenn nein, Zahl an Stelle x übernehmen und Zähler der Schleife hochzählen.

so, wenn Schleife dann durchlaufen, dann vielleicht noch eine Eingabe der Zusatzzahl, natürlich auch mit Prüfung auf int.

Wenn dann alle Werte eingetippt sind, dann 6 (oder 7, mit Zusatzzahl) Zahlen generieren lassen. Beim generieren natürlich darauf achten, dass die neue Zahl noch nicht generiert wurde. Ansonsten solange weiter machen, bis die Zufallszahlen gewürfelt sind.

Und dann die Auswertung.

Das Ganze ist wirklich nicht viel Code, trotz der Prüfungen.

LG, Marko

Normaner · Hält's aus hier Beiträge: 1

Hallo Magixx,

Ich studiere auch BWL mit Informatik als Nebenfach an der TU und muss eine ähnliche [url=www.lotto-6aus49.com]Lotto[/URL] Aufgabe lösen, darf ich einfach Teile von dem Code nutzen?
Vielen lieben Dank!!!!!!

Moderiert von Christian S.: Komplett-Zitat entfernt

Namenlosnameless · Verfasst: Mi 19.10.11 23:27

Hallo! Hier mal die Eingabe mit einer Schleife!

markieren

C#-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:

        static void Main(string[] args)
        {
            const int grenze_unten = 1;
            const int grenze_oben = 49;
            const int groesse_tipp=6;

            List<int> Tipps = new List<int> { }; ;

            //Tippeingabe

            for (int counter = 0; counter < groesse_tipp; counter++)
            {
                //Definiere Prüfvariablen, um Fehler anzuzeigen.
                bool errorhandling1 = false;
                bool errorhandling2 = false;
                //Die Eingabe Variable definieren.
                int converted_input=0;
                //Prüfe ob beim Konvertieren eine Exception auftritt
                try
                {
                    converted_input = int.Parse(Console.ReadLine());
                }
                catch (FormatException)
                {//Wenn Format-Exception dann dem Programm sagen, dass ein Fehler ausgelöst wurde.
                    errorhandling1 = true;
                }
                if (converted_input < grenze_unten && converted_input > grenze_oben)
                {//Wenn Eingabe nicht innerhalb der Grenzen, dann dem Programm sagen, dass ein Fehler ausgelöst wurde.
                    errorhandling1 = true;
                }
                if (errorhandling1)
                {//Wenn ein Fehler aufgetreten ist hier her springen!
                    Console.WriteLine("Bitte geben Sie eine ZAHL zwischen " + grenze_unten.ToString() + " und " + grenze_oben.ToString() + " ein!");
                    Console.WriteLine("Geben Sie nun Tipp " + (counter + 1).ToString() + " ein!");
                    //Conter zurück setzen, um die Eingabe zu wiederholen!
                    counter--;
                }
                //Wenn Eingabe korrekt ist dann "else" verwenden.
                else
                {
                    //Doppelte eingabe Abfangen
                    foreach (int i in Tipps)
                    {
                        if (i == converted_input)
                        {
                            errorhandling2 = true;
                            break;
                        }
                    }
                    //Fehlerbehandlung
                    if (errorhandling2)
                    {
                        Console.WriteLine("Bitte geben Sie eine ZAHL ein die Sie noch nicht getippt haben!");
                        Console.WriteLine("Geben Sie nun Tipp " + (counter + 1).ToString() + " ein!");
                        counter--;
                    }
                        //Wenn kein Fehler, dann Zahl hinzufügen!
                    else
                    {
                        Tipps.Add(converted_input);
                    }
                }

                
            }

        }

@Edit: Sry!!! hab nicht gesehen das der Ursprungspost fast ein Jahr alt ist!

_________________
1:<<Life sucks!!>> 2:<< Well okay>> 1: <<Just Yours>> 2:<<Ohmph>>

dagestania · Hält's aus hier Beiträge: 1

Arriba!

Spielt einer von uns hier eventuell auch Euro-Jackpot und mag der Gemeinschaft mal Erfahrungswere mitteilen? Ich versuche, ein ähnliches Konzept zu kreieren, bräuchte aber verlässliche Quellen über diese Lotterie, also haut's mal raus! :-)

Kennt einer von euch diese Seite? lotto.zohosites.com/

	Mitgliederliste
	Gruppen
	Das Team
	Richtlinien
	Synonyme