Autor Beitrag
Christian V.
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 311

Win Xp Prof
Turbo Delphi 2005
BeitragVerfasst: Sa 14.04.07 17:40 
Hallo DF,
Ich verusche gerade einen Teil meines Programmes in ein Objekt zu verpacken. Allerdings habe ich mit dem Destroy so meine Probleme. Sobald Destroy aufgerufen wird, bekomme ich eine Zugriffsverletzung.

Hier mal die Definition meines Objekts:
ausblenden volle Höhe Delphi-Quelltext
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:
//Funktionen zur Übersichtlichkeit rausgekürzt. Funktionieren aber alle, habe das s hcon mit ausführlichem debuggen getestet.
type
  TSudoku=Class(TObject)
  private
    sudoku: Array of Array[1..81] of Integer;
    impossible: Array of Array[1..9,1..9,1..9]of Boolean;
    owner: Array of Array[1..9,1..9,1..9] of Integer;
    quadrant: Array of Array[1..3,1..3,1..9] of Boolean;
  public
    constructor Create;
    destructor Destroy; override;
    //*************************************//
    //*************************************//
    procedure ResetAll();
    procedure SolveLogic();
///////////////////////////////////////////////
constructor TSudoku.Create;
begin
  inherited create;
  SetLength(sudoku,1);
  SetLength(impossible,1);
  SetLength(owner,1);
  SetLength(quadrant,1);
end;
destructor TSudoku.Destroy;
begin
  SetLength(sudoku,0);
  SetLength(impossible,0);
  SetLength(owner,0);
  SetLength(quadrant,0);
  inherited destroy;
end;

Als ich dann mal testen wollte ob das soweit funktioniert, habe ich einen Button erstellt, und ein wenig Code:
ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
procedure TForm1.Button1Click(Sender: TObject);
begin
field:=TSudoku.Create;
field.ResetAll;
field.SetVal(0,1,1); //Schreibt eine 1 in sudoku[0,1]
field.SolveLogic;    //Wirft Lösungsheuristik an //Hab den ocde aber noch nicht portiert. Funktion prüft nur die Sudoku regeln
field.destroy;  //Hier happerts, sobald ich hier rein will, gibts ne Zugriffsverletzung.
end;


//edit: Problem gelöst: keine Ahnung washalb, aber jetzt gehts. Habe den Code nun fertig portiert. -> Open Source Units

_________________
Hardware runs the world, software controls the hardware, code generates software - Have You already coded today?


Zuletzt bearbeitet von Christian V. am Di 17.04.07 17:14, insgesamt 2-mal bearbeitet
Gausi
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Beiträge: 8554
Erhaltene Danke: 481

Windows 7, Windows 10
D7 PE, Delphi XE3 Prof, Delphi 10.3 CE
BeitragVerfasst: Sa 14.04.07 17:47 
Destroy ruft man nicht direkt auf, sondern nimmt stattdessen .free

_________________
We are, we were and will not be.
Christian V. Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 311

Win Xp Prof
Turbo Delphi 2005
BeitragVerfasst: Sa 14.04.07 17:50 
Danke für die schnelle Antwort.
Hilft leider nichts, Problem besteht immer noch.

_________________
Hardware runs the world, software controls the hardware, code generates software - Have You already coded today?
MrCoder
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 65

WinXP, SuSE Linux
D7 Ent
BeitragVerfasst: Sa 14.04.07 18:41 
Hi,
schick mal bitte den kompletten Code. So wie es da steht ist schon richtig.
PS: Man kann ruhig auch Destroy direkt aufrufen (Free ist nur in speziellen Fällen sicherer)
Christian V. Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 311

Win Xp Prof
Turbo Delphi 2005
BeitragVerfasst: Sa 14.04.07 19:18 
Wird mit der oben geposteten Click-Prozedur aufgerufen.

Zur Funktionsweise: Die erste Dimension in den Arrays ist dynamisch, so können sie verlängert werden, falls es mehrere mögliche Lösungen gibt.
Im Array Sudoku werden die Werte gespeichert, 0 entspricht keinem Eintrag.
Im Array Impossible wird für jedes Feld, welche über die Koordinaten X/Y angesprochen werden können, die Möglichkeiten gespeichert. True steht für schon benutzt. So ist eine schnelle überprüfung möglich, ob nur noch eine Zahl eingesetzt werden kann.
Array Owner dient dazu, um sich zu merken, wer den Eintrag in Impossible an welcher Stelle für welche Zahl gemacht hat. Dies wird verwendet um Sicherzustellen, dass keine falschen "Möglichkeiten" entfern werden. Möglichkeiten werden entfernt, wenn Backtracking-Methode eingesetzt wird.
Die Methode SolveLogic sollte eigentlich die Lösungsheuristik beinhalten, allerdings habe ich diese noch nicht ins Objekt überführt, weil ich mit der Zugriffsverletzung Probleme bekommen habe.

Die Funktionen GetLineX/Y GetQuadX/Y werden dazu benutzt, um aus dem Index(1..81) Spalte(X) oder Y(Linie) zu berechnen, Quadrant entspricht einem 3*3er Kästchen.

//Edit: ResetAll ist um alle Array wieder auf Ursprungswerte zu stellen, also Leer.
SetVal brauche ich, bzw werde ich brauchen um den Sudoku Array mit Daten zu fütter, z.B. von einem Stringgrid.
SetPos aktualisiert den Array Impossible und stellt die benötigten felder auf TRUE, und den Owner falls noch keiner eingetragen ist.
RemPos löscht die Möglichkeiten falls beim Backtracking ein schritt zurückgegangen werden muss. Um sicherzustellen dass keine falschen Möglichkeiten gesetzt werden, wird zuerst geprüft ob der Besitzer mit dem aktuell zu bearbeitenden feld übereinstimmt.

//Edit2: Quelltext aktualisiert: Heuristikfunktion angepasst, und eingefügt., noch ein paar kleine Änderungen an SetPos und RemPos


ausblenden volle Höhe Delphi-Quelltext
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:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
unit USudoku;


interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;

type
  TSudoku=Class(TObject)
  private
    sudoku:    Array of Array[1..81]          of Integer;
    impossible:Array of Array[1..9,1..9,1..9] of Boolean;
    owner:     Array of Array[1..9,1..9,1..9] of Integer;
    quadrant:  Array of Array[1..3,1..3,1..9] of Boolean;
    num:integer;
    procedure SetPos(num,index:integer);
    procedure RemPos(num,index:integer);
    function GetLineX(index:integer):integer;
    function GetLineY(index:integer):integer;
    function GetQuadX(index:integer):integer;
    function GetQuadY(index:integer):integer;
  public
    constructor Create;
    destructor Destroy; override;
    //*************************************//

    function GetVal(num,index:integer):integer;
    procedure SetVal(num,index,val:integer);
    //*************************************//
    procedure ResetAll();
    procedure SolveLogic();

  end;
implementation

constructor TSudoku.Create;
begin
  inherited create;
  SetLength(sudoku,1);
  SetLength(impossible,1);
  SetLength(owner,1);
  SetLength(quadrant,1);
end;
////////////////////////////////////////////////////////////////////////////////
destructor TSudoku.Destroy;
begin
  SetLength(sudoku,0);
  SetLength(impossible,0);
  SetLength(owner,0);
  SetLength(quadrant,0);
  inherited destroy;
end;

////////////////////////////////////////////////////////////////////////////////
//****************************************************************************//
// Koordinaten Funktionen                                                     //
//****************************************************************************//
////////////////////////////////////////////////////////////////////////////////
function TSudoku.GetLineX(index:integer):integer;
begin
  while(index>9) do begin
    index:=index-9;
  end;
  result:=index;
end;
////////////////////////////////////////////////////////////////////////////////
function TSudoku.GetLineY(index:integer):integer;
begin
  result:=1;
  while(index>9) do begin
    index:=index-9;
    result:=result+1;
  end;
end;
////////////////////////////////////////////////////////////////////////////////
function TSudoku.GetQuadX(index:integer):integer;
begin
  result:=(GetLineX(index)-1) div 3 +1;
end;
function TSudoku.GetQuadY(index:integer):integer;
begin
  result:=(GetLineY(index)-1) div 3 +1;
end;
////////////////////////////////////////////////////////////////////////////////
function TSudoku.GetVal(num,index:integer):integer;
begin
  result:=sudoku[num,index];
end;
procedure TSudoku.SetVal(num,index,val:integer);
begin
  sudoku[num,index]:=val;
end;

////////////////////////////////////////////////////////////////////////////////
//****************************************************************************//
//    Möglichkeits Funktionen                                                 //
//****************************************************************************//
////////////////////////////////////////////////////////////////////////////////
procedure TSudoku.SetPos(num,index:integer);
var
x,y,c1,c2,Val,LineX,LineY,QuadX,QuadY:integer;
begin
  LineX:=GetLineX(index);
  LineY:=GetLineY(index);
  QuadX:=GetQuadX(index);
  QuadY:=GetQuadY(index);
  Val:=Sudoku[num,index];
  //Zeilen Möglichkeiten setzen;
  for c1:=1 to 9 do begin
    if owner[num,LineX,c1,val]=0 then owner[num,LineX,c1,val]:=index;
    impossible[num,LineX,c1,val]:=true;
    if owner[num,c1,LineY,val]=0 then owner[num,c1,LineY,val]:=index;
    impossible[num,c1,LineY,val]:=true;
    if owner[num,Linex,Liney,c1]=0 then begin
      owner[num,Linex,Liney,c1]:=index;
      impossible[num,Linex,Liney,c1]:=true;
    end;
  end;
  for c1:= 1 to 3 do begin
    x:=(Quadx-1)*3+c1;
    for c2:=1 to 3 do begin
      y:=(Quady-1)*3+c2;
      if owner[num,x,y,val]=0 then owner[num,x,y,val]:=index;
      impossible[num,x,y,val]:=true;
    end;
  end;
  Quadrant[num,QuadX,QuadY,val]:=true;
end;
////////////////////////////////////////////////////////////////////////////////
procedure TSudoku.RemPos(num,index:integer);
var
x,y,c1,c2,Val,LineX,LineY,QuadX,QuadY:integer;
begin
  LineX:=GetLineX(index);
  LineY:=GetLineY(index);
  QuadX:=GetQuadX(index);
  QuadY:=GetQuadY(index);
  Val:=Sudoku[num,index];
  //Zeilen Möglichkeiten setzen;
  for c1:=1 to 9 do begin
    if owner[num,LineX,c1,val]=index then begin
      owner[num,LineX,c1,val]:=0;
      impossible[num,LineX,c1,val]:=false;
    end;
    if owner[num,c1,LineY,val]=index then begin
      owner[num,c1,LineY,val]:=0;
      impossible[num,c1,LineY,val]:=false;
    end;
    if owner[num,Linex,Liney,c1]=index then begin
      owner[num,Linex,Liney,c1]:=0;
      impossible[num,Linex,Liney,c1]:=false;
    end;
  end;
  for c1:= 1 to 3 do begin
    x:=(Quadx-1)*3+c1;
    for c2:=1 to 3 do begin
      y:=(Quady-1)*3+c2;
      if owner[num,x,y,val]=index then owner[num,x,y,val]:=0;
      impossible[num,x,y,val]:=false;
    end;
  end;
end;
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
procedure TSudoku.ResetAll();
var i,i2,i3,i4:integer;
begin
  for i:=0 to Length(sudoku)-1 do begin
    for i2:=1 to 9 do begin
      for i3:=1 to 9 do begin
        for i4:=1 to 9 do begin
          owner[i,i2,i3,i4]:=0;
          impossible[i,i2,i3,i4]:=false;
        end;
        sudoku[i,(i2-1)*9+i3]:=0;
      end;
    end;
  end;
  SetLength(sudoku,1);
  SetLength(owner,1);
  SetLength(impossible,1);
end;
////////////////////////////////////////////////////////////////////////////////
//****************************************************************************//
//   Lösungsheuristik                                                         //
//****************************************************************************//
////////////////////////////////////////////////////////////////////////////////
procedure TSudoku.SolveLogic();
var
kord,Count,CountPossible,z,inqx,qx,inqy,qy,x,y,i:integer;
fehler,found:boolean;
Label Abbruch,{Normal,}RegelVerstoss;
begin
  num:=0;
  count:=0;
  fehler:=false;
  //Möglichkeiten Setzten mit den Zahlen, die bereits im Array liegen,
  //gleichzeitige Überprüfung auf Sudoku Regeln
  for i:=1 to 81 do begin
    x:=GetLineX(i);
    y:=GetLineY(i);
    if sudoku[0,i]<>0 then begin
      if impossible[0,x,y,sudoku[0,i]]=false then begin
        setpos(0,i);
        count:=count+1;
      end
      else goto RegelVerstoss;
    end;
  end;
  //Initialisiere Heuristik
  found:=true;
repeat
  while(found=true)do begin
    found:=false;
    for z:= 1 to 9 do begin   //Z Zahl auf die geprüft wird
      for qx:=1 to 3 do begin //QuadX
        for qy:=1 to 3 do begin //QuadY
          if Quadrant[0,qx,qy,z]=false then begin  //Prüft ob Zahl im Quadranten Vorkommen kann, fals nein -> nächster
            CountPossible:=0; //Temp: Wieviele Möglichkeiten im Quadranten für bestimmte Zahl besteht
            for inqx:=1 to 3 do begin
              for inqy:=1 to 3 do begin
                if impossible[0,(qx-1)*3+inqx,(qy-1)*3+inqy,z]=false then begin
                  CountPossible:=CountPossible+1;
                  if CountPossible=2 then begin   //falls mehr als 1 Möglichkeit, dann
                    goto abbruch;
                  end;
                  kord:=((qx-1)*3+inqx)+(((qy-1)*3+inqy)-1)*9;
                end
              end;
            end;
            if CountPossible=1 then begin
              sudoku[0,kord]:=z;
              count:=count+1;
              found:=true;
              setpos(0,kord);
            end;
          end;
          abbruch:
        end;
      end;
    end;
  end;
  for i:=1 to 81 do begin
    CountPossible:=0;
    x:=GetLineX(i);
    y:=GetLineY(i);
    for z:=1 to 9 do begin
      if impossible[0,x,y,z]=false then begin
        CountPossible:=CountPossible+1;
        kord:=z;
        if CountPossible=2 then break;
      end;
    end;
    if CountPossible=1 then begin
      sudoku[0,x+(y-1)*9]:=kord;
      setpos(0,x+(y-1)*9);
      found:=true;
      count:=count+1;
    end;
  end;
until(found=false);
  //goto Normal
  if fehler=true then begin
    RegelVerstoss:
    ShowMessage('In Feld '+IntToStr(x)+','+IntToStr(10-y)+' liegt ein Verstoss gegen die Sudokuregeln vor!');
  end;
  //Normal:
end;
end.

_________________
Hardware runs the world, software controls the hardware, code generates software - Have You already coded today?
Christian V. Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 311

Win Xp Prof
Turbo Delphi 2005
BeitragVerfasst: Mo 16.04.07 17:33 
Hilfe mein Problem ist wieder aufgetaucht, und ich habe wieder mal keine Ahnung warum. Die Exception kommt wenn ich bei einer Funktion austrete, also genau wenn ich mit F7 auf dem End lande(Linie 109). Danach würde die .Free methode aufgerufen werden. So sieht mein Quelltext aus:
ausblenden volle Höhe Delphi-Quelltext
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:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323:
324:
325:
326:
327:
328:
329:
330:
331:
332:
333:
334:
335:
336:
337:
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:
358:
359:
360:
361:
362:
363:
364:
365:
366:
367:
368:
369:
370:
371:
372:
373:
374:
375:
376:
377:
378:
379:
380:
381:
382:
383:
384:
385:
386:
387:
388:
389:
390:
391:
392:
393:
394:
395:
396:
397:
////////////////////////////////////////
//Coded and Copyright by Christian V. //
////////////////////////////////////////
unit USudoku;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;

type
  use= set of 1..81;
  TSudoku=Class(TObject)
  private
    sudoku:    Array of Array[1..81]          of Integer;
    impossible:Array of Array[1..9,1..9,1..9] of Boolean;
    owner:     Array of Array[1..9,1..9,1..9] of Integer;
    quadrant:  Array of Array[1..3,1..3,1..9] of Boolean;
    first,last,count,num:integer;
    fehler:boolean;
    ErrVal,ErrNum:integer;
    inuse: set of 1..81;
    used:use;
    procedure SetPos(num,index:integer);
    procedure RemPos(num,index:integer);
    function  InitializePos(num:integer):boolean;
    function  GetLineX(index:integer):integer;
    function  GetLineY(index:integer):integer;
    function  GetQuadX(index:integer):integer;
    function  GetQuadY(index:integer):integer;
    function  GetCounter:integer;
    procedure ResetPos(num:integer);
    procedure ResetAll();
    function  BackTracking(num,start:integer):boolean;
    procedure AddDim(num:integer);
  public
    constructor Create;
    destructor Destroy; override;
    //*************************************//
    property  ErrorNumber:integer read ErrNum;
    property  ErrorValue:integer read ErrVal;
    property  GetCount:integer read GetCounter;
    function  GetVal(num,index:integer):integer;
    procedure SetVal(num,index,val:integer);
    //*************************************//
    procedure SolveAdvanced();
    procedure SolveLogic();
    procedure SolveMore(HowMany:integer);

  end;
implementation

constructor TSudoku.Create;
begin
  inherited create;
  SetLength(sudoku,1);
  SetLength(impossible,1);
  SetLength(owner,1);
  SetLength(quadrant,1);
end;
destructor TSudoku.Destroy;
begin
  SetLength(sudoku,0);
  SetLength(impossible,0);
  SetLength(owner,0);
  SetLength(quadrant,0);
  inherited destroy;
end;

function TSudoku.GetCounter():integer;
begin
  result:=count;
end;
////////////////////////////////////////////////////////////////////////////////
//****************************************************************************//
// Koordinaten Funktionen                                                     //
//****************************************************************************//
////////////////////////////////////////////////////////////////////////////////
function TSudoku.GetLineX(index:integer):integer;
begin
  while(index>9) do begin
    index:=index-9;
  end;
  result:=index;
end;
function TSudoku.GetLineY(index:integer):integer;
begin
  result:=1;
  while(index>9) do begin
    index:=index-9;
    result:=result+1;
  end;
end;
function TSudoku.GetQuadX(index:integer):integer;
begin
  result:=(GetLineX(index)-1) div 3 +1;
end;
function TSudoku.GetQuadY(index:integer):integer;
begin
  result:=(GetLineY(index)-1) div 3 +1;
end;
////////////////////////////////////////////////////////////////////////////////
function TSudoku.GetVal(num,index:integer):integer;
begin
  result:=sudoku[num,index];
end;
procedure TSudoku.SetVal(num,index,val:integer);
begin
  sudoku[num,index]:=val;
end; //Hier tritt die Exception auf.

////////////////////////////////////////////////////////////////////////////////
//****************************************************************************//
//    Möglichkeits Funktionen                                                 //
//****************************************************************************//
////////////////////////////////////////////////////////////////////////////////
procedure TSudoku.SetPos(num,index:integer);        //Möglichkeiten setzen
var
x,y,c1,c2,Val,LineX,LineY,QuadX,QuadY:integer;
begin
  LineX:=GetLineX(index);
  LineY:=GetLineY(index);
  QuadX:=GetQuadX(index);
  QuadY:=GetQuadY(index);
  Val:=Sudoku[num,index];
  //Zeilen Möglichkeiten setzen;
  for c1:=1 to 9 do begin
    if owner[num,LineX,c1,val]=0 then owner[num,LineX,c1,val]:=index;
    impossible[num,LineX,c1,val]:=true;
    if owner[num,c1,LineY,val]=0 then owner[num,c1,LineY,val]:=index;
    impossible[num,c1,LineY,val]:=true;
    if owner[num,Linex,Liney,c1]=0 then begin
      owner[num,Linex,Liney,c1]:=index;
      impossible[num,Linex,Liney,c1]:=true;
    end;
  end;
  for c1:= 1 to 3 do begin
    x:=(Quadx-1)*3+c1;
    for c2:=1 to 3 do begin
      y:=(Quady-1)*3+c2;
      if owner[num,x,y,val]=0 then owner[num,x,y,val]:=index;
      impossible[num,x,y,val]:=true;
    end;
  end;
  Quadrant[num,QuadX,QuadY,val]:=true;
end;
procedure TSudoku.RemPos(num,index:integer);     //Möglichkeiten entfernen
var
x,y,c1,c2,Val,LineX,LineY,QuadX,QuadY:integer;
begin
  LineX:=GetLineX(index);
  LineY:=GetLineY(index);
  QuadX:=GetQuadX(index);
  QuadY:=GetQuadY(index);
  Val:=Sudoku[num,index];
  for c1:=1 to 9 do begin
    for c2:=1 to 9 do begin
      if owner[num,c1,c2,val]=index then begin
      owner[num,c1,c2,val]:=0;
      impossible[num,c1,c2,val]:=false;
    end;
    end;
    if owner[num,Linex,Liney,c1]=index then begin
      owner[num,Linex,Liney,c1]:=0;
      impossible[num,Linex,Liney,c1]:=false;
    end;
  end;
end;
procedure TSudoku.ResetAll();
var i,i2,i3,i4:integer;
begin
  for i:=0 to Length(sudoku)-1 do begin
    for i2:=1 to 9 do begin
      for i3:=1 to 9 do begin
        for i4:=1 to 9 do begin
          owner[i,i2,i3,i4]:=0;
          impossible[i,i2,i3,i4]:=false;
        end;
        sudoku[i,(i2-1)*9+i3]:=0;
      end;
    end;
  end;
  SetLength(sudoku,1);
  SetLength(owner,1);
  SetLength(impossible,1);
  ErrNum:=0;
  ErrVal:=0
end;
////////////////////////////////////////////////////////////////////////////////
procedure TSudoku.ResetPos(num:integer);
var i,i2,i3:integer;
begin
  for i:=1 to 9 do begin
    for i2:=1 to 9 do begin
      for i3:=1 to 9 do begin
        owner[num,i,i2,i3]:=0;
        impossible[num,i,i2,i3]:=false;
      end;
    end;
  end;
end;
////////////////////////////////////////////////////////////////////////////////
function TSudoku.InitializePos(num:integer):boolean;
var
temp,x,y,i,i2:integer;
Label normal,Regelverstoss;
begin
  result:=true;
  used:=[1..81];
  count:=0;
  temp:=0;
  for i:= 1 to 81 do begin
    if sudoku[num,i]<>0 then begin
      x:=GetLineX(i);
      y:=GetLineY(i);
      if impossible[0,x,y,sudoku[0,i]]=false then begin
        setpos(0,i);
        count:=count+1;
        used:=used-[i];
      end
      else goto RegelVerstoss;
    end
    else begin
      if temp=0 then begin
        first:=i;
        temp:=1;
      end;
    end;
  end;
  goto normal;
//Fehler
  regelverstoss:
  ErrNum:=1;
  ErrVal:=i;
  result:=false;
  normal:
end;
////////////////////////////////////////////////////////////////////////////////
//****************************************************************************//
//   Lösungsheuristik                                                         //
//****************************************************************************//
////////////////////////////////////////////////////////////////////////////////
procedure TSudoku.SolveLogic();
var
kord,CountPossible,z,inqx,qx,inqy,qy,x,y,i:integer;
  found:boolean;
Label Abbruch,{Normal,}RegelVerstoss;
begin
  num:=0;
  ResetPos(num);
  count:=0;
  //Möglichkeiten Setzten mit den Zahlen, die bereits im Array liegen,
  //gleichzeitige Überprüfung auf Sudoku Regeln
  if InitializePos(num) then begin
  //Initialisiere Heuristik
    found:=true;
    while (found=true) do begin
      while(found=true)do begin
        found:=false;
        for z:= 1 to 9 do begin   //Z Zahl auf die geprüft wird
          for qx:=1 to 3 do begin //QuadX
            for qy:=1 to 3 do begin //QuadY
              if Quadrant[0,qx,qy,z]=false then begin  //Prüft ob Zahl im Quadranten Vorkommen kann, fals nein -> nächster
                CountPossible:=0; //Temp: Wieviele Möglichkeiten im Quadranten für bestimmte Zahl besteht
                for inqx:=1 to 3 do begin
                  for inqy:=1 to 3 do begin
                    if impossible[0,(qx-1)*3+inqx,(qy-1)*3+inqy,z]=false then begin
                      CountPossible:=CountPossible+1;
                    if CountPossible=2 then begin   //falls mehr als 1 Möglichkeit, dann
                      goto abbruch;
                    end;
                      kord:=((qx-1)*3+inqx)+(((qy-1)*3+inqy)-1)*9;
                    end
                  end;
                end;
                if CountPossible=1 then begin
                  sudoku[0,kord]:=z;
                  count:=count+1;
                  found:=true;
                  setpos(0,kord);
                end;
              end;
              abbruch:
            end;
          end;
        end;
      end;
      for i:=1 to 81 do begin
        CountPossible:=0;
        x:=GetLineX(i);
        y:=GetLineY(i);
        for z:=1 to 9 do begin
          if impossible[0,x,y,z]=false then begin
            CountPossible:=CountPossible+1;
            kord:=z;
            if CountPossible=2 then break;
          end;
        end;
        if CountPossible=1 then begin
          sudoku[0,x+(y-1)*9]:=kord;
          setpos(0,x+(y-1)*9);
          found:=true;
          count:=count+1;
        end;
      end;
    end;;
  end;
end;
function TSudoku.BackTracking(num,start:integer):boolean;
var
z,x,y,i:integer;
found:boolean;
Label advschluss,regelverstoss;
begin
  // Beginn des Algorithmus
  found:=true;
  result:=true;
  i:=start;
  while (i<82) AND (i>=first) do begin  //Während nicht alle Felder ausgefüllt sind
    if [i]<=used then begin    //falls Feld nicht standardmässig ausgefüllt
      //Falls Feld noch Leer ist(Immer beim ersten Einlauf in Funktion)
      x:=GetLineX(i);
      y:=GetLineY(i);
      if sudoku[num,i]=0 then begin
        for z:=1 to 9 do begin
          if impossible[num,x,y,z]=false then begin //Falls ein Wert gültig ist
            sudoku[num,i]:=z;
            setpos(num,i);
            i:=i+1;
            found:=true;
            count:=count+1;
            goto advschluss;         //Springe zum Ende
          end;
        end;                        //Falls kein Wert gültig ist, bearbeite letztes Feld
        i:=i-1;
        found:=false;
      end
      else begin                   //Lösche Möglichkeiten, das dieses Feld gesetzt hat
        rempos(num,i);
        for z:=(sudoku[num,i]+1) to 9 do begin
          if impossible[num,x,y,z]=false then begin  //falls Wert gültig ist
            sudoku[num,i]:=z;
            setpos(num,i);
            i:=i+1;
            found:=true;
            goto advschluss;
          end;
        end;
        sudoku[num,i]:=0;        //Falls kein Wert gültig war, setze Feld auf 0 und gehe ein Feld zurück
        i:=i-1;
        count:=count-1;
        found:=false;
      end;
    end
    else if found=true then i:=i+1      //Falls felder standardmässig besetzt sind
    else i:=i-1;
    advschluss:
  end;
  if i<first then begin
    result:=false;
  end;
  last:=i-1;
end;

procedure TSudoku.SolveAdvanced();
begin
  ResetPos(0);
  if InitializePos(0) then begin
    if Backtracking(0,first)= false then begin
      ErrNum:=2;
    end;
  end;
end;
procedure TSudoku.SolveMore(HowMany:integer);
var i:integer;
begin
  for i:=1 to HowMany do begin
    AddDim(i);
    if backtracking(i,last)=false then begin
      exit;
    end;
  end;
end;
procedure TSudoku.AddDim(num:integer);
var i,i2:integer;
begin
  SetLength(sudoku,num+1);
  SetLength(owner,num+1);
  SetLength(impossible,num+1);
  for i:=1 to 9 do begin
    for i2:=1 to 9 do begin
      Sudoku[num,(i-1)*9+i2]:=Sudoku[num-1,(i-1)*9+i2];
      Impossible[num,i,i2]:=Impossible[num-1,i,i2];
      Owner[num,i,i2]:=Owner[num-1,i,i2];
    end;
  end;
end;
end.


Diese Funktion wird folgenrdermassen aufgerufen:
ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
for i:=1 to 9 do begin      //I Spalte
  for i2:=1 to 9 do begin   //I2 Zeile
    if field.GetVal(1,(i2-1)*9+i)<>0 then begin
      StringGrid1.Cells[i-1,i2-1]:=IntToStr(field.GetVal(1,(i2-1)*9+i));
      end;
  end;
end;
field.Free;

Sobald I und I2 9 sind, wird Feld nummer 81 angefordert.

Der Witz an der Sache: Ich habe danach ausnahmslos alle Werte in meinem Stringgrid stehen. (Ja, es sind auch die richtigen)

Freue mich auf Antworten.

_________________
Hardware runs the world, software controls the hardware, code generates software - Have You already coded today?
Christian V. Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 311

Win Xp Prof
Turbo Delphi 2005
BeitragVerfasst: Di 17.04.07 17:12 
Nun, ich hab rausgefunden wie ich die Fehlermeldung wegbekomme. Aber: Ich seh darin keinen Sinn. :wink:
Mit Fehler:
ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
if field.GetCount<>81 then begin
  ShowMessage('Beginne mit Backtracking');
  field.SolveAdvanced;
  for i:=1 to 9 do begin      //I Spalte
    for i2:=1 to 9 do begin   //I2 Zeile
        StringGrid1.Cells[i-1,i2-1]:=IntToStr(field.GetVal(0,(i2-1)*9+i));
    end;
  end;
  field.SolveMore(10);
  for i:=1 to 9 do begin      //I Spalte
    for i2:=1 to 9 do begin   //I2 Zeile
      StringGrid1.Cells[i-1,i2-1]:=IntToStr(field.GetVal(10,(i2-1)*9+i));
    end;
  end;
  ShowMessage('???!'); //Kommt nur wenn kein Fehler Passiert, sonst geht er aus der Prozedur raus.
end;


Und hier noch Ohne Fehler:
ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
if field.GetCount<>81 then begin
  ShowMessage('Beginne mit Backtracking');
  field.SolveAdvanced;
  for i:=1 to 9 do begin      //I Spalte
    for i2:=1 to 9 do begin   //I2 Zeile
        //StringGrid1.Cells[i-1,i2-1]:=IntToStr(field.GetVal(0,(i2-1)*9+i));
    end;
  end;
  field.SolveMore(10);
  for i:=1 to 9 do begin      //I Spalte
    for i2:=1 to 9 do begin   //I2 Zeile
      StringGrid1.Cells[i-1,i2-1]:=IntToStr(field.GetVal(10,(i2-1)*9+i));
    end;
  end;
  ShowMessage('???!'); //Kommt nur wenn kein Fehler Passiert, sonst geht er aus der Prozedur raus.
end;

Noch zu dem Code: mit SolveAdvanced rufe ich das Backtracking auf, der mir die erste Mögliche Lösung berechnet, mit SOlveMore(10) berechne ich 10 neue Lösungen, also insgesmat 11. Oben rufe ich die erste ab, und unten die 11.
Ich bekomme die 11. Lösung in mein Stringgrid, selbst wenn der Fehler auftritt.
Warum passiert sowas?

Edit:

Dies funktioniert auch:
ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
if field.GetCount<>81 then begin
  ShowMessage('Beginne mit Backtracking');
  field.SolveAdvanced;
  for i:=1 to 9 do begin      //I Spalte
    for i2:=1 to 9 do begin   //I2 Zeile
      StringGrid1.Cells[i-1,i2-1]:=IntToStr(field.GetVal(0,(i2-1)*9+i));
    end;
  end;
  //field.SolveMore(10);
  for i:=1 to 9 do begin      //I Spalte
    for i2:=1 to 9 do begin   //I2 Zeile
      //StringGrid1.Cells[i-1,i2-1]:=IntToStr(field.GetVal(10,(i2-1)*9+i));
    end;
  end;
  ShowMessage('???!');
end;


Dies hingegen wieder nicht:
ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
if field.GetCount<>81 then begin
  ShowMessage('Beginne mit Backtracking');
  field.SolveAdvanced;
  for i:=1 to 9 do begin      //I Spalte
    for i2:=1 to 9 do begin   //I2 Zeile
      StringGrid1.Cells[i-1,i2-1]:=IntToStr(field.GetVal(0,(i2-1)*9+i));
    end;
  end;
  field.SolveMore(10);
  for i:=1 to 9 do begin      //I Spalte
    for i2:=1 to 9 do begin   //I2 Zeile
      //StringGrid1.Cells[i-1,i2-1]:=IntToStr(field.GetVal(10,(i2-1)*9+i));
    end;
  end;
  ShowMessage('???!');
end;


//Edit: Langsam hab ich das Gefühl dass es etwas mit diesen Dynamischen Arrays zu tun hat.

_________________
Hardware runs the world, software controls the hardware, code generates software - Have You already coded today?
BenBE
ontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic starofftopic star
Beiträge: 8721
Erhaltene Danke: 191

Win95, Win98SE, Win2K, WinXP
D1S, D3S, D4S, D5E, D6E, D7E, D9PE, D10E, D12P, DXEP, L0.9\FPC2.0
BeitragVerfasst: Di 17.04.07 20:48 
Deine Arrays sind von 1..9 definiert, in den Schleifen scheinst Du aber von 0..8 darauf zuzugreifen. Aktiviere bitte einmal in den Compiler-Optionen die Bereichsprüfung und die Überlaufprüfungen.

_________________
Anyone who is capable of being elected president should on no account be allowed to do the job.
Ich code EdgeMonkey - In dubio pro Setting.
Christian V. Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 311

Win Xp Prof
Turbo Delphi 2005
BeitragVerfasst: Mi 18.04.07 11:28 
Das mit der Bereichsüberprüfung hat mir der Martok auch schon geraten. Hat aber nichts gebracht, selbe Fehlermeldung. Der array auf den ich bei der Funktion(GetValue) zugreife geht von 1 bis 81:(Ich denke mal du meinst die stelle)
sudoku: Array of Array[1..81] of Integer;
(i2-1)*9+i)
Angenommen: i=1 i2=1:
(1-1)*9+1=1
Angenommen: i=9 i2=9:
(9-1)*9+9=81;

_________________
Hardware runs the world, software controls the hardware, code generates software - Have You already coded today?
Kroko
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 1284

W98 W2k WXP
Turbo D
BeitragVerfasst: Mi 18.04.07 11:53 
(a) gleiche Vermutung, du schreibst über den Speicherbereich eines dyn.Arrays hinaus und killst damit das, was dahinter liegt
(b) schreibe alles auf die Indizes von 0..8 um
(c) nach einschalten der Compileroption Bereichsprüfung musst Du das Projekt neu erzeugen, dann sollte auch der Fehler vorher sichtbar werden
(d) lege Dir folgendes an
ausblenden Delphi-Quelltext
1:
2:
3:
type
  TSudokoLine = array[0..8] of Integer;
  TSudokoArray = array[0..8] of TSudokoLine;
und schreibe Dir 3 Prozeduren, welche Dir
(1) eine Zeile,
(2) eine Spalte,
(3) einen Quadranten in ein TSudokoLine lesen!

_________________
Die F1-Taste steht nicht unter Naturschutz und darf somit regelmäßig und oft benutzt werden! oder Wer lesen kann, ist klar im Vorteil!
Christian V. Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 311

Win Xp Prof
Turbo Delphi 2005
BeitragVerfasst: Mi 18.04.07 12:30 
Moment moment, bevor ich nun alles umzukrempeln beginne, möchte ich euch dies hier zeigen:
s. Anhang debugarrayalltb4.jpg

Und dies hier:
s. Anhang debugarray10lz9.jpg

Wie man sieht kann ich während dem Debuggen Alle Arrays auslesen.
Zudem entsteht die Exception auch nicht bei einem Schreibzugriff, sondern erst bei dieser Funktion:
ausblenden Delphi-Quelltext
1:
2:
3:
4:
function TSudoku.GetVal(num,index:integer):integer;
begin
  result:=sudoku[num,index];
end;


Moderiert von user profile iconTino: Bilder als Anhang eingefügt.
Einloggen, um Attachments anzusehen!
_________________
Hardware runs the world, software controls the hardware, code generates software - Have You already coded today?
Kroko
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 1284

W98 W2k WXP
Turbo D
BeitragVerfasst: Mi 18.04.07 13:30 
Zitat:
Zudem entsteht die Exception auch nicht bei einem Schreibzugriff, sondern erst bei dieser Funktion:


Ja eben, beim Schreiben in eines deiner vielen Arrays wird etwas vom nächsten überschrieben und beim Lesen crasht es dann :!:

EDIT:
PS: Teile und Herrsche!

_________________
Die F1-Taste steht nicht unter Naturschutz und darf somit regelmäßig und oft benutzt werden! oder Wer lesen kann, ist klar im Vorteil!
Kroko
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 1284

W98 W2k WXP
Turbo D
BeitragVerfasst: Mi 18.04.07 13:49 
Ich würde mir erstmal eine Grundklasse: TSudoko schreiben und wenn ich mehrere brauche würde ich diese einer TObjectList speichern!
ausblenden volle Höhe Delphi-Quelltext
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:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
unit tdSudoko;

interface
type
  TSudokoLine = array[0..8] of Integer;
  TSudokoArray = array[0..8] of TSudokoLine;

TCustomSudoko = class
  constructor Create;
  destructor Destroy; override;
  private
    FData: TSudokoArray;
    function GetData(const Ax, Ay: Integer): Integer;
    procedure SetData(const Ax, Ay, Value: Integer);
  protected
    property Data[const Ax,Ay: Integer]: Integer read GetData write SetData;
  public
    procedure Clear;
    function Zeile(const ANum: Integer): TSudokoLine;
    function Spalte(const ANum: Integer): TSudokoLine;
    function Quadrant(const ANum: Integer): TSudokoLine;
    function CheckZeile(const ANum: Integer): Boolean;
    function CheckSpalte(const ANum: Integer): Boolean;
    function CheckQuadrant(const ANum: Integer): Boolean;
end;

TSudoko = class(TCustomSudoko)
  public
end;

implementation

{---------------}
{ TCustomSudoko }
{---------------}
procedure TCustomSudoko.Clear;
var
  X,Y: Integer;
begin
  for Y := 0 to 8 do
    for X := 0 to 8 do
      FData[X,Y] := 0;
end;

constructor TCustomSudoko.Create;
begin
  inherited Create;
  Clear;
end;

destructor TCustomSudoko.Destroy;
begin
  inherited;
end;

function TCustomSudoko.GetData(const Ax, Ay: Integer): Integer;
begin
  Result := FData[Ax,Ay];
end;

procedure TCustomSudoko.SetData(const Ax, Ay, Value: Integer);
begin
  FData[Ax,Ay] := Value;
end;

end.

_________________
Die F1-Taste steht nicht unter Naturschutz und darf somit regelmäßig und oft benutzt werden! oder Wer lesen kann, ist klar im Vorteil!
Christian V. Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 311

Win Xp Prof
Turbo Delphi 2005
BeitragVerfasst: Do 19.04.07 08:27 
Danke für deine Idee zum umgehen des Dynamischen Array Problems Kroko, ich werde dies heute mal ausprobieren.

Aber noch zu meiner ursprünglichen Frage: Ich würde doch zu gerne wissen, was da falsch läuft. Das mit den Dynmaischen Arrays müsste ja schon irgendwie funktionieren können, sonst würde Delphi das ja uch nicht unterstützen, oder?

_________________
Hardware runs the world, software controls the hardware, code generates software - Have You already coded today?
Kroko
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 1284

W98 W2k WXP
Turbo D
BeitragVerfasst: Do 19.04.07 08:35 
na klar funktioniert es, aber irgendwo ist ein Index-Fehler, du müsstes das Problem auf ein Array eingrenzen, also bis auf eins den Rest ausklammern und dann langsam Array für Array dazuschalten, viel Arbeit, daher mein Tipp: Neu anfangen. bei deiner komisches Indizierung wird dazu ein riesen Berg an Arbeit.

_________________
Die F1-Taste steht nicht unter Naturschutz und darf somit regelmäßig und oft benutzt werden! oder Wer lesen kann, ist klar im Vorteil!