4 Gewinnt | Gewinner herausfinden

SeppJ

Gleànn schrieb:

Die 2 Antwort wird denke ich schwerer sein, da sich das Spielbrett nicht mit einem [X][Y]-Array aufbaut, sondern nur einen 1-Dimensionalen beinhaltet welcher nach 7 Werten auf die nächste Zeile versetzt wird.

Ich weiß. Aber dir ist schon klar, dass da ein einfacher mathematischer Zusammenhang besteht?

In 2D ist es viel einfacher, eine Bedingung wie "in einer Reihe", "in einer Spalte" oder "diagonal" zu formulieren. Und damit auch die Umsetzung im Computer. Und da du ganz einfach von 2D auf 1D umrechnen kannst, ist das auch kein Hindernis.

Gleànn

Ist mir soeben beim überlegen der Umsetzung von 1 aufgefallen.

Ich bin zwar noch unschlüssig wie ich genau Nr. 2 umsetzten kann, doch anstatt weiter fragen zu stellen welche ich mit etwas Brainstorming vlt. auch selber beantworten kann begebe ich mich besser zurück in den Code und bastle mal ein wenig.

http://www.sps-forum.de/simatic/67356-4-gewinnt-auswertung.html

ganz unten ist ein wenig C-Code der das macht - es werden einfach die möglichen Strecken vom Spielstein aus bewertet, geht bestimmt aber noch kleiner

Gleànn

@Gast3
Danke für die Antwort, doch da ich atm einen Lösungsweg habe welchen ich zuerst ausprobieren will, schaue ich mir den Code nicht an.

immer erst mal selber und dann schauen - viel Erfolg

Übersichtlich und visuell ansprechend sind Tabellen mit den Offsets im Array, z.B. horizontal nach rechts und diagonal nach links unten:

typedef int off[2];

off hor[] =
  {
    {0,0},{1,0},{2,0},{3,0},
  };

off diag_l[] =
 {
          {0,0},
        {-1,1},
      {-2,2},
    {-3,3},
  };

Das dann zum prüfen mit den aktuellen Koordinaten verwurschteln.

Übersichtlich und visuell ansprechend sind Tabellen mit den Offsets im Array

Wofür soll das sinnvoll sein? kann man doch alles komplett aus dem Wissen Höhe/Breite, aktuelle Position berechnen - wofür vorhalten?

Gast3 schrieb:

Übersichtlich und visuell ansprechend sind Tabellen mit den Offsets im Array

Wofür soll das sinnvoll sein? kann man doch alles komplett aus dem Wissen Höhe/Breite, aktuelle Position berechnen - wofür vorhalten?

Die Tabellen mit den Offsets sind schnell geschrieben und einfach zu handhaben.
Den Code zum prüfen brauche ich nur einmal zu schreiben und je nachdem welche Tabelle ich reinstecke prüft der mir verschiedene Konstellationen.

Das gefällt mir.

Ich verstehe echt nicht was du damit machen willst

fuer die Bewegung durch die Tabelle brauche ich doch nur
einen Richtungs-"Vektor" mit z.B. (X=-1, Y=+1) der Rest ergibt
sich doch automatisch durchs addieren?

Ich würde es echt gerne verstehen - kannst du ein Beispiel zeigen wie du deine Offset-Tabelle nutzt?

Gleànn

Kurzes Feedback:

Ich kann in der zwischenzeit die Horizontalen Linien prüfen und bin jetzt bei den Vertikalen dran.
Leider hab ich die nächsten Tage keine Zeit, doch werde ich mich melden sobald alles entweder funktioniert oder eben nicht.

Danke nochmals für die Hilfe!

@FurbleWruble
Würde mich auch interessieren was du genau damit meinst!

du machst meine Rechnung mit der Richtung einfach als Tabelle - ist ja echt nicht so schön da reicht doch eine einfache Funktion

void laufe_durch(int start_x, int start_y, int richtung_x, int richtung_y, int distanz)
{
for(int i = 0; i < distanz; i++)
{
int aktuell_x = start_x + i * richtung_x;
int aktuell_y = start_y + i * richtung_y;

printf("%d/%d\n", aktuell_x, aktuell_y);
}
}

//horizontal von 0/0 nach 5/0
laufe_durch(0,0, 1,0, 5);
//vertikal von 5/5 nach 5/0
laufe_durch(5,5, 0,-1, 5);
//diagonal von 0/0 nach 5/5
laufe_durch(0,0, 1,1, 5);

der Gewonnen-Test bleibt bei allen gleich

Gleànn schrieb:

@FurbleWruble
Würde mich auch interessieren was du genau damit meinst!

Beispiel:

#include <stdio.h>

typedef struct {
  int v0, v1;
} pos, off;

void pos_print(const pos *p) {
  printf("(%d,%d)\n", p->v0, p->v1);
}

void print(const pos *p, const off *o) {
  pos_print(p);
  for(int i=0; i<3; ++i) {
    pos cur = {p->v0+o[i].v0, p->v1+o[i].v1};
    pos_print(&cur);
  }
}

void s(const pos *p) {
  print(p, (off[]){
    {0,1},
    {0,2},
    {0,3},    
  });
}

void sw(const pos *p) {
  print(p, (off[]){
          {-1,1},
        {-2,2},
      {-3,3},
  });
}

int main(void) {
  s(&(pos){0,0});
  sw(&(pos){42, 31415});
}

Bei so einfach zu beschreibenden Mustern wie Strecken ist das tatsächlich nicht sooo sexy.
Evtl. geht die von mir gepriesene "ansprechende Form" auch flöten, weil ich Zeilen einsparen musste, damit es im Vergleich zu Gast3s Lösung nicht wie Codebloat wirkt... (Der Compound Literals wegen wirst Du auch einen C99 Compiler brauchen.)
Jetzt weißt Du aber, wie ich das meinte.

SeppJ

Das kommt mir vor, wie die ultimative Lösung, wenn wir mal R-gewinnt programmieren wollen; ein Spiel bei dem die Spielsteine die Form des Buchstabens 'R' bilden müssen, um zu gewinnen.

SeppJ schrieb:

Das kommt mir vor, wie die ultimative Lösung, wenn wir mal R-gewinnt programmieren wollen; ein Spiel bei dem die Spielsteine die Form des Buchstabens 'R' bilden müssen, um zu gewinnen.

Hahaha...! Kasper gefrühstückt, was?