Hallo zusammen, sind hier fitte Programmierer am Start? Ich könnte Hilfe benötigen um einen Algorithmus zu kreieren der überprüft ob 4 Steine in einer Reihe liegen. Klar ist mir das ich mit 4 verschiedenen Vektoren arbeiten muss (0,1), (1,0), (1,-1) und (1,1). Ich hab mein Programm mittlerweile schon soweit, dass ich die Koordinaten des letzten Steines in die Prüfmethode übergeben kann. Jetzt muss ich nur noch von diesem Stein aus mit den Vektoren weiterzählen und eben sehen ob dann nochmal 3 gleiche kommen. 4 oder 8 for-Schleifen finde ich schlechte Programmierung ;-).

He, he, he! Selbst ist der Mann! Und der Programmierer erst recht!

Du solltest dazu vielleicht schon mal ein paar mehr details rausgeben
Wie sieht die Datenstruktur aus, wie sieht die Methode aus usw. Worum gehts überhaupt? 4 gewinnt?

Hab mal 4-Gewinnt mit PHP programmiert. Leg einfach alle Steine in ein Array, wobei ein Array die x-Achse darstellt [0,1,2,3,4,5,7,8,9] und deren Unterarrays die y-Achse [0 [0,1,2,3,4,5,6,7,8,9], 1 [0,1,2,3,4,5,6,7,8,9], ...]. In den Unterarrays legst du dann die Farbe ab, zum Beispiel xachse[2]yachse[3] = "rot" (Koordinate 3:4 hat einen roten Stein). Jetzt kannst du ganz einfach in alle Richtungen prüfen, ob die anderen Vektoren auch rote Steine enthalten.

Viele for-Schleifen sind übrigens NICHT unprofessionel. Solange es funktioniert, ist es gut. Warum eine "unprofessionelle", aber funktionierende Variante ausschließen, um eine "professionell wirkende", dafür aber speicherverbrauchende entwickeln? Schwachsinn! Wenn du zB eine Datei erstellen willst, die ALLE IP-Adressen zwischen 1.0.0.0 und 255.255.255.255 ohne 128.399.287.955 (wäre keine IP-Adresse) musst du sogar 4 for-Schleifen ineinander schachteln! (Übrigens: die Datei wäre 60 GB groß, habs nämlich mal getestet^^)

Ach 4 gewinnt stand ja sogar im topic...
Da muss ich Dunkellord aber auf jeden fall recht geben. Das hat nichts mit schlechter Programmierung zu tun... Klar kann man sich für das 4 gewinnt ding sicher auch irgendwas krankes ausdenken, aber DAS wäre dann eventuell schlechter programmierstil, denn wer soll das ding nach ein paar Jahren noch verstehen? Wichtig ist vor allem Laufzeit, Speicherverbrauch und Code-Qualität (die wiederrum auf lesbarkeit usw. zurückzuführen ist)

Ne nette und hübsche Objektorientierte Idee ist natürlich noch das ganze in einer art verketteten Matrix zu speichern. Quasi ein Objekt Feld das 9 Referenzen auf andere Feld-Objekte hat (Nachbarn) und dann kann man nen hübschen rekursiven Ansatz wählen um herauszufinden ob an dem gegebenem Feld vier in einer Reihe sind. Falls du immer noch hilfe brauchst rück einach mal deine Datenstruktur und den Methoden Kopf rüber

Gruß
exo

Zitat von exo

Ach 4 gewinnt stand ja sogar im topic...
Da muss ich Dunkellord aber auf jeden fall recht geben. Das hat nichts mit schlechter Programmierung zu tun... Klar kann man sich für das 4 gewinnt ding sicher auch irgendwas krankes ausdenken, aber DAS wäre dann eventuell schlechter programmierstil, denn wer soll das ding nach ein paar Jahren noch verstehen? Wichtig ist vor allem Laufzeit, Speicherverbrauch und Code-Qualität (die wiederrum auf lesbarkeit usw. zurückzuführen ist)

Ne nette und hübsche Objektorientierte Idee ist natürlich noch das ganze in einer art verketteten Matrix zu speichern. Quasi ein Objekt Feld das 9 Referenzen auf andere Feld-Objekte hat (Nachbarn) und dann kann man nen hübschen rekursiven Ansatz wählen um herauszufinden ob an dem gegebenem Feld vier in einer Reihe sind. Falls du immer noch hilfe brauchst rück einach mal deine Datenstruktur und den Methoden Kopf rüber

Gruß
exo

Mit den Referenzen programmier ich dann das Scrabble, da lass ich dann einen Iterator laufen :-). Ich werd euch demnächst mal den Code hier posten. Momentan prüf ich jetzt die Gewinnabfrage mit einer for-schleife und einer zusätzlich darin verschachteltent. ... 4 oder 8 for-schleifen fallen eindeutig weg, da sich für diese Problemstellung wie ich rausgefunden habe sich auch was kleines schönes programmieren lässt, das dabei auch noch effizient arbeitet. Naja bei 4 oder 8 for-schleifen läufts einfach auf Code-Duplikation raus und dadurch fast toter Code entsteht. Naja. Bis demnächst ich poste dann meins mal hier rein.

-- 01.10.2009, 02:27 --

Hallo zusammen, für alle die es evtl. doch noch interessiert wie ich den Algorithmus realisiert hab.

	public boolean countEqualPiecesInOneDirection(Piece piece, int row, int column)
	{
		int v_row = 0;
		int v_col = 0;
		
		boolean win = false;
		
		for ( int i = 0; i < 4; i++ )
		{
			int temp_row = row;
			int temp_col = column;
			
			switch (i)
			{
			/* right, left */  
			case 0:
				v_row = 0;
				v_col = 1;
				break;
			/* up, down */	
			case 1:
				v_row = 1;
				v_col = 0;
				break;
			case 2:
			/* left down, right up */ 
				v_row = 1;
				v_col = -1;
				break;
			case 3:
			/* right down, left up */ 
				v_row = 1;
				v_col = 1;
				break;
			}
			
			int count = 0;
			int dir_mpc = 1;
			
			for ( int j = 0; j <= 1; j++)
			{
				if ( j == 1 )
				{
					// reset to start-piece
					temp_row = row;
					temp_col = column;
					dir_mpc = -1;
				}
				
				while ( temp_row >= 0 && temp_col >= 0 && temp_row < connect4Board.getHeight() && temp_col < connect4Board.getWidth())
				{
					temp_row += (v_row * dir_mpc);
					temp_col += (v_col * dir_mpc);
					
					if (temp_row < 0 || temp_col < 0 || temp_row >= connect4Board.getHeight() || temp_col >= connect4Board.getWidth() || connect4Board.isEmpty(temp_row, temp_col) || !connect4Board.isOnTheBoard(temp_row, temp_col))
					{
						break;
					}
					else
					{
						if ( connect4Board.getPiece(temp_row, temp_col).equals(piece))
						{
							count++;
						
							if (count == 3)
							{
								win = true;
							}
						}
						else
						{
							break;
						}
					}
				}
			}
		}
		if ( win == true )
		{
			return true;
		}
		else
		{
			return false;
		}
	}