Entwickler-Ecke

C# - Die Sprache - Nimm Spiel Strategie gesucht!


Kenan - Sa 21.03.09 16:11
Titel: Nimm Spiel Strategie gesucht!
Hallo, ich brauche eine Gute Strategie im Modus Spieler gegen Computer

Also das es der Spieler nicht so leicht hat zu gewinnen es aber möglich sein soll..

Beim Nimm Spiel geht es darum: Es gibt 10 Hölzer und es darf pro zug nur 1, 2 oder 3 Hölzer gezogen werden und wer das letzte Holz gezogen hat verliert.

Was ich bis jetz habe:


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:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
 
using System;

namespace NimmSpiel{
    class NimmSpiel{
        static void Main(string[] args){
            string[] Spieler = new string[3];
            int ein;
            int Hoelzer;
            string Gewinner;
            char again;
            int compein;
            char frag;
            int i;
            Spieler[2] = "Computer";
            Console.Write("Gegen Computer<C> oder gegen einen anderen Spieler<S>: ");
            frag = Convert.ToChar(Console.ReadLine());
            /*while (frag != 'C' || frag != 'c' || frag != 'S' || frag != 's')
            {
                Console.WriteLine();
                Console.WriteLine("Fehler, man kann nur 'C' oder 'S' eingeben!");
                Console.Write("Gegen Computer<C> oder gegen einen anderen Spieler<S>: ");
                frag = Convert.ToChar(Console.ReadLine());
                Console.WriteLine();
            }*/

            
            if (frag == 'C' || frag == 'c')
            {
                do
                {
                    for (i = 1; i < 2; i++)
                    {
                        Console.Write("Spieler: ");
                        Spieler[i] = Console.ReadLine();
                        Console.WriteLine();
                    }

                    i = 1;
                    Gewinner = "";
                    Hoelzer = 10;
                    ein = 0;
                    while (Hoelzer != 0)
                    {
                        i = 1;
                        while (i < 3 && Hoelzer != 0)
                        {

                            if (i == 1)
                            {
                                Console.WriteLine(Spieler[1] + ":");
                                Console.WriteLine();
                                Console.Write("Wie viele Stäbchen?<1,2,3>: ");
                                ein = Convert.ToInt32(Console.ReadLine());
                                while (ein <= 0 || ein > 3)
                                {
                                    Console.WriteLine();
                                    Console.WriteLine("Fehler, es könen nur 1, 2 oder 3 Stäbchen genommen werden!");
                                    Console.Write("Wie viele Stäbchen?<1,2,3>: ");
                                    ein = Convert.ToInt32(Console.ReadLine());
                                    Console.WriteLine();
                                }


                                while (Hoelzer == 2 && ein > 2)
                                {
                                    Console.WriteLine();
                                    Console.WriteLine("Fehler, es sind nur noch 2 Stäbe, also können max. 2 weggenommen werden!");
                                    Console.Write("Wie viele Stäbchen?<1,2,3>: ");
                                    ein = Convert.ToInt32(Console.ReadLine());
                                    Console.WriteLine();

                                    while (ein <= 0 || ein > 3)
                                    {
                                        Console.WriteLine();
                                        Console.WriteLine("Fehler, es könen nur 1, 2 oder 3 Stäbchen genommen werden!");
                                        Console.Write("Wie viele Stäbchen?<1,2,3>: ");
                                        ein = Convert.ToInt32(Console.ReadLine());
                                        Console.WriteLine();
                                    }//Fehler
                                }
                                if (Hoelzer == 1 && ein > 1)
                                {
                                    Console.WriteLine();
                                    Console.WriteLine("Fehler, es sind nur noch 1 Stab, also kann max. 1 weggenommen werden!");
                                    Console.Write("Wie viele Stäbchen?<1,2,3>: ");
                                    ein = Convert.ToInt32(Console.ReadLine());
                                    Console.WriteLine();
                                    while (ein <= 0 || ein > 3)
                                    {
                                        Console.WriteLine();
                                        Console.WriteLine("Fehler, es könen nur 1, 2 oder 3 Stäbchen genommen werden!");
                                        Console.Write("Wie viele Stäbchen?<1,2,3>: ");
                                        ein = Convert.ToInt32(Console.ReadLine());
                                        Console.WriteLine();
                                    }//Fehler
                                }

                                Hoelzer = Hoelzer - ein;
                                Console.WriteLine();
                                Console.WriteLine("Genommen: " + ein);
                                Console.WriteLine("Hölzer übrig: " + Hoelzer);
                                Console.WriteLine();
                                Console.WriteLine();
                            }
                            compein = 0;
                            if (i == 2)
                            {
                                Console.WriteLine(Spieler[2] + ":");
                                Console.WriteLine();
                                if (ein == 3)
                                {
                                    compein = 1;
                                }
                                if (ein == 2)
                                {
                                    compein = 2;
                                }
                                if (ein == 1)
                                {
                                    compein = 3;
                                }
                                if (Hoelzer == 2)
                                {
                                    compein = 1;
                                }
                                if (Hoelzer == 1)
                                {
                                    compein = 1;
                                }

                                Hoelzer = Hoelzer - compein;
                                Console.WriteLine();
                                Console.WriteLine("Genommen: " + compein);
                                Console.WriteLine("Hölzer übrig: " + Hoelzer);
                                Console.WriteLine();
                                Console.WriteLine();
                            }//Computer

                            if (Hoelzer == 0)
                            {


                                Gewinner = Spieler[i - 1];
                                if (Gewinner == null)
                                {
                                    i++;
                                    Gewinner = Spieler[i];
                                }
                            }
                            Console.WriteLine();

                            i++;
                        }
                    }

                    Console.WriteLine();

                    Console.WriteLine("Gewinner: " + Gewinner);
                    Console.WriteLine();
                    Console.Write("Nochmal?<J,N>: ");
                    again = Convert.ToChar(Console.ReadLine());
                    if (again == 'j' || again == 'J')
                    {
                        Console.Clear();
                    }
                    Console.WriteLine();

                } while (again == 'J' || again == 'j');
            }
            if (frag == 'S' || frag == 's')
            {
                do
                {
                    for (i = 1; i < 3; i++)
                    {
                        Console.Write("Spieler" + i + ": ");
                        Spieler[i] = Console.ReadLine();
                        Console.WriteLine();
                    }

                    i = 1;
                    Gewinner = "";
                    Hoelzer = 10;
                    while (Hoelzer != 0)
                    {
                        i = 1;
                        while (i < 3 && Hoelzer != 0)
                        {
                            Console.WriteLine(Spieler[i] + ":");
                            Console.WriteLine();
                            Console.Write("Wie viele Stäbchen?<1,2,3>: ");
                            ein = Convert.ToInt32(Console.ReadLine());
                            while (ein <= 0 || ein > 3)
                            {
                                Console.WriteLine();
                                Console.WriteLine("Fehler, es könen nur 1, 2 oder 3 Stäbchen genommen werden!");
                                Console.Write("Wie viele Stäbchen?<1,2,3>: ");
                                ein = Convert.ToInt32(Console.ReadLine());
                                Console.WriteLine();
                            }


                            while (Hoelzer == 2 && ein > 2)
                            {
                                Console.WriteLine();
                                Console.WriteLine("Fehler, es sind nur noch 2 Stäbe, also können max. 2 weggenommen werden!");
                                Console.Write("Wie viele Stäbchen?<1,2,3>: ");
                                ein = Convert.ToInt32(Console.ReadLine());
                                Console.WriteLine();

                                while (ein <= 0 || ein > 3)
                                {
                                    Console.WriteLine();
                                    Console.WriteLine("Fehler, es könen nur 1, 2 oder 3 Stäbchen genommen werden!");
                                    Console.Write("Wie viele Stäbchen?<1,2,3>: ");
                                    ein = Convert.ToInt32(Console.ReadLine());
                                    Console.WriteLine();
                                }//Fehler
                            }
                            if (Hoelzer == 1 && ein > 1)
                            {
                                Console.WriteLine();
                                Console.WriteLine("Fehler, es sind nur noch 1 Stab, also kann max. 1 weggenommen werden!");
                                Console.Write("Wie viele Stäbchen?<1,2,3>: ");
                                ein = Convert.ToInt32(Console.ReadLine());
                                Console.WriteLine();
                                while (ein <= 0 || ein > 3)
                                {
                                    Console.WriteLine();
                                    Console.WriteLine("Fehler, es könen nur 1, 2 oder 3 Stäbchen genommen werden!");
                                    Console.Write("Wie viele Stäbchen?<1,2,3>: ");
                                    ein = Convert.ToInt32(Console.ReadLine());
                                    Console.WriteLine();
                                }//Fehler
                            }

                            Hoelzer = Hoelzer - ein;

                            if (Hoelzer == 0)
                            {


                                Gewinner = Spieler[i - 1];
                                if (Gewinner == null)
                                {
                                    i++;
                                    Gewinner = Spieler[i];
                                }
                            }
                            Console.WriteLine();
                            Console.WriteLine("Genommen: " + ein);
                            Console.WriteLine("Hölzer übrig: " + Hoelzer);
                            Console.WriteLine();
                            Console.WriteLine();
                            i++;
                        }
                    }

                    Console.WriteLine();

                    Console.WriteLine("Gewinner: " + Gewinner);
                    Console.WriteLine();
                    Console.Write("Nochmal?<J,N>: ");
                    again = Convert.ToChar(Console.ReadLine());
                    if (again == 'j' || again == 'J')
                    {
                        Console.Clear();
                    }
                    Console.WriteLine();

                } while (again == 'J' || again == 'j');
            }

        }//Main
    }
}



Es fehlen noch ein paar überprüfungen aber sonst funktioniert es!

Hat vieleicht jemand eine Idee wie ich es:

1. Verkürzen kann?
2. Die Strategie vom Computer verbessern kann?
3. Was ich als funktion machen kann

Ich hoffe ihr könnt mir weiterhelfen!

mfg

Kenan


Kha - Sa 21.03.09 18:19
Uff, das ist wirklich eine Mammut-Funktion ;) . Einige Abschnitte hast du ja wahrscheinlich einfach per Copy&Paste dupliziert, die kann man schonmal auf jeden Fall in eigene Funktionen extrahieren.
So könnte ich mir den Aufbau vorstellen (nicht alle Methoden ausformuliert):

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:
 
void Main() 
{
  Console.Write("Gegen Computer<C> oder gegen einen anderen Spieler<S>: ");
  switch (Console.ReadLine().ToLower()) {
    case "c": Start(ReadPlayerName("Spieler:"), "Computer");
    case "s": Start(ReadPlayerName("Spieler 1:"), ReadPlayerName("Spieler 2:"));
  }
}

string ReadPlayerName(string caption) {...} // Bei Eingabe "Computer" am besten eine Fehlermeldung "So heißt doch niemand!" ;)

void Start(string p1, string p2)
{
  int num = 10;
  do {
    Console.WriteLine("Gewinner: " + Game(p1, p2));
  } while (WantsRestart());
}

bool WantsRestart() { ... }

void Game(string p1, string p2)
{
  string winner;
  while (true) {
    num -= Move(p1, num);
    if (num == 0)
      return p1;

    num -= Move(p2, num);
    if (num == 0)
      return p2;
  }
}

int Move(string player, int num)
{
  if (player == "Computer")
    ...
  else
    ...
}

int ReadNum() { ... }


Thorsten83 - So 22.03.09 23:47
Ich möchte mal behaupten dass es leichter ist, den Computer perfekt spielen zu lassen, als gut, aber schlagbar...


Kenan - Mo 23.03.09 09:12
Ja aber ich brauche dazu eine Taktik aber ich weiß nicht welche ich nehmen soll!


Th69 - Mo 23.03.09 13:22
Das Prinzip ist doch einfach, man muß nur schauen, daß man dem Gegner noch genau 5 Hölzer übrigläßt. Denn dann muß er ja 1 - 3 Hölzer wegnehmen und man selber kann dann auf genau 1 Holz reduzieren.

Und dann kann man ja eine gewisse Wahrscheinlichkeit einbauen, daß er eben nicht so perfekt spielt...


Kenan - Mo 23.03.09 16:52
Wie kann ich es machen das im Modus Computer gegen Spieler per zufall der Anfänger ausgewählt wird aber das dann immer abwechselnd gespielt wird?

Ich habs mit zufallszahlern probiert aber dann kommt es vor das der Computer oder der Spieler 2 mal hintereinander dran kommt!


Kenan - Mo 23.03.09 18:19
So ich habe jetzt ein paar Funktionen in mein Programm eingebaut!

Aber ich kapiere es irgendwie nicht wie ich auf diese Strategie komme das des Spieler immer auf 5 Hölzchen kommt!

Könnte mir vielleicht jemand dabei behilflich sein bin schon seit 3 tagen am programieren aber bekomme es nicht hin das es so leuft wie es soll!


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:
 
using System;

namespace NimmSpiel{
    class NimmSpiel{

            static int ein;
            static int Hoelzer;
            static int compein;

        static void Main(string[] args){
            
            string[] Spieler = new string[3];
            string Gewinner;
            char again;
            char frag;
            int i;
            int z;
            Spieler[2] = "Computer";

            Console.Write("Gegen Computer<C> oder gegen einen anderen Spieler<S>: ");
            frag = Convert.ToChar(Console.ReadLine());
            while (frag != 'C' && frag != 'c' && frag != 'S' && frag != 's')
            {
                Console.WriteLine();
                Console.WriteLine("Fehler, man kann nur 'C' oder 'S' eingeben!");
                Console.Write("Gegen Computer<C> oder gegen einen anderen Spieler<S>: ");
                frag = Convert.ToChar(Console.ReadLine());
                Console.WriteLine();
            }//überprüfen ob richtiger Buchstabe eingegeben!

            
            if (frag == 'C' || frag == 'c')
            {
                do
                {
                    i = 1;
                    while (i < 2)
                    {
                        Console.Write("Spieler: ");
                        Spieler[i] = Console.ReadLine();
                        while (Spieler[i] == "Computer" || Spieler[i] == "computer")
                        {
                            Console.WriteLine("Bitte einen anderen Namen wählen, Sie heißen bestimmt nicht 'Computer'!");
                            Console.Write("Spieler: ");
                            Spieler[i] = Console.ReadLine();
                        }
                        Console.WriteLine();
                        i++;
                    }//Spieler namen einlesen!
                    Gewinner = "";//Initialisieren
                    Hoelzer = 10;
                    ein = 0;
                    while (Hoelzer != 0)
                    {
                        i = 1;
                        while (i < 3 && Hoelzer != 0)
                        {

                            if (i == 1)
                            {
                                Console.WriteLine(Spieler[1] + ":");
                                Console.WriteLine();
                                Console.Write("Wie viele Stäbchen?<1,2,3>: ");
                                ein = Convert.ToInt32(Console.ReadLine());
                                BigSmall();
                                max2();
                                max1();
                                Hoelzer = Hoelzer - ein;
                                Console.WriteLine();
                                Console.WriteLine("Genommen: " + ein);
                                Console.WriteLine("Hölzer übrig: " + Hoelzer);
                                Console.WriteLine();
                                Console.WriteLine();
                            }//wenn spieler 1 an der reihe
                            compein = 0;
                            if (i == 2)
                            {
                                Console.WriteLine(Spieler[2] + ":");
                                Console.WriteLine();
                                if (ein == 3)
                                {
                                    compein = 1;
                                }
                                if (ein == 2)
                                {
                                    compein = 2;
                                }
                                if (ein == 1)
                                {
                                    compein = 3;
                                }
                                if (Hoelzer == 2)
                                {
                                    compein = 1;
                                }
                                if (Hoelzer == 1)
                                {
                                    compein = 1;
                                }

                                Hoelzer = Hoelzer - compein;//Die eingabe von den Hölzern abziehen
                                Console.WriteLine();
                                Console.WriteLine("Genommen: " + compein);//Wieviel genommen?
                                Console.WriteLine("Hölzer übrig: " + Hoelzer);//Wieviel Hözer übrig
                                Console.WriteLine();
                                Console.WriteLine();
                            }//wenn Computer an der Reihe

                            if (Hoelzer == 0)
                            {


                                Gewinner = Spieler[i - 1];
                                if (Gewinner == null)
                                {
                                    i++;
                                    Gewinner = Spieler[i];
                                }
                            }//Wenn letztes Holz gezogen Gewinner ausgeben!
                            Console.WriteLine();

                            i++;//Zähler erhöhen!
                        }//solange zähler kleiner 3 und Hölzer nicht gleih 0
                    }//solange Hölzer nicht gleich 0
                    Console.WriteLine();
                    Console.WriteLine("Gewinner: " + Gewinner);//Gewinner ausgeben!
                    Console.WriteLine();
                    Console.Write("Nochmal?<J,N>: ");//Fragen ob noch einmal
                    again = Convert.ToChar(Console.ReadLine());
                    if (again == 'j' || again == 'J')
                    {
                        Console.Clear();//Console löschen wenn neues spiel
                    }
                    Console.WriteLine();

                } while (again == 'J' || again == 'j');
            }//Wenn Modus Computer ausgewählt wird

            if (frag == 'S' || frag == 's')
            {
                do
                {
                    for (i = 1; i < 3; i++)
                    {
                        Console.Write("Spieler" + i + ": ");
                        Spieler[i] = Console.ReadLine();
                        Console.WriteLine();
                    }//Spieler 1 und 2 namen eingeben!

                    i = 1;
                    Gewinner = "";//Initialisieren
                    Hoelzer = 10;
                    while (Hoelzer != 0)
                    {
                        i = 1;
                        while (i < 3 && Hoelzer != 0)
                        {
                            Console.WriteLine(Spieler[i] + ":");
                            Console.WriteLine();
                            Console.Write("Wie viele Stäbchen?<1,2,3>: ");
                            ein = Convert.ToInt32(Console.ReadLine());
                            BigSmall();//Zahl gtößer oder kleiner
                            max2();//wenn nur 2 Hölzer da sind
                            max1();//wenn nur 1 Holz
                            Hoelzer = Hoelzer - ein;//Eingabe von Hölzern abziehen

                            if (Hoelzer == 0)
                            {
                                Gewinner = Spieler[i - 1];//Gewinner ist wer nicht das letzte zieht
                                if (Gewinner == null)
                                {
                                    i++;
                                    Gewinner = Spieler[i];
                                }//if Gewinner string leer Zähler wird erhöht
                            }//if Hölzer = 0
                            Console.WriteLine();
                            Console.WriteLine("Genommen: " + ein);
                            Console.WriteLine("Hölzer übrig: " + Hoelzer);
                            Console.WriteLine();
                            Console.WriteLine();
                            i++;
                        }//while Zähler kleiner 3 und Hölzer nicht gleich 0
                    }//while Hölzer != 0
                    Console.WriteLine();
                    Console.WriteLine("Gewinner: " + Gewinner);
                    Console.WriteLine();
                    Console.Write("Nochmal?<J,N>: ");
                    again = Convert.ToChar(Console.ReadLine());
                    if (again == 'j' || again == 'J')
                    {
                        Console.Clear();
                    }
                } while (again == 'J' || again == 'j');
            }//wenn Modus gegen einen anderen Spieler
        }//Main

        public static void BigSmall()
        {
            while (ein <= 0 || ein > 3)
            {
                Console.WriteLine();
                Console.WriteLine("Fehler, es könen nur 1, 2 oder 3 Stäbchen genommen werden!");
                Console.Write("Wie viele Stäbchen?<1,2,3>: ");
                ein = Convert.ToInt32(Console.ReadLine());
                Console.WriteLine();
            }
        }//BigSmall

        public static void max2()
        {
            while (Hoelzer == 2 && ein > 2)
            {
                Console.WriteLine();
                Console.WriteLine("Fehler, es sind nur noch 2 Stäbe, also können max. 2 weggenommen werden!");
                Console.Write("Wie viele Stäbchen?<1,2,3>: ");
                ein = Convert.ToInt32(Console.ReadLine());
                Console.WriteLine();
                BigSmall();
            }
        }//max2

        public static void max1()
        {
            if (Hoelzer == 1 && ein > 1)
            {
                Console.WriteLine();
                Console.WriteLine("Fehler, es sind nur noch 1 Stab, also kann max. 1 weggenommen werden!");
                Console.Write("Wie viele Stäbchen?<1,2,3>: ");
                ein = Convert.ToInt32(Console.ReadLine());
                Console.WriteLine();
                BigSmall();
            }
        }//max1


    }
}


Kenan - Mi 25.03.09 22:16
Bin schon fast am verzweifeln Morgen muss ich das Programm abgeben aber ich brauche die Taktik das der Computer immer gewinnt!

aber ich weiß nicht wie ich es Programieren soll kann mir vielleicht jemand behilflich sein?

mfg


Thorsten83 - Do 26.03.09 13:04
wiki:
Zitat:
Das Prinzip lässt sich auf modifizierte Regeln anwenden. Bei einem Ziel z und einer Zugbreite von 1 bis n sind die Schlüsselzahlen z-(n+1), z-2(n+1), z-3(n+1), ...


Entwickler-Ecke.de based on phpBB
Copyright 2002 - 2011 by Tino Teuber, Copyright 2011 - 2025 by Christian Stelzmann Alle Rechte vorbehalten.
Alle Beiträge stammen von dritten Personen und dürfen geltendes Recht nicht verletzen.
Entwickler-Ecke und die zugehörigen Webseiten distanzieren sich ausdrücklich von Fremdinhalten jeglicher Art!