Ich versuch jetzt schon seit 3 stunden meine Fehler zu finden, doch leider ohne erfolg.
Ausgangsposition ist ein Array 0..8 von Array 0..8 (ein Sudoku Feld).

Nun bin ich dabei die Methode des unsichtbaren Einers zu programmieren. Sprich, wenn ein Kandidat (Möglichkeit) nur einmal in einer Reihe, Spalte oder Feld vorkommt, kann dieser fest Eingtragen werden.

Die Prüfung für die Reihe:

zusammenfalten · markieren

Delphi-Quellcode:

   //Reihen nach unsichtbaren Einern durchsuchen
   For x := 0 To 8 Do Begin
      For y := 0 To 8 Do
         If aSudoku[x, y] > 9 Then Begin
            j := 0;
            i := 1;
            a := x;
            b := 0;
            z := IntToStr(aSudoku[x, y]);
            Repeat
               If (pos(z[i], IntToStr(aSudoku[a, b + j])) > 0) Then Begin
                  If (a <> x) Or (b + j <> y) Then Begin
                     i := i + 1;
                     j := 0
                  End Else Begin
                     j := j + 1;
                     If j > 8 Then
                        aSudoku[x, y] := StrToInt(z[i]);
                  End;
               End Else Begin
                  j := j + 1;
                  If j > 8 Then
                     aSudoku[x, y] := StrToInt(z[i]);
               End;
            Until (i > length(z)) Or (j > 8);
         End;
   End;

und für die Spalte:

zusammenfalten · markieren

Delphi-Quellcode:

   //Spalten nach unsichtbaren Einern durchsuchen
   For x := 0 To 8 Do Begin
      For y := 0 To 8 Do

         If aSudoku[x, y] > 9 Then Begin
            j := 0;
            i := 1;
            a := 0;
            b := y;
            z := IntToStr(aSudoku[x, y]);
            Repeat
               If (pos(z[i], IntToStr(aSudoku[a + j, b])) > 0) Then Begin
                  If (a + j <> x) Or (b <> y) Then Begin
                     i := i + 1;
                     j := 0
                  End Else Begin
                     j := j + 1;
                     If j > 8 Then
                        aSudoku[x, y] := StrToInt(z[i]);
                  End;
               End Else Begin
                  j := j + 1;
                  If j > 8 Then
                     aSudoku[x, y] := StrToInt(z[i]);
               End;
            Until (i > length(z)) Or (j > 8);
         End;
   End;

funktionieren Einwandfrei. Doch für das Feld komme ich einfach nicht weiter.
Dazu ein Beispiel (soll ein Sudoku Feld sein):

? 3 0 | 0 0 0 |0 0 0|
0 0 0 | 2 0 0 |0 0 0|
4 5 0 | 0 0 0 |0 0 0|
_____________________
0 0 2 | 0 0 0 |0 0 0|
0 0 0 | 0 0 0 |0 0 0|
0 0 0 | 0 0 0 |0 0 0|
_____________________
0 0 0 | 0 0 0 |0 0 0|
0 0 0 | 0 0 0 |0 0 0|
0 0 0 | 0 0 0 |0 0 0|

Oben links muss ja die 2 rein, da alle anderen Felder gesperrt sind durch die 2 Außen.
Mein Programm schreibt in allen leeren Felder alle Möglichkeiten rein, sprich für das Fragezeichenfeld: 126789 und in den anderen Felder des ersten 3x3 Feldes 16789.
also kommt die 2 nur noch einmal in dem ersten 3x3 feld vor und kann somit eingtragen werden.

Mein Programm sollte dementsprechen soetwas machen:


- Gehe alle Felder 3x3 ab und suche nach Wert größer 9.
- Wenn ein Feld gefunden, dann speichere Wert als string in variable z.
- Dann gehe alle Felder 3x3 ab und prüfe ob eine Position von z in den Werten der Felder enthalten ist
- Wenn ein Wert von z nicht in den anderen Felder vorhanden ist, den Wert in das Feld eintragen.

Mein letzter Ansatz der leider überhaupt nicht macht was es soll:

zusammenfalten · markieren

Delphi-Quellcode:

  For x := 0 To 2 Do Begin
      For y := 0 To 2 Do
         If aSudoku[x, y] > 9 Then Begin
            z := IntToStr(aSudoku[x, y]);
            i := 1;
            For a := 0 To 2 Do Begin
               For b := 0 To 2 Do
                  j := 0;
               Repeat
                  If ((pos(z[i], IntToStr(aSudoku[a, b])) > 0)) And ((a <> x) Or (b <> y)) Then Begin
                     i := i + 1;
                     j := 0;
                  End Else Begin
                     j := j + 1;
                     If j > 8 Then
                        aSudoku[x, y] := StrToInt(z[i]);
                  End;
               Until (i > length(z)) Or (j > 8);
            End;
         End;
   End;

Ich hoffe einer hat Lust und kriegt nicht sofort Angst bei dem langen Text

Dein Konzept ist da etwas schwerfällig

Beim SuDoKu hat man ja 9x9 Felder.
Diese Felder bilden wiederum logische Einheiten über die Spalten, die Reihen und jeweils 3x3 Blöcke.
- Jede Spalte hat 9 Felder
- Jede Reihe hat 9 Felder
- Jeder Block hat 9 Felder

markieren

Code:

B | 0 1 2 3 4 5 6 7 8 | S | 0 1 2 3 4 5 6 7 8 | R | 0 1 2 3 4 5 6 7 8
--+------------------ | --+------------------ | --+------------------
0 | 0 0 0 1 1 1 2 2 2 | 0 | 0 1 2 3 4 5 6 7 8 | 0 | 0 0 0 0 0 0 0 0 0
1 | 0 0 0 1 1 1 2 2 2 | 1 | 0 1 2 3 4 5 6 7 8 | 1 | 1 1 1 1 1 1 1 1 1
2 | 0 0 0 1 1 1 2 2 2 | 2 | 0 1 2 3 4 5 6 7 8 | 2 | 2 2 2 2 2 2 2 2 2
3 | 3 3 3 4 4 4 5 5 5 | 3 | 0 1 2 3 4 5 6 7 8 | 3 | 3 3 3 3 3 3 3 3 3
4 | 3 3 3 4 4 4 5 5 5 | 4 | 0 1 2 3 4 5 6 7 8 | 4 | 4 4 4 4 4 4 4 4 4
5 | 3 3 3 4 4 4 5 5 5 | 5 | 0 1 2 3 4 5 6 7 8 | 5 | 5 5 5 5 5 5 5 5 5
6 | 6 6 6 7 7 7 8 8 8 | 6 | 0 1 2 3 4 5 6 7 8 | 6 | 6 6 6 6 6 6 6 6 6
7 | 6 6 6 7 7 7 8 8 8 | 7 | 0 1 2 3 4 5 6 7 8 | 7 | 7 7 7 7 7 7 7 7 7
8 | 6 6 6 7 7 7 8 8 8 | 8 | 0 1 2 3 4 5 6 7 8 | 8 | 8 8 8 8 8 8 8 8 8

Erstelle dir eine Klasse (z.B. TSuDoKuBlock), die 9 Spielfelder aufnehmen kann und auch eine Methode (CanHaveNumber( x : integer ) : Boolean), die in diesen 9 Spielfeldern prüft, ob eine Zahl x dort gesetzt werden darf.

markieren

Delphi-Quellcode:

function TSuDoKuBlock.CanHaveNumber( x : integer ) : Boolean;
begin
  Result := True;
  // Alle Felder im Block prüfen, ob diese Zahl schon vorkommt
  for FeldIndex := 0 to 8 do
    Result := Result and ( fFields[ FeldIndex ].Number <> x );
end;

Ein Spielfeld kann in max. 3 Blöcken gleichzeitig sein.
Erstelle dir eine Klasse (z.B. TSuDoKuFeld), das 3 Blöcke aufnehmen kann.
Diese Klasse bekommt jetzt auch eine Methode (CanHaveNumber(x : Integer) : Boolean) und die macht nichts anderes als

markieren

Delphi-Quellcode:

function TSuDoKuFeld.CanHaveNumber( x : integer ) : Boolean;
begin
  // Alle 3 Blöcke müssen diese Zahl zulassen
  Result := fBlocks[0].CanHaveNumber( x ) and fBlocks[1].CanHaveNumber( x ) and fBlocks[2].CanHaveNumber( x );
end;