Kontrolle

[Empire]

Ich möchte ein spiel programieren bei den man ein feld hatt z.B16*16 Groß. das ist mit z.B. 5 verschiedenen zeichen voll und man muss immer so 2 nebeneinanderliedenden zeichen tauschen das 3 oder mehr gleiche zeichen in einer reihe sind (horizontal, vertikal, diagonal,).
Aber wie soll ich die Konntrolle machen?
Klar ich könnte 5 millionen if kontrollen einsetzten, aber das soll ein "kleines" Programm werden und nicht mein restliches leben dauern.
Hatt einer eine Idee wie ich das machen könnte?

mfg
Empire

[Xin]

Was genau soll denn kontrolliert werden?
Der Spieler steuert oder ein Algorithmus, der das Problem auflöst?

Was die Kontrolle ansonsten angehst, so musst Du Deine Daten (Dein Spielfeld) so organisieren, dass Du freien Zugriff darauf hast. In Deinem Fall wäre das ein zweidimensionales Array von jeweils 16 Feld Breite.

[Dubbel]

Ich weiß nicht genau, wie weit du in C bist, aber ich an deiner Stelle würde mir die while/for-Schleifen ( http://tutorial.proggen.org/doku.php?id=c:loops:start ) nochmal genau angucken.
Denn wenn du geschickt programmierst musst du in den einzelnen if-Verzweigungen ja immer nur z.B. einen Index eines Arrays (z.B. das Array des Feldes (16x16)) um 1 erhöhen, und musst nicht alle if-Verzweigungen von Hand schreiben.

Viel Spass/Glück/Erfolg,
Dubbel...der bis jetzt an den Aufgaben zur Intel-Leibniz-Challenge saß und nix mehr von for-Schleifen etc. wissen will...

[Empire]

Nein das was du meinst ist nicht ganz richtig.
Ich will möchte ja das alle zeichenreihen mit 3 UND mehr "erkannt" werden.
und das mit der schleife:
ich weis nicht was die mir in dem fall bringen soll (´lese gerade das Buch "C Einführung und professionelle Anwendung" und hab gerade das kAPITTEL SCHLEIFEN GELESEN)

mfg
Empire

[Dirty Oerti]

Naja...

Code: Alles auswählen

unsigned char feld[16][16];
unsigned short max_y = 16;
unsigned short max_x = 16;
unsigned char last = 0;
unsigned short count = 0;
unsigned char gefunden = 0;

for (unsigned short start_y = 0; start < max_y; start_y++) {
	for (unsigned short start_x = 0; start_x < max_x; start_x++) {
		if (feld[start_y][start_x] == last) {
			count++;
			if (count >= 3) {
				gefunden = 1;
			}
		} else {
			count = 1;
			last = feld[start_y][start_x];
		}
	}
}

So (in der Art) müsstest du überprüfen können, ob in irgendeiner Zeile 3 gleiche Zeichen nebeneinander liegen.
Das kann man dann auch auf dein Problem etwas zuschneiden:

Code: Alles auswählen

unsigned char feld[16][16];
unsigned short max_y = 16;
unsigned short max_x = 16;
unsigned short zeichen1_count = 0;
unsigned short zeichen2_count = 0;
unsigned short zeichen3_count = 0;
unsigned short zeichen4_count = 0;
unsigned short zeichen5_count = 0;
unsigned char gefunden = 0;
for (unsigned short start_y = 0; start < max_y; start_y++) {
	for (unsigned short start_x = 0; start_x < max_x; start_x++) {
		switch (feld[start_y][start_x]) {
			case ZEICHEN1:
				zeichen1count++;
				break;
			case ZEICHEN2:
				zeichen2count++;
				break;
			case ZEICHEN3:
				zeichen3count++;
				break;
			case ZEICHEN4:
				zeichen4count++;
				break;
			case ZEICHEN5:
				zeichen5count++;
				break;
			default:
				break;
		}
	}
	if((zeichen1count>3)||(zeichen2count>3)||(zeichen3count>3)||(zeichen4count>3)||(zeichen5count>3)) {
		gefunden++;
	}
	zeichen1count = 0;
	zeichen2count = 0;
	zeichen3count = 0;
	zeichen4count = 0;
	zeichen5count = 0;
}

Ob das Ganze so funktioniert kann ich dir nicht garantieren, aber eine Hilfe für weitere Überlegungen sollte es dir geben können, hoffe ich

(Wer Fehler im Code findet darf sie behalten oder sie als Vereinfachungen zur besseren Lesbarkeit auffassen^^)

Achja, das (müsste) dir aber nur die Reihen durchsuchen, jetzt noch etwas für die Spalten zu schreiben dürfte jawohl kein Problem sein...
Und wegen diagonal: Theoretisch genauso, das kann man aber sicher noch stark vereinfachen, immerhin gibt es nur 2 Diagonalen (oder willst du es mit mehr machen?).

[Empire]

thx
ich schaus mir an

mfg
Empire

[Syntov]

Klar ich könnte 5 millionen if kontrollen einsetzten, aber das soll ein "kleines" Programm werden und nicht mein restliches leben dauern.
Hatt einer eine Idee wie ich das machen könnte?

Wie kommst du drauf das du Millionen von if's brauchst?


Noch 2 kleine Lösungsansätze
Verschwenderische Variante:
Du musst das Feld 4 mal überprüfen(Horizontal, Vertikal, 2xDiogonal)

Optimierte Variante:
Du überprüfst nur lokal ob sich da was ergibt(Dort wo du getauscht hast) da musst du Anfangs nur 8 Felder prüfen. Wenn dan in eine Richtung eine Übereinstimmung gibt musst du dort weiter prüfen.

[Dirty Oerti]

Optimierte Variante:
Du überprüfst nur lokal ob sich da was ergibt(Dort wo du getauscht hast) da musst du Anfangs nur 8 Felder prüfen. Wenn dan in eine Richtung eine Übereinstimmung gibt musst du dort weiter prüfen.

Das ist auch noch eine gute Idee. Anstatt das ganze Feld nur den veränderten Abschnitt prüfen.
Allerdings ist das schwerer zu implementieren und bringt (denke ich) bei einem Feld von 16 mal 16 nocht nicht wirklich eine Verbesserung.

Nur die Anzahl der Felder passen (denke ich) nicht:

Tauscht man 2 (z.B. ÜBEREINANDERLIEGENDE), so muss man die Spalte, in der getauscht wurde, nicht mehr überprüfen. (Keine Änderung, nur die Reihenfolge hat sich verändert).
Dann muss man aber die beiden Reihen neu überprüfen.
Und man muss sich noch überlegen, ob man die Diaogonalen neu prüfen muss.

Ergibt also 2x16 Felder plus evtl die der Diagonalen.
Außer man verwendet noch einen Speicher, damit man die Anzahl der gleichen Elemente in einer Spalte/Reihe/Diaogonale nicht jedesmal neu berechnen sondern immer nur "updaten" muss.
Das ergibt aber meiner Ansicht nach einen enormen Overhead....

Bei einem 16x16 Feld mit 2 Diagonalen und 5 versch. Zeichen wären das nämlich
(16+16)*5 + 2*5 Speichervariablen...

[Empire]

Man müsste die spalte trotzdem konntrolieren:
#
#
+
#

wenn man das + und das unterste # tauscht gibts auch eine 3er reihe

mfg
Empire

[Dirty Oerti]

Man müsste die spalte trotzdem konntrolieren:
#
#
+
#

wenn man das + und das unterste # tauscht gibts auch eine 3er reihe

mfg
Empire

Hängt davon ab, was du machen willst.
Willst du kontrollieren, ob 3 gleiche Zeichen nebeneinander liegen, dann ja.
Wenn es nur um die Anzahl der Zeichen pro Reihe geht, dann ist es egal.