WebWork Magazin - Webseiten erstellen lassen, Online Medien, html

Webhoster, Webhosting Provider und Domain registrieren

Home | Registrieren | Einloggen | Suchen | Aktuelles | GSL-Webservice | Suleitec Webhosting
Reparatur-Forum | Elektro forum | Ersatzteilshop Haushalt und Elektronik


Homepage und Webhosting-Forum

ASP, Python, Perl, CGI, Ruby, Ajax, GO, ... Vom Syntax Error bis zum Release, hier ist Platz für Diskussionen !


Forum » Sonstige Web-Programmiersprachen » Gedankenspiel: 4-Gewinnt » Antworten
Benutzername:
Passwort: Passwort vergessen?
Inhalt der Nachricht: Fett | Kursiv | Unterstrichen | Link | Bild | Smiley | Zitat | Zentriert | Quellcode| Kleiner Text
Optionen: Emailbenachrichtigung bei Antworten
 

Die letzten 5 Postings in diesem Thema » Alle anzeigen
von nisita
ok, weiß endlich, was du meinst.. allerdings glaube ich immer noch, dass die 2^42 falsch sind.. denn das würde auch unterscheiden, was für ein gelber stein auf dem feld x-y liegt.. und die reihenfolge, die bei dir berücksichtigt wird, spielt nunmal keine rolle..

st
von Ori
Es geht doch darum, herauszufinden, wie viele Anordnungsmöglichkeiten es für ein Unentschieden gibt. Die Anzahl läst sich bestimmen, indem man alle Spiele spielt und zählt, wie viele unterschiedliche Anordnungen es bei einem Unentschieden gibt.

Das ist aber sehr zeitaufwändig. Daher wird nach einer besseren Möglichkeit gesucht, diese Anzahl zu ermitteln. Ich bin mittlerweile zu der Überzeugung gelangt, dass dies nicht anders geht. Zu prüfen, ob eine Anordnung von Spielsteinen ein entschiedenes Spiel ist oder nicht, schafft mein Code innerhalb von Millisekundenbruchteilen.

Es werden pro Sekunde etliche tausend Spiele geprüft. Aber da es insgesamt 2^42 mögliche Spielsteinanordnungen gibt (ohne Berücksichtigung, dass man abwechselnd zieht, also je gleich viele rote wie gelbe Steine im Feld sind), dauert diese Methode sehr lange und führt, wie ich bereits erwähnte, zu einem falschen Ergebnis.

Die echte Methode dauert allerdings noch länger.
von nisita
hm.. irgendwie versteh ich nicht, was du meinst.. nach welchen lösungen suchst du denn??? ich dachte, du würdest nur danach suchen, ob untenschieden oder gewonnen.. und das macht mein code ja auch..

was meinst du mit alle lösungen zu erwischen??? wenn du so ein spiel stein für stein durchspielst, was bringt dir das? denn auf ein unentschieden wirst du wohl nur selten stoßen..

aber so ein spiel durch zu spielen, ist ja auch nicht soo das ding.. brauchst halt random(6)+1, für jeden wurf, und dann muss überprüft werden, welcher der höchste stein ist, und dort dann drüber fliegt er rein..

sorry, aber bin irgendwie gerade durcheinander..

mfg
st
von Ori
Dass ich zweimal den gleichen Code für die Diagonalen benutzt habe, war ein Fehler (copy, paste and forget), den ich inzwischen korrigiert habe. Da ich den Fehler aber beim Durchlaufen bemerkt habe, als noch keine Lösungen gefunden wurden (es gab noch genug waagerechte und senkrechte Vierer, die es nicht zur Diagonalen-Prüfung kommen ließen)

Es geht nicht um die Überprüfung einer Lösung, sondern um die Überprüfung aller Lösungen, die drei Tage in Anspruch nimmt.

Die einzige Möglichkeit, alle Lösungen zu erwischen besteht in der Durchrechnung ebendieser.
Ergo: Wir werfen rekursiv Stein für Stein für Stein. Immer abwechselnd (Code folgt irgendwann).
von nisita
hallo..

habe mir nochmal gedanken gemacht.. wegen der erdanziehungskraft.. das stimmt schon, hatte da wohl doch einen denkfehler.. allerdings macht das es ja eigentlich unmöglich, die möglichkeiten zu bestimmen..

die 69 sind wohl ebenfalls falsch.. es gibt zwar 69 möglichkeiten, einen "4-er" auf das feld zu legen, alldernings, gibt es ja für eine variante 68 ander, dafür wiederum 67 andere etc.. was ja bedeuten würde, dass es 69! möglichkeiten geben würde, irgendwie zu gewinnen.. das wiederum ist auch blödsinn, denn man gewinnt ja schon mit dem ersten vierer..


um das zu überprüfen, ob es nun ein unentschieden gibt, ja oder nein hier mal ein bisschen code.. ist jedoch flash, aber dürfte eigentlich alles klar sein.. die setzung hab ich erstmal erstmal nicht beigefügt, da das ja zum überprüfen nicht interesant ist.. bei mir dauert eine überprüfung nichtmal eine sekunde..


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:
//es gibt ein feld.. 2 dimensionaler array..


show = function(){
	zw = "";
	for(k=0; k < feld.length; k++) {
		for(i=0; i < feld[0].length; i++) {
			zw = zw add feld[k][i];
		}
		trace(zw);
		zw = "";
	}
}

//ist eigentlich nur dazu da, um das feld anzuzeigen..
show();

//////////////
//überprüfung:
//////////////

//durchsucht den string "zw" nach "xxxx" oder "oooo" (x = spieler 1, o = spieler 2)..
//wenn dieser string gefunden wird (!=-1), dann gibt es also einen 4er.. -eigentlich
//könnte hier jetzt alles abgebrochen werden..

durchsuchen = function(){
	if(zw.indexOf("xxxx") != -1 || zw.indexOf("oooo") != -1){
		trace("Es hat jmd. eine 4er Reihe!");
	}
}

////////////
//waagerecht
////////////


//trace ist in flash sowas wie "ausgabe".. zum überprüfen von variablen oder ähnlichem..
trace("waagerecht");


//feld wird durchsucht, eine zeile bildet einen string, der mit "durchsuchen" überprüft wird
zw = "";
for(k=0; k < feld.length; k++) {
	for(i=0; i < feld[0].length; i++) {
		zw = zw add feld[k][i];
	}
	trace(zw)
	durchsuchen();
	zw = "";
}

///////////
//senkrecht
///////////


//eigentl. dasselbe wie bei waagerecht.. nur ist jetzt ein string eine spalte, und nicht eine reihe..

trace("senkrecht");
zw = "";
for(k=0; k < feld[0].length; k++) {
	for(i=0; i < feld.length; i++) {
		zw = zw add feld[i][k];
	}
	trace(zw)
	durchsuchen();
	zw = "";
}

/////////////////
//Diagonal nw->so
/////////////////

trace("Diagonal nw->so");


//beide diagonalen durchsuchungen, kann man bestimmt noch optimieren..
//x und y, stellen die start variablen dar.. es fängt somit links unten
//in der ecke mit dem ersten string an.. natürlich brauch man die ersten 3
//und die letzten 3 strings nicht beachten, da sie ja nichtmal 4 "einheiten"
//langs sind..
//der startwert, wandert sozusagen am anfang nach unten (k--), und wenn
//ka dann 0 ist, wandert der startwert nach rechts (x=math.abs(k))
//in der while schleife, kommt es zu der eigentlichen scrägen durchlaufung
//des feldes (x++; y++;)

zw = "";
for(k=feld.length-1; math.abs(k) <= feld.length; k--) {
		if(k==0){
			x = math.abs(k)
			y = 0;
		}else{
			x = 0;
			y = k;
		}
		while(y < feld.length && x < feld[0].length) {
			zw = zw add feld[y][x];
			x++;
			y++;
		}
		trace(+zw);
		durchsuchen();
		zw = "";
}

/////////////////
//Diagonal sw->no
/////////////////

trace("Diagonal sw->no");

//wie vorher, nur das nun der startwert unten rechts ist, er "wandert"
//dann nach oben, und dann nach links..

zw = "";
for(k=feld.length-1; math.abs(k) <= feld.length; k--) {
	if(k<0){
		//trace("123")
		x = feld.length-math.abs(k);
		y = 0;
	}else{
		x = feld.length;
		y = math.abs(k);
	}
	//trace(x+","+y);
	while(y < feld.length && x >= 0) {
		zw = zw add feld[y][x];
		x--;
		y++;
	}
	trace(zw);
	durchsuchen();
	zw = "";
}

Nach oben