Sudoku

[seth]

gudn tach Jürgen!

Vieleicht verstehe ich deinen Ansatz auch nicht, aber er kommt mir recht kompliziert vor.

ist nicht kompliziert.

Zum Überprüfen musst du doch nur wissen, zu welcher Spalte, zu welcher Zeile und zu welchem Block das Feld gehört. Zeile und Spalte sind klar:

f(z,s) -> f(z,i), i=0...8 bzw. f(i,s), i=0...8

ja. (habe ich ebenso gemeint)

Beim Block ist es nur etwas komplizierter:

ja, zunaechst hat man da mal verschiedene moeglichkeiten der indizierung.
z.b. in dem von mir genannten 4d-array [0,...,2]^4 koennte man eine transformation wie folgt angeben:
[0,...,8]^2     -> [0,...,2]^4
(zeile, spalte) -> (zeilenstreifen, spaltenstreifen, zeile im subquadrat, spalte im subquadrat)
(x,y)->(a,b,c,d)
mit
a=x/3   \ diese beiden groessen legen
b=y/3   / das subquadrat fest
c=x%3   \ d=y%3   / und die beiden das element innerhalb des subquadrates,

wobei mit "streifen" jeweils die breite eines subquadrates gemeint ist. man hat also ein grobes und ein feines raster.
"/" bezeichne wieder die ganzzahlige division.

die umkehrabbildung waere ebenfalls sehr unkompliziert:
(a,b,c,d)->(x,y)
x=3*a+c
y=3*b+d

aaaber: das ist langweilig.

is=Math.floor(z/3)*3;ie=is+3;
js=Math.floor(s/3)*3;je=js+3;

f(z,s) -> f(i,j), i=is...ie und j=js...je;

Aber vieleicht meinen wir ja das selbe.

hmm, weiss nicht.
da z ja eine zahl von 0 bis 8 ist, ist somit
is=Math.floor(z/3)*3 eine zahl von 0 bis 2
ie=is+3 ist folglich eine zahl von 3 bis 5

f(z,s) -> f(i,j), i=is...ie und j=js...je;

hier laufen i und j jeweils von 0 bis 3 (oder 2 bis 4 oder 3 bis 5)
was fuer mich so aussieht, als wuerden manche elemente nie getroffen? wie nummerierst du die subquadrate?

naja, ich finde an der von mir beschrieben ueberfuehrungsfunktion so toll, dass die umgekehrte rechnung, also die ueberfuehrung von "subquadratischen" koordinaten in die gewoehnliche zeilen-spalten-koordinaten, auf genau die gleiche weise erfolgt.

am beispiel wird's vielleicht klarer:

  
// die folgende funktion dient nur der umrechnung zeilen-spalten nach subquadratischen koordinaten _und_ auch zurueck!  
// slen=3 ist die laenge eines subquadrates  
function subquadr_umrechnung($x, $y, $slen){  
  return array($slen*floor($x/$slen)+$y/$slen, $slen*($x%$slen)+$y%$slen);  
}  
  
// die folgende funktion ueberprueft nur, ob eine uebergebene zelle mit dem uebergebenen wert gefuellt werden darf.  
// $feld ist ein 2d-array.  
// die zu checkende zelle ist $feld[$zeile][$spalte]  
function wert_zulaessig_in_zelle($feld, $zeile, $spalte, $wert){  
  $zulaessig=1;                          // initialisiere die zelle erstmal als zulaessig  
  $feldlaenge=count($feld);              // also ... = 9  
  $subqulaenge=round(sqrt($feldlaenge)); // = 3 die breite eines subwuadrates  
    // konvertierung von zeilen,spalten nach subquadratischen koordinaten (ist selbstinvers)  
  $subqu=subquadr_umrechnung($zeile, $spalte, $subqulaenge);  
    // schleife ueber alle zellen in zeile/spalte/subquadrat, die schon besetzt sind  
  for($i=0; $i<$feldlaenge && $zulaessig; ++$i){  
    if($zulaessig && $i<$spalte) $zulaessig=$feld[$zeile][$i]!=$wert;  // zeilenkriterium  
    if($zulaessig && $i<$zeile)  $zulaessig=$feld[$i][$spalte]!=$wert; // spaltenkriterium  
    if($zulaessig && $i<$subqu[1]){                                    // subquadrate-kriterium  
        // konvertierung von subquadratischen koordinaten nach zeilen,spalten (involution, s.o.)  
      $temp=subquadr_umrechnung($subqu[0], $i, $subqulaenge);  
      $zulaessig=$feld[$temp[0]][$temp[1]]!=$wert;  
    }  
  }  
  return $zulaessig;  
}

prost
seth