/* ***************************************************************************************************************
* Autor: Cyb3r *
* Beschreibung: Dies ist ein Konsolenprogramm, in der man Sudoku selber eingeben kann, *
* oder Sudoku aus einem Textfile als Vorlage laden und lösen. Sowie gelöste Sudokus abseichern und kontolieren lassen. *
* Auch kann man ein Sudoku vom Computer lösen lassen. *
* Date: 18.12.2006 *
* ***************************************************************************************************************
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <Windows.h>
/*Stellt das Sudoku auf null*/
void sudokuNull(int sudoku[9][9]) {
int zeile, spalte;
for (spalte=0; spalte<9; spalte++) {
for (zeile=0; zeile<9; zeile++) {
sudoku[zeile][spalte] = 0;
}
}
}
/*---------------SUDOKU PRÜFEN----------------*/
/*prüft die Spalten*/
int pruefSpalte(int sudoku[9][9]) {
int spaltePruef[9];
int zeile, spalte;
int index;
int fehler=0;
for (spalte = 0; spalte <9; spalte++) { // geht die Spalten vom Sudkou durch
for (zeile=0; zeile<9; zeile++) { // geht die Zeilen vom Sudoku druch
spaltePruef[zeile] = sudoku[spalte][zeile]; // Wertzuweisung (kleines = Grosses..)
for (index=0; index<zeile; index++) { // geht das kleine Array zeile mal durch...
if(spaltePruef[index] == sudoku[spalte][zeile]) {
if (spaltePruef[index] != 0) {
fehler++; // Fehler
}
}
}
}
}
return fehler;
}
/*Prüft die Zeilen*/
int pruefZeile(int sudoku[9][9]) {
int zeilePruef[9];
int zeile, spalte;
int index;
int fehler=0;
for (zeile=0; zeile<9; zeile++) { // geht die Zeilen vom Sudoku durch
for (spalte = 0; spalte <9; spalte++) { // geht die Spalten vom Sudoku durch
zeilePruef[spalte] = sudoku[spalte][zeile]; // Wertzuweisung (kleines = grosses..)
for (index=0; index<spalte; index++) { // geht das kleine Array spalte mal durch....
if(zeilePruef[index] == sudoku[spalte][zeile]) {
if (zeilePruef[index] != 0) {
fehler++; // Fehler...
}
}
}
}
}
return fehler;
}
/*prüft die einzelnen Quadrätchen*/
int pruefQuadrat(int sudoku[9][9]) {
int fehler=0;
int count=0, zahl;
int zeile, spalte, indexZeile, indexSpalte;
for (zeile=0; zeile<9; zeile+=3) { // Jede 3. Zeile
for (spalte=0; spalte<9; spalte+=3) { // Jede 3. Spalte
for(zahl=1; zahl<10; zahl++) { // Zahlen 1 bis 9
for(indexZeile=0; indexZeile<3; indexZeile++) { // 3x3 Quadrat die Zeilen
for(indexSpalte=0; indexSpalte<3; indexSpalte++) { // 3x3 Quadrat die Spalten
if (zahl == sudoku[spalte+indexSpalte][zeile+indexZeile]) { // Überprüfung der Vorkomnisse einer Zahl
count++;
}
}
}
if( count >= 2) { // 2 oder mehr Vorkomnisse einer Zahl...
fehler++; // ... Fehler
}
count = 0;
}
}
}
return fehler; // gibt die Anzahl Fehler zurück
}
/*SUDOKU LÖSEN*/
//SOLVER 1
int sudokuLoesen(int sudoku[9][9]) {
int fehler=0, count=0, zahl, durchgang=0;
int zahlen, zeile, spalte;
do {
durchgang=0;
for (zeile=0; zeile<9; zeile++) { // Jede Zeile....
for (spalte=0; spalte<9; spalte++) { // .... Jede Spalte ... .... jede Zahl
for (zahlen=1; zahlen<=9; zahlen++) { // alle Zahlen von 1 bis 9
if (sudoku[spalte][zeile] == 0) { // wenn das Feld noch leer ist...
durchgang++; // Durchgang noch nicht fertig
sudoku[spalte][zeile] = zahlen; //Zahl einsetzten
fehler = pruefSpalte(sudoku); //überprüfen
fehler = fehler + pruefZeile(sudoku); //überprüfen
fehler = fehler + pruefQuadrat(sudoku); //überprüfen
if (fehler == 0) { // keine Fehler.. Zahl speichern und zähler erhöhen
count++;
zahl = zahlen;
}
sudoku[spalte][zeile] = 0; //alles auf 0 setzen
fehler=0;
}
}
if (count==1) { // Nur eine mögliche zahl
sudoku[spalte][zeile] = zahl; //Füge Zahl ein
}
count=0; // Zähler auf null setzen
}
}
}while (durchgang != 0); // Solange Durchgang nicht 0
return 0;
}
//SOLVER 2
//Sovlersudoku speichern
void solverSave(int sudoku[9][9][10]) {
char save;
char name[200];
FILE *handle;
char pfad[200] = "saveSudoku/";
int i, j;
printf("Wollen Sie das Sudoku speichern? (j/n) "); //Abfrage nach Speichern
fflush(stdin); //Tastaturpuffer leeren
scanf("%c", &save);
if (save == 'j') {
printf("Unter welchem Namen wollen sie das Sudoku speichern? "); //Abfrage nach dem Dateinamen
fflush(stdin);
scanf("%[^\n]", &name);
strcat(pfad, name); //Pfad zusammensetzen
strcat(pfad, ".txt");
handle = fopen(pfad, "a+");
for(i=0; i<9; i++){
for (j=0; j<9; j++){
fprintf(handle, "%i\t", sudoku[j][i][0]); //in die Datei schreiben...
}
fprintf(handle, "\n");
}
fclose(handle);
}
}
//Sovlersudoku ausgeben
void solverAusgeben(int sudoku[9][9][10]) {
int zeile, spalte;
printf(" A B C D E F G H I\n"); //Spaltenübertitel ausgeben
for(zeile=0; zeile<9; zeile++) { // jede Zeile
if (zeile%3 == 0) { //Jede 3. Zeile Linie ausgeben
printf(" - - - - - - - - - - - - - - - -\n");
}
printf("%i ", zeile+1); // Jede Zeile Zeilennummer ausgeben
for(spalte=0; spalte<9; spalte++) { //Jede Spalte
if (spalte%3 == 0) { // Jede 3. Spalte Linie ausgeben
printf("|");
}
if(sudoku[spalte][zeile][0] == 0) { // Wenn Feld leer .. - ausgeben
printf(" - ");
}
else {
printf(" %i ", sudoku[spalte][zeile][0]); //Sonst die Zahl
}
}
printf("|\n"); // nächste Zeile
}
printf(" - - - - - - - - - - - - - - - -\n"); // Linie ausgeben
printf("\n\n\n");
}
/* Bei dieser Funktion werden die überflüssigen Zahlen gelöscht... Diese Funktion wird von wegA aufgerufen..
* Auch hier ist das Sudoku als Rückgabwert...
*/
void zahlenLoeschen(int sudoku[9][9][10], int zeileNr, int spalteNr, int zahl) {
int i, j;
int zeile, spalte;
for(i=0; i<9; i++) {
sudoku[i][zeileNr][zahl] = 0; //Hier werden die überflüssigen Zahlen in den spalten gelöscht.... (vo obe nach abe...)
}
for(i=0; i<9; i++) {
sudoku[spalteNr][i][zahl] = 0; // die bei den zeile (vo links nach rechts.....)
}
//Rechnet die Anfangsposition des Quadrätchens aus...
zeile = (zeileNr/3)*3;
spalte = (spalteNr/3)*3;
// Löscht die überflüssigen Zahlen in den Quadrätchen
for (i=0; i<3; i++) {
for (j=0; j<3; j++) {
sudoku[spalte+j][zeile+i][zahl] = 0;
}
}
}
/* Zuerst werden die überflüssigen Zahlen gelöscht und anschliessen wird das
* Sudoku ausgegeben und das Sudoku zurückgegeben
*/
void loeschen(int sudoku[9][9][10]) {
int zahl;
int zeile, spalte;
for (zeile=0; zeile<9; zeile++) {
for (spalte=0; spalte<9; spalte++) {
if (sudoku[spalte][zeile][0] != 0) {
zahl = sudoku[spalte][zeile][0];
zahlenLoeschen(sudoku, zeile, spalte, zahl);
}
}
}
}
//Sucht leere Felder mit eindeutigen Zahlen
int aktualisieren(int sudoku[9][9][10]) {
int zeile, spalte, zahl;
int count=0;
int merkeZahl;
int nochmal=0;
for(zeile=0; zeile<9; zeile++) { //geht die Zeilen Durch
for(spalte=0; spalte<9; spalte++) { //die Spalten
for(zahl=1; zahl<10; zahl++) { // zählt jede Zahl
if (sudoku[spalte][zeile][0] == 0) {
if(sudoku[spalte][zeile][zahl] == zahl) {
count++; //Zählt die Zahl
merkeZahl = zahl; //merkt sich die Zahl
}
}
}
if (count==1) {
sudoku[spalte][zeile][0] = merkeZahl; //Schreibt die einzige mögliche Zahl definitiv in das Array.
sudoku[spalte][zeile][merkeZahl] = 0;
nochmal++;
}
count=0;
}
}
return nochmal;
}
// Durchsucht die Zeile nach nur einmaligen vorkommen von Zahlen
int methodeAzeile (int sudoku[9][9][10]) {
int zeile, spalte, zahl;
int merken;
int count=0;
int nochmal=0;
int i;
for (zeile=0; zeile<9; zeile++){ //geht die zeilen durch
for (zahl=1; zahl<10; zahl++) { //zählt jede Zahl durch
for (spalte=0; spalte<9; spalte++) { //geht die Spalten durch
if (sudoku[spalte][zeile][0] == 0) {
if(sudoku[spalte][zeile][zahl] == zahl) {
count++;
merken = spalte; //merkt sich die möglich einzige Zahl
}
}
}
if(count == 1) {
sudoku[merken][zeile][zahl] = 0;
sudoku[merken][zeile][0] = zahl; //schreibt die einzig mögliche Zahl definitiv in das Array
for(i=1; i<10; i++) {
sudoku[merken][zeile][i] = 0;
}
nochmal++;
}
count =0;
}
}
return nochmal;
}
//Durchsucht die Spalte nach einmaligen vorkommen von Zahlen
int methodeAspalte(int sudoku[9][9][10]) {
int zeile, spalte, zahl;
int count = 0;
int merken;
int nochmal=0;
int i;
for (spalte=0; spalte<9; spalte++){ //geht die Spalten durch
for (zahl=1; zahl<10; zahl++) { //zählt die Zahlen
for (zeile=0; zeile<9; zeile++) { //geht die Zeilen durch
if (sudoku[spalte][zeile][0] == 0) {
if(sudoku[spalte][zeile][zahl] == zahl) {
count++;
merken = zeile; //merkt sich die mögliche einzig mögliche Zahl
}
}
}
if(count == 1) {
sudoku[spalte][merken][zahl] = 0;
sudoku[spalte][merken][0] = zahl; //Schreibt die einzig möglich Zahl definitiv in das Array.
for(i=1; i<10; i++) {
sudoku[spalte][merken][i] = 0; //Setzt die anderen Zahlen auf 0
}
nochmal++;
}
count =0;
}
}
return nochmal;
}
//Durchsucht das Quadrat nach nur einmaligen vorkommen von Zahlen
int methodeAquadrat(int sudoku[9][9][10]) {
int zeile, spalte, zahl;
int count=0;
int nochmal=0;
int i, j;
int merkenZeile, merkenSpalte;
int y;
for (spalte=0; spalte<9; spalte+=3){ //geht die Spalten druch ..... nur alle 3
for (zeile=0; zeile<9; zeile+=3) { //geht die Zeilen durch ...... nur alle 3
for (zahl=1; zahl<10; zahl++) { //zählt die Zahlen
//kleines Quadrat
for(i=0; i<3; i++) { //geht im kleinen Quadrat die Zeilen durch
for(j=0; j<3; j++) { //da die Spalten
if (sudoku[spalte+j][zeile+i][0] == 0) {
if(sudoku[spalte+j][zeile+i][zahl] == zahl) {
count++;
merkenZeile = zeile+i; //merkt sich die Zeile und die Spalte (vom grossen, richtigen Quadrat)
merkenSpalte = spalte+j;
}
}
}
}
if(count == 1) {
sudoku[merkenSpalte][merkenZeile][zahl] = 0; //schreibt die Zahl definitiv in das Array
sudoku[merkenSpalte][merkenZeile][0] = zahl;
for(y=1; y<10; y++) {
sudoku[merkenSpalte][merkenZeile][y] = 0;
}
nochmal++;
}
count =0;
}
}
}
return nochmal;
}
/*Lösungsverfahren A*/
void methodeA(int sudoku[9][9][10]) {
int nochmal;
//das ganze wird so oft wiederholt, bis keine Änderung mehr vorgenommen wurde
do {
loeschen(sudoku);
nochmal=methodeAquadrat(sudoku);
loeschen(sudoku);
nochmal = methodeAspalte(sudoku) + nochmal;
loeschen(sudoku);
nochmal = methodeAzeile(sudoku) + nochmal;
}while(nochmal != 0);
}
//Durchsucht die Zeilen nach Zahlen die nur in einem Block in einer Zeile vorkommen können
int methodeBzeile(int sudoku[9][9][10]) {
int zeile, spalte, zahl;
int quadratZeile, quadratSpalte, quadrat2;
int count=0;
int right = 0;
int i, j;
int nochmal=0;
for(zeile=0; zeile<9; zeile++) { //geht die Zeilen durch
for(zahl=1; zahl<10; zahl++) { //zählt die Zahlen
for(spalte=0; spalte<9; spalte++) { //geht die Spalten durch
if (sudoku[spalte][zeile][0] == 0 ) {
if(sudoku[spalte][zeile][zahl] == zahl) {
quadratSpalte = (spalte/3)*3; //rechnet das Quadrat aus... 0, 1 oder 2
count++;
}
}
if(count == 1) {
quadrat2 = quadratSpalte;
}
if(count>1) {
if(quadratSpalte != quadrat2) { //Wenn es nicht im gleichen Block ist, wird abgebrochen
right = 0;
break;
}
else {
right = 1;
}
}
}
count = 0;
if (right == 1) {
quadratZeile = (zeile/3)*3; //rechnet das Ausgangsfeld aus...
for(i=0; i<3; i++) {
if(quadratZeile+i != zeile) { //es darf nur in den anderen Zeilen gelöscht werden...
for(j=0; j<3; j++) {
sudoku[quadratSpalte+j][quadratZeile+i][zahl] = 0;
nochmal++;
}
}
}
}
quadratZeile=0; //Setzt alles wieder auf 0...
quadratSpalte=0;
quadrat2=0;
count = 0;
right=0;
}
}
return nochmal;
}
//Durchsucht die Spalten nach Zahlen, die nur in einem Block in einer Zeile vorkommen können
int methodeBspalte(int sudoku[9][9][10]) {
int zeile, spalte, zahl;
int quadratZeile, quadratSpalte, quadrat2;
int count=0;
int right = 0;
int i, j;
int nochmal=0;
for(spalte=0; spalte<9; spalte++) { //geht die Spalten durch...
for(zahl=1; zahl<10; zahl++) { //zählt die Zahl
for(zeile=0; zeile<9; zeile++) { //geht die Zeilen druch...
if (sudoku[spalte][zeile][0] == 0 ) {
if(sudoku[spalte][zeile][zahl] == zahl) {
quadratZeile = (zeile/3)*3; //rechnet den Block aus... 0, 1 oder 2
count++;
}
}
if(count == 1) {
quadrat2 = quadratZeile;
}
if(count>1) {
if(quadratZeile != quadrat2) { //Fals die Zahlen nicht im gleichen Block sind...
right = 0;
break;
}
else {
right = 1;
}
}
}
count = 0;
if (right == 1) {
quadratSpalte = (spalte/3)*3;
for(i=0; i<3; i++) {
if(quadratSpalte+i != spalte) { //Es darf nicht in der Falschen Spalte gelöscht werden...
for(j=0; j<3; j++) {
sudoku[quadratSpalte+i][quadratZeile+j][zahl] = 0; //Setzt die Zahlen auf 0..
nochmal++;
}
}
}
}
quadratZeile=0; //wird wieder alles auf 0 gesetzt...
quadratSpalte=0;
quadrat2=0;
count = 0;
right=0;
}
}
return nochmal;
}
/*Lösungsverfahren B*/
void methodeB(int sudoku[9][9][10]) {
int nochmal;
//Solange bis nichts mehr geändert wurde...
do{
nochmal = methodeBspalte(sudoku);
nochmal += methodeBzeile(sudoku);
aktualisieren(sudoku);
methodeA(sudoku);
loeschen(sudoku);
}while(nochmal != 0);
}
void sudokuSolver(int sudoku[9][9][10]) {
int zeile, spalte, zahl;
int nochmal;
/*Die 3. Dimension wird aufgefüllt....*/
system("cls"); // Bildschirminhalt leerren.
for (zeile=0; zeile<9; zeile++) { // 1. Dimension
for (spalte=0; spalte<9; spalte++) { // 2. Dimension
for (zahl=1; zahl<10; zahl++) { // 3. Dimension
if ( sudoku[spalte][zeile][0]== 0) { // Fals bei index 0 noch keine Zahl steht werden die Zahlen 1 bis 9 reingeschrieben
sudoku[spalte][zeile][zahl] = zahl;
}
else {
sudoku[spalte][zeile][zahl] = 0; // ansonsten einen 0...
}
}
}
}
solverAusgeben(sudoku); // Das Sudoku wird ausgegeben
do{
methodeA(sudoku);
nochmal=aktualisieren(sudoku);
}while(nochmal!=0);
printf("LOESUNGSVERFAHREN A: \n");
solverAusgeben(sudoku); // Das Sudoku wird ausgegeben
do{
methodeB(sudoku);
nochmal=aktualisieren(sudoku);
}while(nochmal!=0);
printf("LOSEUNGSVERFAHREN B: \n");
solverAusgeben(sudoku); // Das Sudoku wird ausgegeben
fflush(stdin);
getch();
solverSave(sudoku);
}
/*EIN- UND AUSGABE VON SUDOKU*/
/*Liest ein Sudoku aus einem Textfile*/
int sudokuAusTextfile(int sudoku[9][9]) {
FILE *handle;
int zeile, spalte;
char filename[200]="\0";
char pfad[200] = "saveSudoku/";
system("cls"); //Bildschirminhalt löschen
system("dir saveSudoku"); //Verzeichnis ausgeben
printf("\n\n\nWie ist der Name Datei (ohne .txt)? ");
scanf("%s", &filename);
strcat(filename, ".txt"); //Pfad zusammensetzen
strcat(pfad, filename);
if (handle = fopen(pfad, "r")) {
for (zeile=0; zeile<9; zeile++) { //jede Zeile
for (spalte=0; spalte<9; spalte++) { // jede Spalte
fscanf(handle, "%i\t", &sudoku[spalte][zeile]); //Schreibe in Textdatei
}
fscanf(handle, "\n"); // neue Zeile... Zeilenumbruch
}
fclose(handle);
return 1;
}
else { // Falls die Datei nicht geöffnet werden konnte...
printf("Diese Datei existiert nicht!");
return 0;
}
}
/*Sudoku speichern*/
void sudokuSpeichern(int sudoku[9][9]) {
FILE *handle;
int zeile, spalte;
char filename[200] ="\0";
char pfad[200] = "saveSudoku/";
printf("Unter welchen Namen wollen Sie das Sudoku speichern?");
scanf("%s", &filename);
strcat(filename, ".txt"); // Pfade zusammensetzen
strcat(pfad, filename);
if (handle = fopen(pfad, "w")) {
for (zeile=0; zeile<9; zeile++) { //jede Zeile
for (spalte=0; spalte<9; spalte++) { //jede Spalte
fprintf(handle, "%i\t", sudoku[spalte][zeile]); //aus Textfile herauselesn
}
fprintf(handle, "\n"); //nächste Zeile
}
fclose(handle);
}
}
/*Sudoku Ausgabe*/
void sudokuAusgabe(int sudoku[9][9]) {
system("cls"); // Bildschirminhalt löschen
int zeile, spalte;
printf(" A B C D E F G H I\n"); //Spaltenübertitel ausgeben
for(zeile=0; zeile<9; zeile++) { // jede Zeile
if (zeile%3 == 0) { //Jede 3. Zeile Linie ausgeben
printf(" - - - - - - - - - - - - - - - -\n");
}
printf("%i ", zeile+1); // Jede Zeile Zeilennummer ausgeben
for(spalte=0; spalte<9; spalte++) { //Jede Spalte
if (spalte%3 == 0) { // Jede 3. Spalte Linie ausgeben
printf("|");
}
if(sudoku[spalte][zeile] == 0) { // Wenn Feld leer .. - ausgeben
printf(" - ");
}
else {
printf(" %i ", sudoku[spalte][zeile]); //Sonst die Zahl
}
}
printf("|\n"); // nächste Zeile
}
printf(" - - - - - - - - - - - - - - - -\n"); // Linie ausgeben
}
/*Sudoku selber eingeben*/
int sudokuEingabe(int sudoku[9][9]) {
int zeile, zahl, spalteInt;
char spalte[5]="\0";
char nochmal = 'j';
printf("Bitte geben Sie nun an, in welches Feld sie was hineinschreiben wollen (A/2 6).\n");
fflush( stdin ); //Puffer leeren
scanf("%[^/]", &spalte); //Eingabe...
if (strcmp(spalte, "exit") == 0) { // Falls der Benutzer beenden will....
nochmal = 'n';
}
else {
scanf("/%i", &zeile); // ansonsten die anderen Angaben einlesen
scanf(" %i", &zahl);
spalteInt = (int)spalte[0]; //Spalte (A-I) in Integer casten
spalteInt = spalteInt-65; // in richtige Zahl umrechnen
if(zeile >9 || zahl>9 || spalteInt > 9) { //Überprüfung ob angabe richtig
printf("Ihre Eingabe war falsch.");
getch();
}
else {
sudoku[spalteInt][zeile-1] = zahl; // Schreibe Zahl
}
}
return nochmal;
}
/*DIE VERSCHIEDENEN FÄLLE*/
/*FALL 1*/
void fall1(int sudoku[9][9]) {
char ende;
do {
sudokuAusgabe(sudoku); //Sudoku wird ausgegeben
printf("Um die Eingabe zu beenden schreiben sie 'exit/'\n"); //beenden-Hinweis
ende = sudokuEingabe(sudoku); //Sudoku eingabe
} while (ende != 'n');
printf("Wollen Sie dieses Sudoku speichern? (j/n)"); // Abfrage nach Speichern
fflush(stdin);
scanf("%c", &ende);
if(ende == 'j') {
sudokuSpeichern(sudoku); // Sudoku speichern
}
}
/*FALL 2*/
void fall2(int sudoku[9][9]) {
int exist;
do {
exist = sudokuAusTextfile(sudoku); //Sudoku aus Textfile holen
} while(exist != 1);
sudokuAusgabe(sudoku); //Sudoku ausgeben
fall1(sudoku); //Fall 1....
}
/*FALL 3*/
void fall3(int sudoku[9][9]) {
int exist;
char speichern;
do {
exist = sudokuAusTextfile(sudoku); //Sudoku aus Textfile holen
} while(exist != 1);
sudokuLoesen(sudoku); // Sudoku lösen
sudokuAusgabe(sudoku); //Sudoku ausgeben
printf("Wollen Sie dieses Sudoku speichern (j/n)? ");
fflush(stdin);
scanf("%c", &speichern);
if (speichern == 'j') {
sudokuSpeichern(sudoku); //Sudoku speichern
}
}
/*FALL 4*/
void fall4(int sudoku[9][9]) {
int fehler, count=0;
int exist;
do {
exist = sudokuAusTextfile(sudoku);
} while(exist != 1);
sudokuAusgabe(sudoku);
fehler = pruefSpalte(sudoku); //Spalte überprüfen
if(fehler != 0) {
printf("Es hat %i Fehler in der Spalte.\n", fehler);
count++;
}
fehler = pruefZeile(sudoku); //Zeile überprüfen
if(fehler != 0) {
printf("Es hat %i Fehler in der Zeile. \n", fehler);
count++;
}
fehler = pruefQuadrat(sudoku); //3x3 Quadrate überprüfen
if(fehler != 0) {
printf("Es hat %i Fehler im 3x3 Quadrat. ", fehler);
count++;
}
if (count == 0) { // Keine Fehler
printf("Keine Fehler!");
}
getch();
}
/*MAIN*/
int main()
{
int sudoku[9][9];
int auswahl;
/*Wird für den Solver 2 gebraucht*/
int sudoku2[9][9][10];
int i, j;
int tmp;
FILE *handle;
char filename[100] = "\0";
char pfad[100] = "saveSudoku/";
srand( (unsigned)time( NULL ) );
do{
sudokuNull(sudoku); //Sudoku auf null setzen
system("cls");
/*MENU AUSGEBEN*/
printf("\n\n\n\t\t\t Menu\n");
printf(" - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n\n");
printf("\t\t1. Vorlage selber eingeben\n");
printf("\t\t2. Vorlage aus Textfile holen\n");
printf("\t\t3. Computer Sudoku loesen lassen\n");
printf("\t\t4. Sudoku pruefen lassen\n\n");
printf("\n\n");
printf("\t\t5. Sudoku loesen lassen\n\n");
printf(" - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n");
fflush(stdin);
auswahl = getch();
switch (auswahl) {
case '1': //Auswahl 1
fall1(sudoku);
break;
case '2': //Auswahl 2
fall2(sudoku);
break;
case '3': //Auswahl 3
fall3(sudoku);
break;
case '4': //Auswahl 4
fall4(sudoku);
break;
case '5': //Auswahl 5
system("cls");
system("dir saveSudoku");
printf("Welches Sudoku wollen Sie loesen lassen? ");
scanf("%[^\n]", &filename);
strcat(pfad, filename);
strcat(pfad, ".txt");
handle = fopen(pfad, "r");
for (i=0; i<9; i++) {
for (j=0; j<9; j++) {
fscanf(handle, "%i\t", &tmp);
sudoku2[j][i][0] = tmp;
}
fscanf(handle, "\n");
}
fclose(handle);
sudokuSolver(sudoku2);
break;
}
} while(auswahl != 27); //Beenden mit ESC.... dezimal 27 und hex 0x1B
return 0;
}
