Sudoku Logik

[hans ditter]

Hast du absolut Recht... das fehlte!
Aber leider behebt es immer noch nicht mein Problem. Ich glaube fast, dass es irgendwie einen falschen Zugriff auf eine falsche TStringList gibt.
Oh man, ich komm einfach nicht weiter...

[Notxor]

Da fehlt noch (mindestens) ein "-1" (glaub ich jedenfalls), und zwar in der DigitIsOk bei for j := 0 to Size -1 do

[Jumpy]

Wie lösche ich den Post wenn ich gerade Müll geschrieben habe????

Egal, versuch ich was evtl. sinnvolles:

Aus der Hilfe: Random gibt eine Zufallszahl im Bereich 0 <= X < Range zurück.

Also ist die -1 in

dig:=ValidDecision[random(ValidDecision.Count -1 )];
doch eher falsch, da random so Zahlen kleiner ValidDecision.Count-1 zurückliefert und nicht kleiner ValidDecision.Count, wie es eigentlich sein soll.
Somit eher wieder:

dig:=ValidDecision[random(ValidDecision.Count)];

[hans ditter]

Also, ich hab jetzt beides nochmal überprüft.
@Notxor
Ich hab's geändert. Hat auch schonmal was gebracht. Da hat's dann jedesmal funktioniert. Jedes andere 2te Mal kam aber die Fehlermeldung, dass der Litenindex überschritten wurde.

@Jumpy
Ich glaube löschen geht nicht!
Ich hab das auch bei dir geändert. Hat dann dazu geführt, dass ich ca. 10-15 Mal ein Sudoku erzeugen konnte. Aber auch dann kam die Fehlermeldung mit dem überschrittenem Listenindex.

EDIT!!!!

Hier die Fehlerstelle:

Delphi-Quellcode:

function SetCell(i: integer) : boolean;
var ValidDecision: TStringList;
  j,X,Y: Integer;
  dig: string;
begin
  if i > (Size * Size - 1) then
  begin
    Result:=true;
    Exit;
  end;
{.....................................................................}
  ValidDecision:=TStringList.Create;
  for j := 1 to Size do
    ValidDecision.Add(IntToStr(j));
{.....................................................................}
  while ValidDecision.Count > 0 do
  begin
    dig:=ValidDecision[random(ValidDecision.Count)];
    if DigitIsOk(i,StrToInt(dig)) then
    begin
      X:=i mod Size;
      Y:=i div Size;
      Form1.Map.Cells[X,Y]:=dig;
      if SetCell(i + 1) then //hier kommt der Fehler!!!
      begin
        Result:=True;
        Exit;
     (* end
      else
      begin
        ValidDecision.Delete(ValidDecision.IndexOf(dig));
        dig:=ValidDecision[random(ValidDecision.Count)]; *)
//hier ist der Fehler. Der else-Zweig ist total überflüssig!!
      end;
    end
    else
      ValidDecision.Delete(ValidDecision.IndexOf(dig));
  end;

  ValidDecision.Free;

  Result:=False;
end;

[Edit2]
Jetzt bräuchte ich nur nochmal Hilfe mit den Quadraten. Wie kann ich die möglichst dynamisch abfragen?
Hab grad schonmal ein bisschen mit Formeln rumjonliert.. ist aber nicht wirklich was bei rausgekommen.
Man müsste ja auf jeden Fall wissen, wie groß das Spielfeld ist. Das ist wohl auch nicht das Problem.
Vielmehr ist dann die Frage, wie man die einzelnen (von der Anzahl her ja auch noch variierenden) Quadrate überprüft.
Gibt es da irgendeinen mathematischen Weg oder muss man das mit lauter if-Schleifen abfragen? Wenn 2teres: Wie macht man das "dynamisch"?

[Jumpy]

Wenn man von rein Quadratischen Sudokus ausgeht, so ist Size bei dir ja die Größe des Hauptquarates. Die Wurzel aus Size gibt dir dann die größe der kleinen Quadrate und die Info wieviele davon in einer Reihe/Spalte stehen.

Deine X und Y Werte liefern dir wieder mit mod und div die Infos die du brauchst. Wenn Smallsize = Wurzel(Size) ist könnte es so gehen:

x div Smallsize = "X Nummer des kleinen Quadrats"
x mod Smallzise = "X Position deiner Zahl im kleinen Quadrat"

Beispiel oberste Reihe eines 9ers: 0,1,2 / 3,4,5 / 6,7,8. Nehmen wir Position 7:
7 div 3 = 2, d.h. Quadrat Nummer 2 (X richtung) (Zählung der Quadrate beginnt auch bei 0)
7 mod 3 = 1, d.h. Im kl. Quadrat steht die Zahl auf X-Position 1 (wieder beginnt Zählung bei null).

Y Funktioniert genauso. Im Beispiel, oberste Reihe, Y also 0:
0 div 3 = 0, d.h. Quadrat Nr. 0 (Y richtung)
0 mod 3 = 0, d.h. Steht im kl. Quadr. auf Y-Pos 0.

Die mit mod gewonnene Info ist aber unwichtig.

Somit muss jetzt ein Test das betroffene Quadrat durchlaufen:

Delphi-Quellcode:

for i = Smallsize*QuadratNummerX To Smallsize*QuadratNummerX+Smallzise
  for j = Smallsize*QuadratNummerY To Smallsize*QuadratNummerY+Smallzise
    if Grid(i,j)=digit and ((i<>X)and(j<>Y)) then
      return false,....

So könnte es in etwa anfangen

[hans ditter]

Okeeeee... werd's mal schauen, ob ich das umsetzten kann. Meld mich dann wieder.

Danke für deine Hilfe!

LG, hans ditter

[Jumpy]

Ein Gedanke, der mir dazu noch gekommen ist. Wenn man das so rekursiv ausbaut, hat man dann die Funktion nicht u.U. sehr oft aufgerufen und im Speicher? Z.B. bei einem 9er Soduko 81 mal?

Ist das nicht schlecht für die Performane? Bin ja selber noch neu beim Programmieren, kann also sein, dass ich das überschätze und sowas bei heutiger Rechenpower egal ist.

In die selbe Kerbe gehauen. Wäre es nicht besser die Zahlen nicht direkt in einem Gitter zu speichern, sondern in einem zweidimensionalen Array und dann nur zum Schluß das Gitter aus dem Array zu füllen? A) Kostet das zeichnen immer Zeit und B) ist man dann offen, wie man das Sudoku darstellt, muss ja nicht unbeding ein Gitter sein...

Letzter Vorschlag: Sollte man nicht statt von einem 4er Sudoku zu sprechen, von einem 2x2 Sudoku sprechen? Damit ist die Zahl der kleinen Quadrate in dem großen Quadrat gemeint. Dies hätte den Vorteil, das man mit der Funktion nicht nur Quadratische Sudokus bauen könnte, z.B.:
2x3 Sudoku: Ist ein 6er Sudoku, d.h. Size = 36. Hat 6 kleine Unter-Blöcke (rede nicht mehr von Quadraten), 2 solcher Blöcke nebeneinander und davon dann 3 untereinander.

Das macht die Sache viel flexibler.

[hans ditter]

Also ich denke, dass 81 Funktionsaufrufe nacheinander nicht so das Problem darstellen dürften... sollte heute schon funktionieren, zumindest wenn man mal den Preis betrachtet . . .

Ansonsten: Ja, wäre wohl besser, die Zahlen in einem Array zu speichern, aber soweit war ich einfach noch nicht. Ich wollte das Programm erstmal zum Laufen bringen und dann weitere Funktionen einbauen (z.B. Array).
Zum letzten, ja, wäre auch 'ne Möglickeit, muss aber ehrlich sagen, dass ich noch nie von einem 2 x 3 Sudoku gehört habe. Es muss ja jede Zahl in jedem Block, in jeder Reihe und in jeder Spalte einmal vorkommen. Und das geht bei einem 2x3 Sudoku imho nicht mehr.

LG, hans ditter

[hans ditter]

Also, ich hab deinen Rechenweg noch ein wenig verändert. So wie du ihn hier beschrieben hast, war der nicht ganz richtig...(warum, weiß ich auch nicht so genau, war einfach so... )
Hier der Code:

Delphi-Quellcode:

Smallsize:=Trunc(sqrt(Size));

    X:=i div SmallSize;
    Y:=i div SmallSize;

    for j := (SmallSize * X) to (SmallSize * X) do
    begin
      for k := (SmallSize * Y) to (SmallSize * Y) do
      begin
        if (Form1.Map.Cells[j,k] = IntToStr(digit)) AND ((j<>X) AND (k<>Y)) then
        begin
          Result:=false;
          Break;
        end;
      end;
    end;

Komischerweise hängt sich das Programm beim dritten erzeugten Sudoku auf. Weiß auch nicht warum, es scheint komplett fertig generiert zu sein und plötzlich hängt das Programm... Hast du 'ne Idee?

LG, hans ditter

[Jumpy]

Ich nehme an, du hast den Testcode für das Quadrat da eingebaut, wo du auch zuvor die Zeile und Spalte getestet hast? Zeig mal das Ganze, vllt. kommt es da zu Konflikten.

Deine Schleifen können aber nicht richtig sein:
for j := (SmallSize * X) to (SmallSize * X) do

Start und Endwert sind immer gleich. Da wird ja nur einmal was gemacht, das kann auch nicht richtig sein. Ich dachte meine Schleifen wären OK gewesen, da man damit durch das entsprechende Quadrat iteriert. Schau mir das aber nachher noch mal in Ruhe an.