1:
2:
3:
4:
5:
6:
7:

procedure TForm1.Button2Click(Sender: TObject);
begin
if stringgrid1.cells[0,0]<>stringgrid1.cells[1,0] then
showmessage('Richtig')
else
showmessage('Falsch')
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

Zahlen[1..9] : Boolean;

Für Jede Reihe
  Setze alle Arrayfelder von Zahlen auf false
  für jedes Feld in Reihe
    Wenn Zahlen[Feld] = False dann
      Setze Zahlen[Feld] = True
    sonst
      Fehlermeldung "Zahl im Feld " + Feld + " in Reihe " + Reihe + " doppelt vorhanden!"
      Prozedur abbrechen
  nächstes Feld
nächste Reihe					

1:

sudoku: array[0..8] of array[0..8] of array[0..14] of string;					

1:

zahlen: array[1..9] of array[1..9] of boolean;					

1:

sodoku: array[0..8, 0..8] of Integer					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:

 var sudoku: array[0..8, 0..8] of Integer;

//Testet ein Feld des Sodokus auf Richtigkeit
//@X: X-Position im Sodoku (0-8);
//@Y: Y-Position im Sodoku (0-8);
//@result: TRUE wenn Test bestanden, sonst FALSE;
function CheckField(X, Y: Integer): Boolean;
//SchleifenVariable
//  |  x-Position im Quadrat
//  |  |         y-Position im Quadrat
var i, QuadPosX, QuadPosY: Integer;
begin
  result := false ;                       //Ergebnis mit false initialisieren
  if(X < 0)or(X > 8) then exit;           //wenn X-Position auserhalb der ArrayGrenzen --> Exit (result: FALSE)
  if(Y < 0)or(Y > 8) then exit;           //wenn Y-Position auserhalb der ArrayGrenzen --> Exit (result: FALSE)
  for i := 0 to 8 do begin                //Schleife zum durchzählen der 9 Felder
    //Reihe in X-Richtung testen
    if (i <> X)and                        //wenn die Indices nicht identisch sind (nicht das gleiche Feld testen) UND
       (sudoku[i,Y] = sudoku[X,Y]) then   //die Inhalte der Felder gleich sind (doppelte Zahl), dann...
      exit;                               //--> Exit (result: FALSE)
    //Reihe in Y-Richtung testen
    if (i <> Y)and                        //analog zu oben
       (sudoku[X,i] = sudoku[X,Y]) then
      exit;
    //Quadrat testen
    QuadPosX := (i mod 3) + (X div 3)*3;  //mit (i mod 3) die X-Position den Feldes im MiniQuad berechnen(0-2)
                                          //mit (X div 3) die Position des MiniQuads errechnen(0-2)
                                          //und 3 multiplizeren um normalen FeldINdex zu bekommen (0, 3 oder 6)
    QuadPosY := (i div 3) + (Y div 3)*3;  //analog zu QuadPosX, bloß mit (i div 3) als Y-Wert
    if(QuadPosX <> X)and                  //wenn die Indices nicht identisch sind (nicht das gleiche Feld testen) UND
      (QuadPosY <> Y)and
      (sudoku[QuadPosX, QuadPosY] = sudoku[X, Y]) then //die Inhalte der Felder gleich sind (doppelte Zahl), dann...
      exit;                               //--> Exit (result = FALSE)
  end;                                    //SchleifenEnde
  result := true;                         //wenn alle Test bestanden nur noch Ergebnis auf TRUE setzen
                                          //Exit (result = TRUE)
end;

//Prüft alle Felder des Sodokus auf Richtigkeit
//@result: TRUE wenn Test bestanden, sonst FALSE;
function CheckAll: Boolean;
//Schleifenvariable
var i: Integer;
begin
  result := False;            //Erbenis mit false initialisieren
  for i := 0 to 80 do         //alle 81 Felder des Sudoku durchzählen
    if not CheckField(        //wenn der Test eines Einzelfeldes fehlschlägt, dann...
            i mod 9,          //(X-Position des Feldes berechnen)
            i div 9) then     //(Y-Position des Feldes berechnen)
      exit;                   //...Exit (result = FALSE)
  result := True;             //wenn alle Test bestanden Ergebnis auf TRUE setzen
                              //Exit (result = TRUE)
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

type
  TSudoku = array[0..8, 0..8] of Integer;
  PSodoku = ^TSudoku;
var
  SudokuList: TList;

procedure AddSudokuToList(FileName: String);
//Zeiger auf das neue Sudoku
var p: PSodoku;
begin
  new(p);                   //neues Array anlegen
  LoadSudoku(p^, FileName); //Array laden: LoadSudoku(sudoku: TSudoku; FileName: String);
  SudokuList.Add(p);        //Array in Liste übernehmen
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:

//prüft alle Spalten auf Richtigkeit
//@result: WAHR wenn alle Spalten richtig, sonst FALSCH
function CheckCols: Boolean;
var x, y, sum: Integer;
begin
  result := false;
  for x := 0 to 8 do begin        //alle Spalten durchzählen
    sum := 0;                     //neue Spalte, also Summe mit 0 initialisieren
    for y := 0 to 8 do            //alle Reihen durchzählen
      sum := sum + sudoku[x, y];  //aktuelles Feld der Reihen zur Summe addieren
    if sum <> 45 then             //wenn die Summe nicht stimmt, dann
      exit;                       //verlasse die Funktion mit Ergebnis = FALSCH
  end;
  result := true;                 //wenn die Funktion noch nicht vorzeitig abgebrochen wurde
                                  //und demzufolge alle Spalten-Summen 45 sind
                                  //muss noch das Ergeniss auf WAHR gesetz werden
end;

//prüft alle Reihen auf Richtigkeit
//@result: WAHR wenn alle Reihen richtig, sonst FALSCH
function CheckRows: Boolean;
var x, y, sum: Integer;
begin
  result := false;
  for y := 0 to 8 do begin        //alle Reihen durchzählen
    sum := 0;                     //neue Reihen, also Summe mit 0 initialisieren
    for x := 0 to 8 do            //alle Spalten durchzählen
      sum := sum + sudoku[x, y];  //aktuelles Feld der Spalte zur Summe addieren
    if sum <> 45 then             //wenn die Summe nicht stimmt, dann
      exit;                       //verlasse die Funktion mit Ergebnis = FALSCH
  end;
  result := true;                 //analog zu oben
end;

//Prüft alle MiniQuads auf Richtigkeit
//@result: WAHR wenn alle MiniQuads richtig, sonst FALSCH
function CheckQuads: Boolean;
var i, j, x, y: Integer;
begin
  for i := 0 to 2 do              //alle MiniQuad-Spalten durchzählen
    for j := 0 to 2 do begin      //alle MiniQuad-Reihen durchzählen
      sum := 0;                   //neues Quad, also Summe mit 0 initialisieren
      for x := 0 to 2 do          //alle Spalten des MiniQuads durchzählen
        for y := 0 to 2 do        //alle Reihen des MiniQuads durchzählen
          sum := sum + sudoku[i*3 + x, //erst die MiniQiad-Position in die FeldPosition umrechnen (*3)
                              j*3 + y] //und dann noch die Position des aktuellen Feldes im MiniQuad dazuaddieren (+x)
        if sum <> 45 then              //wenn die Summe nicht stimmt, dann
          exit;                        //verlasse die Funktion mit Ergebnis = FALSCH
    end;
  result := true;                 //analog zu oben
end;

//und jetzt kannst du so prüfen die du das wolltest:
if CheckCols and CheckRows and CheckQuads
  then ShowMessage('Sudoku richtig gelöst');					

1:
2:

if checkcols=true and checkrows=true and checkquads=true then
showmessage('Richtige Lösung');					

1:

      sum := sum + sudoku[x, y];					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

function testspalte:boolean;
var x, y, sum: integer;
begin
 result:= false;
  for x:= 0 to 8 do
   begin
   sum:= 0;
     for y := 0 to 8 do
     sum:= sum+ sudoku[x,y];
     if sum<>45 then
     exit;
  end;
  result:= true;
end;					

1:
2:
3:
4:
5:

var test: boolean;
test := true;
if test = true then ShowMessage('is wahr'); //is nich so schön
if test then ShowMessage('is wahr'); //so is besser
if not test then ShowMessage('is falsch'); //so negiert man das ganze dann					

1:
2:
3:

sudoku[0,0,0]:='3';
sudoku[0,1,0]:='' ;
sudoku[0,2,0]:='';					

1:

   sum:= sum+ sudoku[x,y];					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

procedure TForm1.Button2Click(Sender: TObject);
var i,j:integer;
    allesRichtig:Boolean;
begin
allesRichtig:=true;
for i:=0 to 7 do
    for j:=0 to 8 do
       if (stringgrid1.cells[i,j]=stringgrid1.cells[i+1,j]) then
          allesRichtig:=false;
if allesRichtig then       
    showmessage('Richtig')
else
    showmessage('Falsch');
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:

type
  TSudoku = array[0..8, 0..8] of Integer;

var 
  SudokuList: TList;

function LoadSudoku(FileName: String): TSudoku;
begin
  //lade das Sudoku
end;

//neues sudoku hinzufügen
procedure Test;
var neu: TSudoku;
begin
  if OpenDialog.Execute then begin
    neu := LoadSudoku(OpenDialog.FileName);
    SudokuList.add(neu);
  end;    
end;

//auf sudoku zugreifen
function GetSudokuFromList(index: Integer): TSudoku;
begin
  result := TSudoku(SudokuList[index]);
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:

function testspalte:boolean;
var x, y, sum: integer;
begin
 result:= false;
  for x:= 0 to 8 do
   begin
   sum:= 0;
     for y := 0 to 8 do
     sum:= sum+ sudoku[x,y];
     if sum<>45 then
     exit;
  end;
  result:= true;
end;

function testzeile:boolean;
var x, y, sum: integer;
begin
result:=false;
for x:= 0 to 8 do
begin
sum:=0;
 for y:= 0 to 8 do
 sum:= sum+ sudoku[x,y];
 if sum<>45 then
 exit;
 end;
 result:= true;
 end;

function testquadrat:boolean;
var p, q, x, y, sum:integer;
begin
result:= false;
 for p:= 0 to 2 do
  for q:= 0 to 2 do
  begin
  sum:= 0;
  for x:= 0 to 2 do
   for y:= 0 to 2 do
   sum:= sum + sudoku[p*3+x,q*3+y];
    if sum<>45 then
    exit;
   end;
   result:= true;
   end;