Sudoku-Enträtseler arbeitet nicht ordentlich (probiert ihn mal aus)-riesen Problem



  • 003 502 900
     060 000 040
     910 000 082
    
     001 865 700
     000 000 000
     008 924 100
    
     780 000 013
     090 000 050
     005 307 400
    
    int main()
    {
        OrdneZeilen();OrdneQuadrate();OrdneSpalten();
        ResetZahlen();
        ZeigeZahlen();
        ZahlenEingeben();
        FillRaster();
    
        ZeigeZahlen();
    
        return 0;
    }
    

    nachdem ich alles eingegeben habe, sollte er eigentlich für die Nullen Zufallszahlen einsetzen und dies solange wiederholen bis keine gleichen Zahlen in den Quadraten,Zeilen und/oder Spalten sind.



  • hier der überarbeitete Code

    #include <iostream>
    #include <ctime>
    #include "ic.h"
    using namespace std;
    
    int zahlen[81];
    int quadrat[9][9];
    int zeilen[9][9];
    int spalten[9][9];
    int ablage[81];
    
    void FillRaster();
    void Nochmal();
    int ArrMinIndex(int *arr,int ugrenze,int ogrenze)
    {
    	int min_index = ugrenze;
    	for(int i =ugrenze+1; i<=ogrenze;i++)
    	{
    		if(arr[i] < arr[min_index])
    		{
    			min_index = i;
    		}
    	}
    	return min_index;
    }
    
    void sortiereArr(int *arr,int elemente)
    {
    	int ablage;
    	for(int i=0;i<elemente;i++)
    	{
    		ablage = arr[ArrMinIndex(arr, i, elemente -1)];
    		arr[ArrMinIndex(arr,i,elemente -1)]= arr[i];
    		arr[i] = ablage;
    	}
    }
    
    int doppelte(int *arr, int elemente)
    {
    	sortiereArr(arr,elemente);
    	for (int i= 0; i<elemente - 1; i++)
    	{
    		if (arr[i] == arr[i+1])
    			return 1;
    	}
    	return 0;
    }
    
    void ResetZahlen()
    {
    	for (int i= 0; i<81;i++)
    	{
    		zahlen[i]=0;
    
    	}
    }
    void RasterFullen()
    {
    	for (int i=0;i<81;i++)
    	{
    		zahlen[i]=i;
    	}
    }
    void ZeigeZahlen()
    {
    	system("cls");
    	for (int i=0;i<81;i++)
    	{
    		if(i%9==0)
    			cout<<endl;
    		if(i%27==0)
    			cout<<endl;
    		if (i%3==0)
    			cout<<" ";
    		cout<<zahlen[i];
    	}
    }
    void OrdneQuadrate()
    {
    	quadrat[0][0]=zahlen[0];
    	quadrat[0][1]=zahlen[1];
    	quadrat[0][2]=zahlen[2];
    
    	quadrat[0][3]=zahlen[9];
    	quadrat[0][4]=zahlen[10];
    	quadrat[0][5]=zahlen[11];
    
    	quadrat[0][6]=zahlen[18];
    	quadrat[0][7]=zahlen[19];
    	quadrat[0][8]=zahlen[20];
    //////////////////////////////
    	quadrat[1][0]=zahlen[3];
    	quadrat[1][1]=zahlen[4];
    	quadrat[1][2]=zahlen[5];
    
    	quadrat[1][3]=zahlen[12];
    	quadrat[1][4]=zahlen[13];
    	quadrat[1][5]=zahlen[14];
    
    	quadrat[1][6]=zahlen[21];
    	quadrat[1][7]=zahlen[22];
    	quadrat[1][8]=zahlen[23];
    //////////////////////////////
    	quadrat[2][0]=zahlen[6];
    	quadrat[2][1]=zahlen[7];
    	quadrat[2][2]=zahlen[8];
    
    	quadrat[2][3]=zahlen[15];
    	quadrat[2][4]=zahlen[16];
    	quadrat[2][5]=zahlen[17];
    
    	quadrat[2][6]=zahlen[24];
    	quadrat[2][7]=zahlen[25];
    	quadrat[2][8]=zahlen[26];
    ////////////////////////////////
    	quadrat[3][0]=zahlen[27];
    	quadrat[3][1]=zahlen[28];
    	quadrat[3][2]=zahlen[29];
    
    	quadrat[3][3]=zahlen[36];
    	quadrat[3][4]=zahlen[37];
    	quadrat[3][5]=zahlen[38];
    
    	quadrat[3][6]=zahlen[45];
    	quadrat[3][7]=zahlen[46];
    	quadrat[3][8]=zahlen[47];
    ///////////////////////////////
    	quadrat[4][0]=zahlen[30];
    	quadrat[4][1]=zahlen[31];
    	quadrat[4][2]=zahlen[32];
    
    	quadrat[4][3]=zahlen[39];
    	quadrat[4][4]=zahlen[40];
    	quadrat[4][5]=zahlen[41];
    
    	quadrat[4][6]=zahlen[48];
    	quadrat[4][7]=zahlen[49];
    	quadrat[4][8]=zahlen[50];
    /////////////////////////////////
    	quadrat[5][0]=zahlen[33];
    	quadrat[5][1]=zahlen[34];
    	quadrat[5][2]=zahlen[35];
    
    	quadrat[5][3]=zahlen[42];
    	quadrat[5][4]=zahlen[43];
    	quadrat[5][5]=zahlen[44];
    
    	quadrat[5][6]=zahlen[51];
    	quadrat[5][7]=zahlen[52];
    	quadrat[5][8]=zahlen[53];
    /////////////////////////////////
    	quadrat[6][0]=zahlen[54];
    	quadrat[6][1]=zahlen[55];
    	quadrat[6][2]=zahlen[56];
    	quadrat[6][3]=zahlen[63];
    	quadrat[6][4]=zahlen[64];
    	quadrat[6][5]=zahlen[65];
    	quadrat[6][6]=zahlen[72];
    	quadrat[6][7]=zahlen[73];
    	quadrat[6][8]=zahlen[74];
    /////////////////////////////////
    	quadrat[7][0]=zahlen[57];
    	quadrat[7][0]=zahlen[58];
    	quadrat[7][0]=zahlen[59];
    
    	quadrat[7][0]=zahlen[66];
    	quadrat[7][0]=zahlen[67];
    	quadrat[7][0]=zahlen[68];
    
    	quadrat[7][0]=zahlen[75];
    	quadrat[7][0]=zahlen[76];
    	quadrat[7][0]=zahlen[77];
    //////////////////////////////////
    	quadrat[8][0]=zahlen[60];
    	quadrat[8][1]=zahlen[61];
    	quadrat[8][2]=zahlen[62];
    
    	quadrat[8][3]=zahlen[69];
    	quadrat[8][4]=zahlen[70];
    	quadrat[8][5]=zahlen[71];
    
    	quadrat[8][6]=zahlen[78];
    	quadrat[8][7]=zahlen[79];
    	quadrat[8][8]=zahlen[80];
    
    }
    
    int GleicheZahlenQuadrat()
    {
    	for(int i=0;i<9;i++)
    	{
    		if (doppelte(quadrat[i],9)==1)
    			return 1;
    	}
    	return 0;
    }
    
    void OrdneZeilen()
    {
    	int b=0;
    	for(int i= 0;i<9;i++)
    		for(int z=0;z<9;z++)
    		{
    			zeilen[i][z]=zahlen[b];
    			b++;
    		}
    }
    
    int GleicheZahlenZeile()
    {
    	for(int i=0;i<9;i++)
    	{
    		if (doppelte(zeilen[i],9)==1)
    			return 1;
    	}
    	return 0;
    }
    
    void OrdneSpalten()
    {
    	int b=0;
    	for(int i=0;i<9;i++)
    		b=i;
    		for(int z=0;z<9;z++)
    		{
    			spalten[i][z]=zahlen[b];
    			b=b+9;
    		}
    }
    
    int GleicheZahlenSpalte()
    {
    	for(int i=0;i<9;i++)
    	{
    		if (doppelte(spalten[i],9)==1)
    			return 1;
    	}
    	return 0;
    }
    
    int GleicheZahlen()
    {
    	if (GleicheZahlenQuadrat()==1)
    		return 1;
    	if (GleicheZahlenSpalte()==1)
    		return 1;
    	if (GleicheZahlenZeile()==1)
    		return 1;
    	return 0;
    }
    
    void ZahlenEingeben()
    {
    	int eingabe;
    	for (int i=0;i<81;i++)
    	{
    		cin>>eingabe;
    		ablage[i]=eingabe;
    		zahlen[i]=eingabe;
    		ZeigeZahlen();
    	}
    }
    void Nochmal()
    {
    	ResetZahlen();
    	for(int i=0;i<81;i++)
    	{
    		zahlen[i]=ablage[i];
    	}
    	FillRaster();
    }
    
    void FillRaster()
    {
    
    	for(int i=0;i<81;i++)
    	{
    		if(zahlen[i]==0)
    		{
    			zahlen[i]=(rand()%9)+1;
    			ZeigeZahlen();
    		}
    
    	}
    	if(GleicheZahlen()==1)
    		{
    			Nochmal();
    		}
    }
    
    int main()
    {
    	srand(time(NULL));
    	ResetZahlen();
    	ZeigeZahlen();
    	ZahlenEingeben();
    	OrdneZeilen();
    	OrdneQuadrate();
    	OrdneSpalten();
    	FillRaster();
    
    	ZeigeZahlen();
    
    	return 0;
    }
    


  • Du mußt die Zahlen natürlich nach jedem Ratevorgang neu in die Spalten, Zeilen und Blöcke einsortieren - sonst prüfst du immer auf den selben Werten (und noch dazu auf lauter Null-Werten von der Initialisierung), ob du doppelte Werte hast.

    PS: Es gibt bestimmt schnellere Möglichkeiten, ein Sudoku zu lösen, als per Zufall alle Möglichkeiten auszutesten 😃



  • also beim enträtseln per zufall 81 richtige - das ist wohl nicht
    ganz der richtige ansatz.
    selbst wenn das programm frei irgendeine lösung finden sollte -
    wird es wahrscheinlich auf kurz 🙂 oder lang 😞
    soll das teil frei ein sodoku entwerfen: 9er-gruppe - 8x rand die 9te
    ist dann wohl logisch oder? dann um andere 9er-gruppe erweitern.
    ich bin nicht mehr so fit in logik-rechnen, aber für die lösung
    sollte man etwa nach dem schema vorgehen, wenn die spalten, die zeilen
    oder die neuner-quadrate nur eine lösung zulassen wird dies notiert
    und dann erst die nächste zahl angehen.

    kann ja bei so einem teil nicht ganz sein das meine verrosteten grauen
    zellen schneller sind als der pc. da muss an dem programm wohl noch
    einiges getuned werden. 😉

    und: void OrdneQuadrate() läst sich wohl auch noch optimieren.

    mfg f.-th.



  • ...das Programm doch eher etwas länger brauchen wird, wieviele möglichkeiten es gibt kannst du dir ja selber ausrechnen:

    51 Zahlen werden in 51 Kästchen verteilt, das heißt es gibt genau 51! ~= 1,551 x 10^66 Möglichkeiten die Zahlen zu verteilen...

    Ich würde mal sagen, die Wahrscheinlichkeit, dass du in deinem Leben das Ergebnis noch mitbekommst, ist äußerst gering... 🙄



  • ok. ich gebe das projekt jetzt auf. wenn ihr wollt könnt ihr den Sudoku-Enträtseler noch tunen und von mir aus auch an Microsoft verkaufen. Ich möchte aber mindestens 10% Gewinnbeteiligung für die Ursprungsidee. Die ist doch genial. Stellt euch vor ihr könnt bei einem Sudoku-Gewinnspiel 99 Millionen gweinnen. Da müsst ihr nicht stundenlang rätseln, sondern einfach den Pc anschalten, Programm starten, 3 Jahre warten und dann steht den Millionen nichts mehr im weg. Gruß, Leon++!



  • nicht 51 sondern 9 x 9 = 81 felder!
    nach 5 soduko brauch ich für leichte per graue zellen keine 1/4 stunde:
    für meiner ansicht nach nicht brauchbaren ansatz willst du prozente -
    dann biet ihn bei ebay an - da gibts vielleicht noch mehr. 😉

    mfg f.-th.

    p.s. wer so schnell aufgibt für den ist programmieren eh nicht der
    richtige sport.
    faustzahl für profis (nach höhrensagen) 20 brauchbare codezeilen pro tag.



  • f.-th. schrieb:

    faustzahl für profis (nach höhrensagen) 20 brauchbare codezeilen pro tag.

    Nach meinem hören-sagen waren es 5 (fünf)...



  • *g* drei Jahre ist aber eine seh optimistische Schätzung. Und ehe ich versuche, dieses Programm zu "tunen", bastel' ich mir lieber ein intelligenteres Verfahren, um einen Sudoku zu lösen (am günstigsten ist es, iterativ nach "sicheren" Positionen zu suchen).



  • na dann mach mal!



  • ich bin übrigens C++-Einsteiger, gerade mal 14 Jahre alt und habe deshalb nicht Zeit 20 Zeilen Code am Tag zu schreiben. Außerdem kotzt mich die scheiß Konsole an (deshalb die mangelnde Motivation). Ich habe versucht auf die WINAPI umzusteigen (zu schwer) und scheiterte ausserdem auch an wxWidgets (krieg ich nicht installed). Mein Vater erlaubt mir zudem auch nur 10 Std. Internet im Monat(obwohl ich die Kosten trage) und DSL (und Flatrate) ist bei mir nicht verfügbar(Glasfaser). Dies führt dazu, dass ich nicht wie andere Programmers stundenlang in der MSDN herumsurfen kann.

    Ende, mfg, ****.



  • Ich empfehle Dir fang mit C# Express an, da kannst Du graphische Oberflächen sehr einfach und schön machen...



  • C# Express? Was ist das für ein Buch? C# ist doch was anderes als C++.



  • f.-th. schrieb:

    nicht 51 sondern 9 x 9 = 81 felder!
    nach 5 soduko brauch ich für leichte per graue zellen keine 1/4 stunde:
    für meiner ansicht nach nicht brauchbaren ansatz willst du prozente -
    dann biet ihn bei ebay an - da gibts vielleicht noch mehr. 😉

    mfg f.-th.

    p.s. wer so schnell aufgibt für den ist programmieren eh nicht der
    richtige sport.
    faustzahl für profis (nach höhrensagen) 20 brauchbare codezeilen pro tag.

    Falls du es nicht bemerkt haben solltest, 30 Zahlen stehen da schon drin... 😉



  • und das berücksichigt sein programm ja nicht oder?

    mfg f.-th.



  • f.-th. schrieb:

    und das berücksichigt sein programm ja nicht oder?

    mfg f.-th.

    doch das tut es es werden nur zufallszahlen bei feldern mit dem wert 0 generiet.



  • ich glaube die linux-spezies haben quelltexte zu dem thema. ich weis
    allerdings nicht in welche programmiersprache, hab da irgendwas mit
    gnome und kde in erinnerung.

    mfg f.-th.



  • hab jetzt nach ner langen weile mal wieder vorbeigeschaut. Was ist nun draus geworden. Hat irgendeiner hier mal einen anderen sudokuenträtseler gebaut?

    hab jetzt übrigens flatrate, welche ich mir per wlan von einem freifunknetz in berlin hole. Und das beste: mein Vater kriegt nichts davon ab. 😋 Haha. Ausserdem bin ich jetzt 15!





  • is leider python. da kenn ich mich nicht aus.


Anmelden zum Antworten