Ich beschäftige mich seit einiger Zeit mit C++.
Nachdem ich Tutorials mit den Basics durchgearbeitet habe, versuche ich jetzt mehr oder weniger einfache Programme zu schreiben (z.B. Tic-Tac-Toe).

Momentan bin ich dabei ein Sudoku-Löser zu basteln.
Nachdem man die vorhanden Felder eingegeben hat, soll das Programm zuerst nach unten alle Zahlen 1 - 9 durchgehen, dann zur Seite und dann in seiner "Box". Die erste Möglichkeit soll eingesetzt werden, danach geht es mit dem nächsten Kästchen weiter. Ist irgendwann keine Möglichkeit mehr vorhanden, soll ein Kästchen zurückgegangen werden und die nächste mögliche Zahl eingesetzt werden.

Ich bin jetzt in etwa so weit:

#include <cstdlib>
#include <iostream>

using namespace std;

void draw(int *feld)
{
     cout << "----------------------------------" << endl
          << "||" << feld[1] << "|" << feld[2] << "|" << feld[3] //Zeile 1 - Block 1 
          << "| |" << feld[4] << "|" << feld[5] << "|" << feld[6] 
          << "| |" << feld[7] << "|" << feld[8] << "|" << feld[9] << "||" << endl
          << "||" << feld[10] << "|" << feld[11] << "|" << feld[12] //Zeile 1 - Block 2
          << "| |" << feld[13] << "|" << feld[14] << "|" << feld[15] 
          << "| |" << feld[16] << "|" << feld[17] << "|" << feld[18] << "||" << endl
          << "||" << feld[19] << "|" << feld[20] << "|" << feld[21] //Zeile 1 - Block 3
          << "| |" << feld[22] << "|" << feld[23] << "|" << feld[24] 
          << "| |" << feld[25] << "|" << feld[26] << "|" << feld[27] << "||" << endl
          << "----------------------------------" << endl
          << "||" << feld[28] << "|" << feld[29] << "|" << feld[30] //Zeile 2 - Block 1
          << "| |" << feld[31] << "|" << feld[32] << "|" << feld[33] 
          << "| |" << feld[34] << "|" << feld[35] << "|" << feld[36] << "||" << endl
          << "||" << feld[37] << "|" << feld[38] << "|" << feld[39] //Zeile 2 - Block 2
          << "| |" << feld[40] << "|" << feld[41] << "|" << feld[42] 
          << "| |" << feld[43] << "|" << feld[44] << "|" << feld[45] << "||" << endl
          << "||" << feld[46] << "|" << feld[47] << "|" << feld[48] //Zeile 2 - Block 3
          << "| |" << feld[49] << "|" << feld[50] << "|" << feld[51] 
          << "| |" << feld[52] << "|" << feld[53] << "|" << feld[54] << "||" << endl
          << "----------------------------------" << endl
          << "||" << feld[55] << "|" << feld[56] << "|" << feld[57] //Zeile 3 - Block 1
          << "| |" << feld[58] << "|" << feld[59] << "|" << feld[60] 
          << "| |" << feld[61] << "|" << feld[62] << "|" << feld[63] << "||" << endl
          << "||" << feld[64] << "|" << feld[65] << "|" << feld[66] //Zeile 3 - Block 2
          << "| |" << feld[67] << "|" << feld[68] << "|" << feld[69] 
          << "| |" << feld[70] << "|" << feld[71] << "|" << feld[72] << "||" << endl
          << "||" << feld[73] << "|" << feld[74] << "|" << feld[75] //Zeile 3 - Block 3
          << "| |" << feld[76] << "|" << feld[77] << "|" << feld[78] 
          << "| |" << feld[79] << "|" << feld[80] << "|" << feld[81] << "||" << endl
          << "----------------------------------" << endl;
}

void eingabe(int *feld)
{
     int wert;
     int nummer;

     while(nummer != 99)
     {
           cout << "Nummer des Feldes (99 = fertig): " << endl;
           cin >> nummer;

           if ((nummer != 99) && (nummer < 82))
           {
              cout << endl << "Wert: ";
              cin >> wert;

              if (wert < 10)
              {
                 feld[nummer] = wert;
                 cout << "Erfolg!" << endl << endl;
              }

              else
              {
                  cout << "Wert größer als 9! Neue Eingabe!" << endl;
              }

           }

           else if ((nummer != 99) && (nummer > 82))
           {
                cout << "Nummer nicht vorhanden! Neue Eingabe!" << endl << endl;
           }

           else
           {
               break; 
           }

     }

}

void check-vert(int *feld)
{

/*void analyse(int *feld)
{
     for(int a = 1; a < 82; ++a) //Felder 1 bis 81 durchgehen
     {
             if(feld[a] > 0) //Wenn Feld belegt ist, Ausgabe
             {
                        cout << "Feld " << a << " belegt. " << feld[a] << endl;
             }

             if (feld[a] = 0) //Wenn Feld nicht belegt ist
             {
                  if (a < 10) //Für Felder 1 - 9
                  {
                        cout << "Feld" << a << " beträgt " << feld[a];

                      for(int b = a; b < 81; b + 9) //Alle Felder vertikal unter Feld a durchgehen
                      {
                             for (int c = 1; c < 11; ++c) //einsetzbare Werte 1 bis 9
                              {
                                  if (feld[b] != c) //Wenn geprüftes Feld diesen Wert nicht hat
                                  {
                                     feld[a] = c; //Setze Wert in das Feld ein
                                     cout << "Feld " << a << " beträgt " << feld[a];
                                  }

                              }

                      }

                  }

             }
     }   
}*/      

int main(int argc, char *argv[])
{
    int feld[82] = {0};

    char i;

    cout << "C++ Soduku-Solver 0.1" << endl << endl;
    cout << "Ihr Sodokufeld: " << endl << endl;
    cout << "------------------------------------" << endl
         << "|| 1| 2| 3 ||  4| 5| 6 ||  7| 8| 9||" << endl
         << "||10|11|12 || 13|14|15 || 16|17|18||" << endl
         << "||19|20|21 || 22|23|24 || 25|26|27||" << endl
         << "------------------------------------" << endl
         << "||28|29|30 || 31|32|33 || 34|35|36||" << endl
         << "||37|38|39 || 40|41|42 || 43|44|45||" << endl
         << "||46|47|48 || 49|50|51 || 52|53|54||" << endl
         << "------------------------------------" << endl
         << "||55|56|57 || 58|59|60 || 61|62|63||" << endl
         << "||64|65|66 || 67|68|69 || 70|71|72||" << endl
         << "||73|74|75 || 76|77|78 || 79|80|81||" << endl << endl << feld[1];

    eingabe(feld);

    //analyse()

    cin >> i;

    //Feld zeichnen

    return 0;
}

Die Analyse hab ich jetzt mal in Klammern gesetzt. Da fängt mein Denkfehler glaube schon an.
Es müssen ja zuerst ALLE Felder unter, neben und in der Box des leeren Feldes überprüft werden, bis ein Wert eingesetzt wird. Hier hab ich nur unter dem Feld prüfen lassen und dann einsetzen lassen, wenn das geprüfte Feld einen anderen Wert hat, als die Ziffer die ich überprüfen lasse. Dabei kann Feld b ja 3 sein, es wird mit Wert 1 verglichen und Feld a bekommt dann den Wert 1 (weil 1 != 3). Dabei kann ja in der Reihe unter Feld a doch noch ein Feld den Wert 1 haben.

Ich hoffe ihr konntet mit so weit folgen

Also denke ich, brauche ich ja 3 einzelne Funktionen (vertikal, horizontal und Box), oder?!

Ich habe grade keine Ahnung, wie ich das bewerkstelligen soll, dass erst alle Ziffern auf den Wert geprüft werden und danach die übrig bleibende Nummmer übergeben wird.
Soll ich vielleicht die Werte 1 - 9 in ein Array schreiben und dann alle Plätze in dem Array nach und nach mit jedem Feld vergleichen, tausche die vorhandenen Werte gegen eine 0 aus und lasse das übrigbleibende übergeben und dann mit den übergebenen Werten aus den anderen 2 Funktionen vergleichen?

Ich hoffe Ihr könnt mir irgendwie einen Denkanstoß geben...

Liebe Grüße
Maximilian

Ich hoffe Ihr könnt mir irgendwie einen Denkanstoß geben...

Hier ein etwas heftiger Denkanstoß: Nurikabe solver
Das ist Nummer 4 in einer Serie, die anderen sind auch sehenswert. Danach solltest du in der Lage sein deinen Code in ordentlichem C++ zu schreiben.

Wie findest du denn meinen Ansatz? Kann man daraus noch was machen oder hab ich gleich ganz falsch angefangen und erzähl die ganze Zeit nur Blödsinn?

Werd mir die Seite aus alle Fälle merken!

Hi Leute!

Denke, Du solltest erstmal kleinere Probleme üben.

a) Die Volkardsche Zahl hat die Eigenschaft, daß die Zahl,
- die als ihrer ersten Ziffer gebildet wird, durch 1 teilbar ist und
- die als ihrer ersten beiden Ziffern gebildet wird, durch 2 teilbar ist und
- die als ihrer ersten drei Ziffern gebildet wird, durch 3 teilbar ist und

…
Also 123
würde das lösen bisher.
1 ist duch 1 teilbar.
12 ist durch 2 teilbar.
123 ist durch 3 teilbar.
…

- die als ihrer letzten vier Ziffern gebildet wird, durch 4 teilbar ist und

…Schon gehts nicht mehr. 1234 passt nicht, 1432 ginge…

- und so weiter
- die als ihrer ersten neun Ziffern gebildet wird, durch 9 teilbar ist und

jede Ziffer von 1 bis 9 kommt genau einmal vor, die 0 kommt nicht vor.

b) Und das Acht-Damen-Problem.

Dann löse Dich vom Backtracking, aber behalte es im Hinterkopf und Sudoku sollte relativ locker von der Hand gehen. Ich denke, viel schneller so, als wenn Du Dir jetzt an Sudoku den Kopf einrennst.

Und wenn, dann ist die Lösung trivial (123456789000000000), denn jede ganze Zahl ist ein Teiler von 0.

Es ist die kleinste volkardsche Zahl gesucht.

Entweder bin ich zu dumm oder zu müde

Ist auch die Ziffer 0 erlaubt?

Nein.

Wenn nicht, dann gibt es keine volkard'sche Zahl (Teiler 5 und 2 schließen sich dann gegenseitig aus).

Aufgabe war falsch. Von vorne.

Warum hast Du da so einen Apostroph hineingefummelt?

Evtl. auch wie man allgemein an solche Aufgaben herangeht um eine vernünftige Lösung zu finden...

Löse es ein paar mal per Hand.

Mit Hilfe dieses Videos www.youtube.com/watch?v=F8JYIUOn_L4&hd=1

bin ich zu dem Code gekommen:

#include <cstdlib>
#include <iostream>

using namespace std;

void draw(int feld[][8])
{
    for (int zeile = 0; zeile < 9; ++zeile)
    {
        for(int spalte = 0; spalte < 9; ++spalte)
        {
             cout << feld[spalte][zeile] << " ";
        }

        cout << endl;
    }
}

void eingabe(int feld[][8])
{
    int spalte; 
	int zeile;
	int wert;
	char input = ' ';

	while(input != 'q')
	{

		cout << "Ihr Sodokufeld: " << endl << endl;
		cout << "------------------------------------------" << endl
		     << "-|| 0 | 1 | 2 || 3 | 4 | 5 || 6 | 7 | 8 ||" << endl
             << "-||-----------||-----------||-----------||" << endl
		     << "0|| x | x | x || x | x | x || x | x | x ||" << endl
             << "1|| x | x | x || x | x | x || x | x | x ||" << endl
             << "2|| x | x | x || x | x | x || x | x | x ||" << endl
             << "-||-----------||-----------||-----------||" << endl
             << "3|| x | x | x || x | x | x || x | x | x ||" << endl
             << "4|| x | x | x || x | x | x || x | x | x ||" << endl
             << "5|| x | x | x || x | x | x || x | x | x ||" << endl
             << "-||-----------||-----------||-----------||" << endl
             << "6|| x | x | x || x | x | x || x | x | x ||" << endl
             << "7|| x | x | x || x | x | x || x | x | x ||" << endl
             << "8|| x | x | x || x | x | x || x | x | x ||" << endl;

		cout << endl << "Spalte (0-8): ";
		cin >> spalte;
		cout << endl << "Zeile (0-8): " ;
		cin >> zeile;
		cout << endl << "Wert (1-9) ";
		cin >> wert;

		feld[spalte][zeile] = wert;

		cout << endl << "'q' + Enter zum fertigstellen. Beliebige Taste + Enter zum fortfahren." << endl << endl;
		cin >> input;

	}
}

bool chkZeile(int zeile, int wert, int arr[8][8])
{
	for (int spalte = 1; spalte < 9; ++spalte) //für Spalten-koordinate
	{
		if (arr[spalte][zeile] == wert) //wenn Feld (spalte, koordinnate) schon wert hat
		{
			return false;
		}
	}

	return true;
}

bool chkSpalte(int spalte, int wert, int arr[8][8])
{
	for (int zeile = 1; zeile < 9; ++zeile)
	{
		if (arr[spalte][zeile] == wert)
		{
			return false;
		}
	}

	return true;
}

bool chkBox(int spalte, int zeile, int wert, int arr[8][8])
{
	for (int i = 1; i < 9; ++i)
	{
		for (int j = 1; i < 9; ++i)
		{
			if (arr[spalte - (spalte%3) + i][zeile - (zeile%3) + j] == wert) //von links-oben nach rechts-unten
			{
				return false;
			}
		}
	}
	return true;
}

bool chkall(int spalte, int zeile, int wert, int arr[8][8])
{
	if (chkZeile(zeile, wert, arr) == false)
	{
		return false;
	}

	if (chkSpalte(spalte, wert, arr) == false)
	{
		return false;
	}

	if (chkBox(spalte, zeile, wert, arr) == false)
	{
		return false;
	}

	return true;
}

int solve(int spalte, int zeile, int wert, int arr[8][8])
{
	int workarr[8][8];
	for (int i = 0; i < 9; ++i)
	{
		for (int j = 0; j < 9; ++j)
		{
			workarr[i][j] = arr[i][j];
		}
	}

	workarr[zeile][spalte] = wert;

	for (int x = 0; x < 9; ++x)
	{
		for (int y = 0; y < 9; ++y)
		{
			if(workarr[x][y] == 0)
			{
				for (int val = 1; val < 9; ++val)
				{
					if(chkall(x,y,val,workarr))
					{
						solve(x,y,val,workarr);
					}
				}
				return NULL;
			}
		}
	}
}

int main(int argc, char *argv[])
{
    int feld[8][8] = {0};

    eingabe(feld);
	solve(0,0,0,feld);
    draw(feld);
	system("Pause");

    return 0;
}

Es wird jetzt an der Stelle angehalten, an der ich eine Kopie von dem der Funktion übergebenem Array, um damit dann weiter zu arbeiten, kommt die Fehlermeldung:

Unbehandelte Ausnahme bei 0x012b8d38 in Sudoku-Löser.exe: 0xC0000005: Zugriffsverletzung beim Lesen an Position 0xa835bbca.

Weiß da jmd. einen Rat? :o

1. zeile 13 (vll solltest du dir array-indices nochmals anschauen)

Was soll denn damit sein?

1. zeile 13 (vll solltest du dir array-indices nochmals anschauen)

Was soll denn damit sein?

Zähl mal alle Zahlen von 0 an, die kleiner sind als 9. Wie viele sind das?

Sind neun Zahlen

Sind neun Zahlen

Und wie groß ist dein Feld?

Und wie groß ist dein Feld?

0-8 (also 9) Zeilen und 0-8 Spalten.
Sind ja dann insgesamt 81...

Sieht man doch eigentlich auch im Code oder?

cout << "------------------------------------------" << endl
             << "-|| 0 | 1 | 2 || 3 | 4 | 5 || 6 | 7 | 8 ||" << endl
             << "-||-----------||-----------||-----------||" << endl
             << "0|| x | x | x || x | x | x || x | x | x ||" << endl
             << "1|| x | x | x || x | x | x || x | x | x ||" << endl
             << "2|| x | x | x || x | x | x || x | x | x ||" << endl
             << "-||-----------||-----------||-----------||" << endl
             << "3|| x | x | x || x | x | x || x | x | x ||" << endl
             << "4|| x | x | x || x | x | x || x | x | x ||" << endl
             << "5|| x | x | x || x | x | x || x | x | x ||" << endl
             << "-||-----------||-----------||-----------||" << endl
             << "6|| x | x | x || x | x | x || x | x | x ||" << endl
             << "7|| x | x | x || x | x | x || x | x | x ||" << endl
             << "8|| x | x | x || x | x | x || x | x | x ||" << endl;

Und wie groß ist dein Feld?

0-8 (also 9) Zeilen und 0-8 Spalten.
Sind ja dann insgesamt 81...

Sieht man doch eigentlich auch im Code oder?

nicht die Zeichen, die du ausgibst. Wie groß ist dein Array?

nicht die Zeichen, die du ausgibst. Wie groß ist dein Array?

Ich glaub ich versteh jetzt was ihr sagen wollt

Wenn ich ein Array mit 8 Speicherplätzen erstelle, kann ich das Array nur bis [7] ansprechen, weil [0] ja auch zu den 8 Plätzen dazu zählt, oder?!

Wenn ich ein Array mit 8 Speicherplätzen erstelle, kann ich das Array nur bis [7] ansprechen, weil [0] ja auch zu den 8 Plätzen dazu zählt, oder?!

So ist es.

Jetzt erklärt mir das mal bitte mit dem Stackoverflow bei einer zu tiefen Rekursion...

Was ist damit genau gemeint?

#include <vector>
#include <iostream>
using namespace std;
class sudoku
{
public:
	enum {
		width = 9,
		height = 9
	};
private:
	vector<int> data;
public:
	sudoku(int fill = 0)
		: data(width * height, fill) {
	}
	void solve() {
		//...
	}
	int operator() (size_t x, size_t y) const {
		return data[x + y * width];
	}
	int& operator() (size_t x, size_t y) {
		return data[x + y * width];
	}
};
ostream& operator<< (ostream& s, sudoku const& d) {
	//...
}
int main()
{
	sudoku mein_spielfeld;
	mein_spielfeld(0, 0) = 1;
	mein_spielfeld.solve();
	cout << mein_spielfeld;
}

das ganze ist viel einfacher zu bedienen...
das mit dem möglichen stackoverflow wird damit gerade auch behoben denn ein std::vector speichert seine elemente auf dem heap. (bzw. nein, er legt sie mit new[] an aber damit wird normalerweise der heap angesprochen)

Okay... hab ich so weit verstanden

Jetzt erklärt mir das mal bitte mit dem Stackoverflow bei einer zu tiefen Rekursion...

Was ist damit genau gemeint?

Jeder rekurtsive Aufruf braucht ein wenig Stackspeicher, so 20-50 Bytes vielleicht. Ruft sich eine Funktion oft selber auf, vieltausenmal, kann der STack ausgehen und das Programm stürzt ab.

Wird Dir aber nicht passieren, weil Du bei vor jedem Abstieg eine Zahl einträgst und nach jedem Aufstieg sie wieder austrägst. Kannst nicht tiefer als 81 Ebenen abteigen. 81 ist voll unkritisch.

Sogar, wenn Du nicht streichst (warum nicht, ist doch viel schneller und einfach genug), sondern Kopien hältst, wie Du es mit dem workarray machst, 81*sizeof(int)*81 ist auch locker um die 30k, kannst davon ausgehen, ca 1M zu haben.