Scripts in Firefox langsamer als im IE?

[twb]

Liebe alle - mein in DHTML gehaltenes Sudoku erweist sich hinsichtlich seines Skripts als Fass ohne Boden. Alles läuft, nur benötigt das zufallsbasierte Errechnen eines _echten neuen_ Sudokus reichlich Zeit.

Beim Rechnen wird nun die Toleranzzeit des Firefox überschritten - nach ca. 3 Sekunden meldet er "Ein Skript auf dieser Seite ist eventuell beschäftigt oder antwortet nicht mehr". Das Skript hängt aber nicht in einer Endlosschlaufe, sondern braucht einfach mehr Zeit. Der MSIE dagegen arbeitet das Skript ohne Fehlermeldung ab, und dazu benötigt er erst noch _viel_ weniger Zeit. Daher meine Frage: Ist es möglich, dass rechnerisch aufwändige Skripte im MSIE um soviel rascher verarbeitet werden? Warum?

Ihr könnt das im übrigen gern selbst ausprobieren - aber _achtung_: Das Skript wird Euren Browser ordentlich beschäftigen; der Firefox wird den genannten Fehler auswerfen; der MSIE dagegen rechnet durch. Das Spiel ist hier, das Skript ist hier.

Herzlich, T.

[derletztekick]

Hallo twb,

hier war vor kurzem erst ein Thread, in dem einer/eine dies anhand eines Beispiels bereits zeigte. Im Verlauf dieses Themas wurde gesagt, dass dies beim "DOM-Scripting" nicht so sei...

Btw: ich habs im Opera getestet, es geht recht fix.

Mit freundlichem Gruß
Micha

[twb]

Hallo Micha - ein erhellender Thread, den ich übersehen habe. Danke! DOM-Scripting mag im FF überaus flink vonstatten gehen, no objections von meiner Seite. In meinem Script dagegen werden neue, einmalige und zufällige Sudokus gerechnet; zu Buche schlägt dabei vor allem mein Zufallsgenerator

for (i=0;i<n;i++)
{
random=parseInt(Math.random()*(i+1));
randomnum[i]=randomnum[random];
randomnum[random]=i;
}

und die Rekursivität. Und da schlägt der MSIE den FF offensichtlich um Längen. (Aus diesem Grund habe ich mein mathematisch spannendes Script nur hier hingestellt und nicht publiziert; wirklich publikumstauglich ist es nämlich mitnichten. Mein wirklich spielbares Sudoku ist zwar viel weniger elegant, dafür aber wesentlich schneller.

Btw: ich habs im Opera getestet, es geht recht fix.

Das, lieber Micha, hilft mir weiter. Nochmal Danke!

[JürgenB]

Hallo twb,

for (i=0;i<n;i++)
{
random=parseInt(Math.random()*(i+1));
randomnum[i]=randomnum[random];
randomnum[random]=i;
}

zwei Bemerkungen:
Was soll das parseInt machen? Wenn du nur runden willst, nimm math.round.

while-Schleifen sind etwas schneller als for schleifen und noch schneller, wenn sie runter laufen:

for (i=0;i<n;i++) ->

i=n;
do {
i--;
...
} while(i);

so entfällt der Vergleich.

Gruß, Jürgen

[twb]

Hallo Jürgen

Was soll das parseInt machen? Wenn du nur runden willst, nimm math.round.

Ich will ausdrücklich _nicht_ runden, sondern die erste Nachkommastelle als ganzzahligen Wert haben.

while-Schleifen sind etwas schneller als for schleifen und noch schneller, wenn sie runter laufen:

Wer'd ich ausprobieren. Danke!

[derletztekick]

Hallo twb,

In meinem Script dagegen werden neue, einmalige und zufällige Sudokus gerechnet...

Ich habe mal fix bei Wikipedia geschaut und empfand den letzten genannten Algorithmus als /einfach/ umsetzbar. Matrizenrechnung musst Du dabei auch nicht unbedingt mehr können, da es in SELFHTML bereits eine Bibliothek gibt, die Dir das abnehmen kann. Das soll Dich natürlich nicht am selbstprogrammieren abhalten ;-)

Mit freundlichem Gruß
Micha

[JürgenB]

Hallo derletztekick,

Ich habe mal fix bei Wikipedia geschaut und empfand den letzten genannten Algorithmus als /einfach/ umsetzbar.

einfach umsetzbar stimmt, leider sind die Sudokus auch leicht durchschaubar. Den "Schiebealgorithmus" mit anschließendem Vertauschen von Zeilen, Spalten und Blöcken biete ich zwar als schnellen Algorithmus an, gut ist er aber nicht. Lediglich beim 16er Sudoku ist mein Zufallsalgorithmus viel zu langsam, daher hier nur der Schiebealgorithmus.

http://www.j-berkemeier.de/Sudoku.html

Gruß, Jürgen

[derletztekick]

Hallo JürgenB und twb,

Dass das Schieben allein nicht reicht, steht dort ja auch. Aber wenn man die Art und die Reihenfolge der Veränderungen zufällig gestaltet:

"deswegen sollte man über erlaubte Transformationen diese Matrix nun schrittweise so verändern, dass die Ursprungsziffernfolge sowie die ausgeführten Transformationen nicht mehr nachvollziehbar sind. Erlaubte Transformationen sind z. B. das Invertieren, das Spiegeln (vertikal, horizontal, schräg), Rotieren, Vertauschen ganzer Zeilen oder Spalten..."

sollte es doch schon recht schwer sein, durchschaut zu werden, oder? Ich habe es nicht weiter probiert - vll tu ich das nun mal? - um es genau abzuschätzen.

Was mich jedoch verwundert ist, das invertieren erlaubt sein soll. Eine 2x2 Matrix:

A = 4  5
    9  8

ergibt: A^-1 =

-0,615   0,385
 0,692  -0,307

welchen Nutzen hätte das Invertieren hier?

Mit freundlichem Gruß
Micha

[JürgenB]

Hallo derletztekick,

"deswegen sollte man über erlaubte Transformationen diese Matrix nun schrittweise so verändern, dass die Ursprungsziffernfolge sowie die ausgeführten Transformationen nicht mehr nachvollziehbar sind. Erlaubte Transformationen sind z. B. das Invertieren, das Spiegeln (vertikal, horizontal, schräg), Rotieren, Vertauschen ganzer Zeilen oder Spalten..."

mache ich natürlich.

sollte es doch schon recht schwer sein, durchschaut zu werden, oder? Ich habe es nicht weiter probiert - vll tu ich das nun mal? - um es genau abzuschätzen.

Vieleicht kenne ich meinen Algorithmus auch nur zu gut.

Was mich jedoch verwundert ist, das invertieren erlaubt sein soll.

Da bin ich auch hängen geblieben. Ich glaube, der Autor hat invertieren mit transponieren verwechselt.

Gruß, Jürgen

[derletztekick]

Hallo JürgenB,

"deswegen sollte man [...] diese Matrix [...] verändern..."
mache ich natürlich.

Ich habe nichts anderes erwartet ;-)

Vieleicht kenne ich meinen Algorithmus auch nur zu gut.

Das möchte ich nicht bestreiten, dennoch fällt es mir schwer, dies ausreichend abzuschätzen - gerade auch, weil ich das Spiel nicht spiele - was durchschaubar ist und was nicht. Ich möchte Dir in diesem Punkt also werder wiedersprechen noch zustimmen.

Ich glaube, der Autor hat invertieren mit transponieren verwechselt.

Ja, das würde zumindest einen Sinn ergeben.

Mit freundlichem Gruß
Micha

[derletztekick]

Hallo JürgenB,

Vieleicht kenne ich meinen Algorithmus auch nur zu gut.

Ich habe es heute probiert und musste feststellen, dass es wirklich einfach zu durchschauen ist:

2  5  3   1  9  8   7  6  4
6  7  4   3  5  2   9  8  1
8  9  1   4  7  6   5  2  3

Nimmt man sich die ersten drei Ziffern des ersten Blocks: 2,5,3 so tauchen diese in den beiden anderen Blöcken (durch Zufall ändern sich die Reihenfolge ab und an) ebenfalls auf. Das passiert natürlich nicht nur Reihenweise sondern auch Spaltenweise. Hat mal also eine 3er Reihe gelöst, so ist klar, das bei bspw. einer 5 nur noch 2 und 3 in Frage kommen.

Mit freundlichem Gruß
Micha

[derletztekick]

Hallo JürgenB,

ich habe mich am WE nun auch mal hingesetzt und den ersten, auf Wikipedia beschriebenen, Weg verfolgt. Rausgekomme ist eine - zu meinen Erstaunen - recht fixe Lösung des SUDOKU Spiels.

Ich hoffe es sieht nicht zu konfus aus, da ich, nachdem ich Mathias seinen Artikel gelesen hatte, alles noch mal umgestellt habe. Ob ich da nun wirklich alle seine Anregungen 100% verstanden habe, bezweifle ich fast ein wenig ;-) Egal, es läuft zumindest.

Lediglich beim 16er Sudoku ist mein Zufallsalgorithmus viel zu langsam, daher hier nur der Schiebealgorithmus.

Das habe ich auch einmal probiert. Es dauert schon eine ganze Ecke, bis er das Ding genackt hat. Deshalb bei "nur" die klassische Variante 9x9.

Festgestellt habe ich auch, das Firefox recht langsam ist. Opera und IE sind beim berechnen des Spiels an sich (also keine graphischen Sachen wie Tabellen erstellen usw.) deutlich schneller.

Mit freundlichem Gruß
Micha

[twb]

Hallo twb,

In meinem Script dagegen werden neue, einmalige und zufällige Sudokus gerechnet...

Ich habe mal fix bei Wikipedia geschaut und empfand den letzten genannten Algorithmus als /einfach/ umsetzbar.

Tja, Micha: Ich auch. Und daher steht mein langsames Skript nur versteckt im Netz; die öffentliche Version basiert genau auf dem, was Du in der Wikipedia gefunden hast. :-)

[JürgenB]

Hallo twb,

dein Bemühen um ein echtes Zufallssudoku erinnert mich sehr an meine Bemühungen zum gleichen Problem. Meine erste Version brauchte ca. eine Minute zum Berechnen eines Sudokus. Natürlich bekam auch ich die Warnung vom FF über das zu lange laufende Script. Aber wenn du lange genug über das Problem nachdenkst, wird es dir gelingen, ein Sudoku in ca. 1 Sekunde zu berechnen.

Zu deiner Frage: nach meiner Erfahrung rechnet der FF nicht langsamer als der IE. Lediglich beim dynamischen Erzeugen von einigen tausend Elementen (z.B. divs) ist der IE dem FF überlegen.

Die Meldung des FF kannst du übrigens umgehen, indem Du rechenintensive Schleifen in ein Konstrukt mit setTimeout umwandelst. Ich mache es so, dass ich nach 0.1 s bis 1 s, je nach Problem, die Rechnung anhalte und dann mit setTimeout nach einer Millisekunde weiterlaufen lasse.

Gruß, Jürgen

[twb]

Hallo Jürgen!

dein Bemühen um ein echtes Zufallssudoku erinnert mich sehr an meine Bemühungen zum gleichen Problem. Meine erste Version brauchte ca. eine Minute zum Berechnen eines Sudokus.

Da bin ich auf meine 2-3 Sekunden im MSIE schon direkt stolz. :-) Nein, im Ernst: Erstens gibt es noch einige Möglichkeiten, die Rechnerei in meinem Skript zu beschleunigen. Und zweitens ist Skripting für rechenintensive Aufgaben grundsätzlich wenig geeignet, weil jeder kompilierten Anwendung unterlegen.

Die Meldung des FF kannst du übrigens umgehen, indem Du rechenintensive Schleifen in ein Konstrukt mit setTimeout umwandelst.

Hab Dank für den Tipp! Aber ich denke, ich arbeite lieber an der Rekursivität meiner Berechnung weiter, um die Rechenzeit klar unter die Toleranzzeit des FF zu drücken. Alles andere bliebe letztlich immer eine Zumutung für die User.

Herzlich, twb

[Struppi]

Liebe alle - mein in DHTML gehaltenes Sudoku erweist sich hinsichtlich seines Skripts als Fass ohne Boden. Alles läuft, nur benötigt das zufallsbasierte Errechnen eines _echten neuen_ Sudokus reichlich Zeit.

ich würd ja gerne helfen, aber dein Programmierstil ist wirklich grauenhaft und macht deinen Quellcode sehr unleserlich.

Ein paar Bytes für Zeilenumbrüche oder Variabelnamen sparen war zwar früher beim C64 durchaus wichtig, aber heutzutage wirst du damit wenn überhaupt nur wenige Milliprozent hat Geschwindigkeit rausholen, aber vermutlich eher gar nichts, da lediglich während der Übersetzungsphase dies eine Rolle spielt und die dürfte bei JS in dieser Größe bei wenigen Millisekunden liegen.

Ich vermute aber in dem Skript viele stellen die sich optimieren liessen, diese riesigen if() Bedingungen können garantiert besser umgesetzt werden. Oder auch wenn Variabelnamen auftauchen wie, col1 col2 col3 .. deuten das schwer daraufhin, dass hier Arrays sinnvoller wären.

Struppi.

[twb]

ich würd ja gerne helfen, aber dein Programmierstil ist wirklich grauenhaft und macht deinen Quellcode sehr unleserlich.

Stattgegeben. Ich hab' auch nie behauptet, wirklich programmieren zu können - ich bin tatsächlich alles andere als ein Programmierer. Ich bin's lediglich zufrieden, dass sowas oder sowas reibungslos funktioniert. Meine Frage galt auch keiner Sequenz aus meinem Skript, sondern lediglich der Frage, ob es möglich sei, dass verschiedene Browser unterschiedlich lange brauchen, umfangreiche Skripte abzuarbeiten. Ist mittlerweile auch beantwortet.

Ich vermute aber in dem Skript viele stellen die sich optimieren liessen, diese riesigen if() Bedingungen können garantiert besser umgesetzt werden. Oder auch wenn Variabelnamen auftauchen wie, col1 col2 col3 .. deuten das schwer daraufhin, dass hier Arrays sinnvoller wären.

Öhm, das _sind_ Arrays...

Trotzdem herzlich, twb

[Struppi]

Ich vermute aber in dem Skript viele stellen die sich optimieren liessen, diese riesigen if() Bedingungen können garantiert besser umgesetzt werden. Oder auch wenn Variabelnamen auftauchen wie, col1 col2 col3 .. deuten das schwer daraufhin, dass hier Arrays sinnvoller wären.
Öhm, das _sind_ Arrays...

Ja die einzelnen Werte, aber col sollte hier ein Array sein.

Struppi.

[Struppi]

.... Meine Frage galt auch keiner Sequenz aus meinem Skript, sondern lediglich der Frage, ob es möglich sei, dass verschiedene Browser unterschiedlich lange brauchen, umfangreiche Skripte abzuarbeiten. Ist mittlerweile auch beantwortet.

Trotzallem, sollte deine Ursachenforschung tiefer gehen. Jeder Browser hat seine Spezialitäten und ist in anderen Dingen langsamer als der Rest. Aber dein Code erweckt schon so den Eindruck der ineffizenz, dass das von dir beobachteten Verhalten evtl. auch daran liegen kann.

Öhm, das _sind_ Arrays...

Ich kann das Spiel zwar nicht und weiß daher nicht was du im einzelnen passieren soll, aber ich hab das mal umgebaut.

Die grundlegende Änderung ist deine Funktion setarray()

  
function setarray()  
{  
    rows = [  
    [ num[0],num[1],num[2],num[3],num[4],num[5],num[6],num[7],num[8] ],  
    [ num[9],num[10],num[11],num[12],num[13],num[14],num[15],num[16],num[17] ],  
    [ num[18],num[19],num[20],num[21],num[22],num[23],num[24],num[25],num[26] ],  
    [ num[27],num[28],num[29],num[30],num[31],num[32],num[33],num[34],num[35] ],  
    [ num[36],num[37],num[38],num[39],num[40],num[41],num[42],num[43],num[44] ],  
    [ num[45],num[46],num[47],num[48],num[49],num[50],num[51],num[52],num[53] ],  
    [ num[54],num[55],num[56],num[57],num[58],num[59],num[60],num[61],num[62] ],  
    [ num[63],num[64],num[65],num[66],num[67],num[68],num[69],num[70],num[71] ],  
    [ num[72],num[73],num[74],num[75],num[76],num[77],num[78],num[79],num[80] ]  
    ];  
  
    cols = [  
    [ num[0],num[9],num[18],num[27],num[36],num[45],num[54],num[63],num[72] ],  
    [ num[1],num[10],num[19],num[28],num[37],num[46],num[55],num[64],num[73] ],  
    [ num[2],num[11],num[20],num[29],num[38],num[47],num[56],num[65],num[74] ],  
    [ num[3],num[12],num[21],num[30],num[39],num[48],num[57],num[66],num[75] ],  
    [ num[4],num[13],num[22],num[31],num[40],num[49],num[58],num[67],num[76] ],  
    [ num[5],num[14],num[23],num[32],num[41],num[50],num[59],num[68],num[77] ],  
    [ num[6],num[15],num[24],num[33],num[42],num[51],num[60],num[69],num[78] ],  
    [ num[7],num[16],num[25],num[34],num[43],num[52],num[61],num[70],num[79] ],  
    [ num[8],num[17],num[26],num[35],num[44],num[53],num[62],num[71],num[80] ]  
    ];  
  
    blks = [  
    [ num[0],num[1],num[2],num[9],num[10],num[11],num[18],num[19],num[20] ],  
    [ num[3],num[4],num[5],num[12],num[13],num[14],num[21],num[22],num[23] ],  
    [ num[6],num[7],num[8],num[15],num[16],num[17],num[24],num[25],num[26] ],  
    [ num[27],num[28],num[29],num[36],num[37],num[38],num[45],num[46],num[47] ],  
    [ num[30],num[31],num[32],num[39],num[40],num[41],num[48],num[49],num[50] ],  
    [ num[33],num[34],num[35],num[42],num[43],num[44],num[51],num[52],num[53] ],  
    [ num[54],num[55],num[56],num[63],num[64],num[65],num[72],num[73],num[74] ],  
    [ num[57],num[58],num[59],num[66],num[67],num[68],num[75],num[76],num[77] ],  
    [ num[60],num[61],num[62],num[69],num[70],num[71],num[78],num[79],num[80] ]  
    ];  
}  

sieht schonmal besser aus als vorher.

Jetzt hast du ja diese Grauenhaften Abfragen
if( row1.indexOf(11) != 1 || row1.indexOf(22) != 1 || ... usw. usf.

oder auch
if( row1.length > maxnum  || row1.length < minnum ....

Diese habe ich mal umgesetzt als Protoype Funktionen für Arrays:

  
// Funktionen für die Arrays of Arrays  
  
// has_joins verknüpft die Einträge der Arrays  
// sortiert miteinander,  
// das muss aber nur einmal gemacht werden  
Array.prototype.has_joins = function()  
{  
    if(!this.joins)  
    {  
         this.joins = [];  
         for(var i = 0; i < this.length; i++)  
         this.joins[i] = this[i].sort().join('');  
    }  
};  
// find_one prüft ob ein Element des array el  
// in einem Array von this vorhanden ist  
Array.prototype.find_one = function(el)  
{  
    this.has_joins();  
    for(var i = 0; i < el.length; i++)  
         for(var j = 0; j < this.length; j++)  
             if( this.joins[j].indexOf( el[i] ) > -1) return true;  
    return false;  
};  
// min_max prüft die Anzahl der einträge in den Arrays  
// kleiner als may und größer als min sind  
Array.prototype.min_max = function(min, max)  
{  
    this.has_joins();  
    for(var i = 0; i < this.length; i++)  
    {  
        if( this.joins[i].length > max || this.joins[i].length < min) return true;  
    }  
    return false;  
};  

Dann stehen 2 neue Funktionen zu Verfügung, die die Arrays of Arrays (AoA) benutzen können.
Einmal find_one( Array ) und min_max(min, max), diese übernehmen deine ellenlangen if(....) Konstrukte.

Und da du immer nach den gleichen Werten suchst 11,22,33,44,.... hab ich hier noch ein globales Array eingeführt (find_array)

deine Funktionen calulate() und reject() sehen dann so aus:

  
var find_array = [11, 22, 33, 44, 55, 66, 77, 88, 99];  
...  
  
function calculate()  
{  
    for (i=0;i<n;i++)  
    {  
         num[i] = parseInt(Math.random()*10);  
         td[i] = "<input type=\"text\" maxLength=\"1\" value=\""+num[i]+"\" readonly>";  
         setarray();  
         if (  
         rows.find_one( find_array ) ||  
         cols.find_one( find_array ) ||  
         blks.find_one( find_array ) ||  
         num[i] == 0  
         )  
         i--;  
         }  
}  
function reject()  
{  
    setarray();  
    if (  
    rows.min_max(minnum, maxnum) ||  
    cols.min_max(minnum, maxnum) ||  
    blks.min_max(minnum, maxnum)  
    )  
    {  
    setup();  
    }  
    else  
    {  
    message="Level: "+msglevel[0];  
    show();  
    }  
}  

Das hat bei mir zumindest schon die Geschwindigkeit erheblich verbessert, aber ich muss dazu sagen, da ich das Spiel ja nicht kann, dass ich nicht 100% sicher bion, da ich es nicht testen konnte, ob dann immer noch alles so passiert wie es sollte.

Struppi.

[twb]

Trotzallem, sollte deine Ursachenforschung tiefer gehen.

Stattgegeben. Ich bin im übrigen, trotz meinem fehlenden Programmierkönnen, nicht dafür bekannt, mich mit halben Dingen zufriedenzugeben. Du im übrigen auch nicht, wie Dein Posting zeigt - das ist echt der Hammer. Hab Dank!

sieht schonmal besser aus als vorher.

Und wie.

Dann stehen 2 neue Funktionen zu Verfügung, die die Arrays of Arrays (AoA) benutzen können.

Für mich Neuland - ich habe Arrays noch nie in Arrays gebündelt. Dass das hier jedoch absolut auf der Hand liegt, ist mir klar. Und Funktions-Prototyping hab' ich bisher auch nicht gekannt. Einleuchtend.

Das hat bei mir zumindest schon die Geschwindigkeit erheblich verbessert, aber ich muss dazu sagen, da ich das Spiel ja nicht kann, dass ich nicht 100% sicher bion, da ich es nicht testen konnte, ob dann immer noch alles so passiert wie es sollte.

Einzig hier kann ich nicht folgen - die Geschwindigkeit ist bei mir nur wenig schneller geworden (1-2 Sekunden pro Spielaufbau). Aber erstens bleibt das Spiel integer - d.h. Deine Änderungen sind perfekt. Und zweitens hast Du meinen Spielcode glatt auf etwas mehr als die Hälfte gedrückt. Mit einem Wort: Ich bin begeistert. :-)

[Struppi]

sieht schonmal besser aus als vorher.
Und wie.

Na, dann bin ich zufireden ;-)

Dann stehen 2 neue Funktionen zu Verfügung, die die Arrays of Arrays (AoA) benutzen können.
Für mich Neuland - ich habe Arrays noch nie in Arrays gebündelt. Dass das hier jedoch absolut auf der Hand liegt, ist mir klar. Und Funktions-Prototyping hab' ich bisher auch nicht gekannt. Einleuchtend.

Auch schön, dass du das verstanden hast, man kann damit seinen Code wesentlich übersichtlicher gestalten (was dir eh schwer fällt ;-) )

Das hat bei mir zumindest schon die Geschwindigkeit erheblich verbessert, aber ich muss dazu sagen, da ich das Spiel ja nicht kann, dass ich nicht 100% sicher bion, da ich es nicht testen konnte, ob dann immer noch alles so passiert wie es sollte.
Einzig hier kann ich nicht folgen - die Geschwindigkeit ist bei mir nur wenig schneller geworden (1-2 Sekunden pro Spielaufbau).

ich muss zugeben, als ich das geschrieben hatte, war ich an meiner uralten Mühle (P100/ IE 4), wo das Skript einige Minuten brauchte, danach nur noch 40 Sekunden. Daher meine vielleicht etwas zu optimistische Einschätzung.

Aber erstens bleibt das Spiel integer - d.h. Deine Änderungen sind perfekt. Und zweitens hast Du meinen Spielcode glatt auf etwas mehr als die Hälfte gedrückt. Mit einem Wort: Ich bin begeistert. :-)

Da ist noch mehr drin, aber dazu müßte ich das Prinzip und diese Algorithmus (der hier ja ausführlich diskutuiert wurde) besser verstehen, aber soviel freie Zeit hab ich dann leider doch nicht.

Struppi.

[Gunnar Bittersmann]

Hello out there!

Ich bin's lediglich zufrieden, dass sowas oder sowas reibungslos funktioniert.

Nein, damit kannst du kaum zufrieden sein.

Zumindest dein Algorithmus in http://www.mah-jongg.ch/sudoku zur Erstellung eines Sudoku ist fehlerhaft; er gibt ungültige Sudokus aus. Ich erhielt bspw. dieses (evil):

  
╔═══╤═══╤═══╦═══╤═══╤═══╦═══╤═══╤═══╗  
║   │ 3 │ 5 ║   │   │   ║   │   │   ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║   │ 6 │   ║   │ 5 │   ║   │ 1 │ 2 ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║   │   │   ║   │   │ 9 ║   │   │ 3 ║  
╠═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╣  
║   │   │ 7 ║   │ 3 │   ║   │   │   ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║   │ 9 │   ║ 1 │   │ 8 ║   │ 6 │   ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║   │   │   ║   │ 7 │   ║ 3 │   │   ║  
╠═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╣  
║ 7 │   │   ║ 5 │   │   ║   │   │   ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║ 9 │ 5 │   ║   │ 1 │   ║   │ 8 │   ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║   │   │   ║   │   │   ║ 5 │ 4 │   ║  
╚═══╧═══╧═══╩═══╧═══╧═══╩═══╧═══╧═══╝  

Das wird von diser Belegung erfüllt:

  
╔═══╤═══╤═══╦═══╤═══╤═══╦═══╤═══╤═══╗  
║ 2 │ 3 │ 5 ║ 6 │ 8 │ 1 ║ 9 │ 7 │ 4 ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║ 4 │ 6 │ 9 ║ 7 │ 5 │ 3 ║ 8 │ 1 │ 2 ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║ 1 │ 7 │ 8 ║ 2 │ 4 │ 9 ║ 6 │ 5 │ 3 ║  
╠═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╣  
║ 6 │ 4 │ 7 ║ 9 │ 3 │ 5 ║ 1 │ 2 │ 8 ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║ 5 │ 9 │ 3 ║ 1 │ 2 │ 8 ║ 4 │ 6 │ 7 ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║ 8 │ 1 │ 2 ║ 4 │ 7 │ 6 ║ 3 │ 9 │ 5 ║  
╠═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╣  
║ 7 │ 8 │ 1 ║ 5 │ 6 │ 4 ║ 2 │ 3 │ 9 ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║ 9 │ 5 │ 4 ║ 3 │ 1 │ 2 ║ 7 │ 8 │ 6 ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║ 3 │ 2 │ 6 ║ 8 │ 9 │ 7 ║ 5 │ 4 │ 1 ║  
╚═══╧═══╧═══╩═══╧═══╧═══╩═══╧═══╧═══╝  

Aber auch von dieser:

  
╔═══╤═══╤═══╦═══╤═══╤═══╦═══╤═══╤═══╗  
║ 2 │ 3 │ 5 ║ 6 │ 8 │ 1 ║ 9 │ 7 │ 4 ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║ 4 │ 6 │ 9 ║ 7 │ 5 │ 3 ║ 8 │ 1 │ 2 ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║ 1 │ 7 │ 8 ║ 2 │ 4 │ 9 ║ 6 │ 5 │ 3 ║  
╠═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╣  
║ 8 │ 4 │ 7 ║ 9 │ 3 │ 6 ║ 1 │ 2 │ 5 ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║ 5 │ 9 │ 3 ║ 1 │ 2 │ 8 ║ 4 │ 6 │ 7 ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║ 6 │ 1 │ 2 ║ 4 │ 7 │ 5 ║ 3 │ 9 │ 8 ║  
╠═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╣  
║ 7 │ 8 │ 1 ║ 5 │ 6 │ 4 ║ 2 │ 3 │ 9 ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║ 9 │ 5 │ 4 ║ 3 │ 1 │ 2 ║ 7 │ 8 │ 6 ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║ 3 │ 2 │ 6 ║ 8 │ 9 │ 7 ║ 5 │ 4 │ 1 ║  
╚═══╧═══╧═══╩═══╧═══╧═══╩═══╧═══╧═══╝  

Und auch von dieser:

  
╔═══╤═══╤═══╦═══╤═══╤═══╦═══╤═══╤═══╗  
║ 2 │ 3 │ 5 ║ 6 │ 8 │ 1 ║ 9 │ 7 │ 4 ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║ 4 │ 6 │ 9 ║ 7 │ 5 │ 3 ║ 8 │ 1 │ 2 ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║ 8 │ 7 │ 1 ║ 2 │ 4 │ 9 ║ 6 │ 5 │ 3 ║  
╠═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╣  
║ 6 │ 4 │ 7 ║ 9 │ 3 │ 5 ║ 1 │ 2 │ 8 ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║ 5 │ 9 │ 3 ║ 1 │ 2 │ 8 ║ 4 │ 6 │ 7 ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║ 1 │ 8 │ 2 ║ 4 │ 7 │ 6 ║ 3 │ 9 │ 5 ║  
╠═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╣  
║ 7 │ 1 │ 8 ║ 5 │ 6 │ 4 ║ 2 │ 3 │ 9 ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║ 9 │ 5 │ 4 ║ 3 │ 1 │ 2 ║ 7 │ 8 │ 6 ║  
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢  
║ 3 │ 2 │ 6 ║ 8 │ 9 │ 7 ║ 5 │ 4 │ 1 ║  
╚═══╧═══╧═══╩═══╧═══╧═══╩═══╧═══╧═══╝  

Möglich, dass es weitere gibt.

Ein Sudoku muss aber _eindeutig_ lösbar sein!

See ya up the road,
Gunnar