#include <stdio.h>
/* Teilaufgabe 1: Zeilen 18 - 91 */
/* Teilaufgabe 2: Zeilen 107 - 231 */
/* Teilaufgabe 3: Zeilen 233 - 410 */
/* Teilaufgabe 4: Zeilen 412 - 553 */
int eingabe();
int isSolved();
void setValue();
void blockdurchlauf(int m, int n);
void printGrid();
void zeile1(int c, int d);
void zeile2(int c, int d);
void zeile3(int c, int d);
void zeile4(int c, int d);
void zeile5(int c, int d);
void zeile6(int c, int d);
int i;
/*Die Struktur streich wird deklariert als Struktur mit einer ganzen Zahl
und einem 3x3-Array von ganzen Zahlen als Inhalt. Außerdem bewirkt der
Befehl typedef, dass man statt "struct streich" ab hier nur noch "str"
schreiben muss.*/
typedef struct streich {
int wert;
int liste[3][3];
} str;
str gesamt[9][9]; /*Ein 9x9-Array aus Strukturen wird angelegt (später: Sudoku-Feld!)*/
int main () {
int zaehler, spalte, zeile, g_sp, g_zei;
zaehler = 1;
/*Die folgenden vier for-Schleifen bewirken, dass in jedes Feld des Arrays liste[3][3],
der Wert geschrieben wird, den man später dort für die Streichlisten benötigen wird.
D.h. z.B., dass in liste[0][0] der Wert 1 kommt, in liste[2][2] der Wert 9.
Dies geschieht nun mit allen Feldern des Arrays gesamt[9][9].*/
for (g_zei = 0; g_zei < 9; g_zei++) {
for (g_sp = 0; g_sp < 9; g_sp++) {
for (zeile = 0; zeile < 3; zeile++) {
for (spalte = 0; spalte < 3; spalte++) {
gesamt[g_zei][g_sp].liste[zeile][spalte] = zaehler;
zaehler++;
if (zaehler == 10) {zaehler = 1;}
}}}}
/*Der Variablen wert wird in jedem Feld von gesamt[9][9] zunächst der Wert 0 zugewiesen.*/
for (g_zei = 0; g_zei < 9; g_zei++) {
for (g_sp = 0; g_sp < 9; g_sp++) {
gesamt[g_zei][g_sp].wert = 0;
}}
/* Werte des Arrays gesamt[9][9] werden ausgegeben:
for (g_zei = 0; g_zei < 9; g_zei++) {
for (g_sp = 0; g_sp < 9; g_sp++) {
for (zeile = 0; zeile < 3; zeile++) {
for (spalte = 0; spalte < 3; spalte++) {
printf("%d\n", gesamt[g_zei][g_sp].liste[zeile][spalte]);
}}}}*/
/*Zum jetzigen Zeitpunkt haben wird also ein 9x9-Array, das aus Strukturen besteht, die jeweils
einen int-Wert und ein 3x3-Array besitzen, das wie folgt belegt ist:
123
456
789
Man hat nun folglich quasi ein Sudoku-Feld, bei dem in jeder Zelle noch der Wert 0 steht,
die Zelle enthält dafür eine Streichliste.*/
while (gesamt[0][0].wert != 10) { /*Der Benutzer kann solange Werte eingeben, bis er in Feld [0][0] eine 10 schreibt.*/
eingabe();
setValue();
printGrid();
/*Falls die Funktion isSolved() den Wert 1 zurückgibt (was gleichbedeutend damit ist, dass das
Sudoku gelöst ist, wird "Sudoku gelöst" ausgegeben, ansonsten "Sudoku nicht gelöst".*/
if (isSolved() == 1) {
printf("\nSudoku gelöst!\n");
}
else printf("\nSudoku nicht gelöst!\n");
while(getchar() != '\n');
}
return 0;
}
/*In der Funktion eingabe() muss folgendes verändert werden:
scanf("(%d,%d)=%d", &x, &y, &z);
i[x-1][y-1] = z;
wird zu:
scanf("(%d,%d)=%d", &x, &y, &z);
gesamt[x-1][y-1].wert = z;
Die Funktion isSolved muss wie folgt umgeschrieben werden:
In den vielen Schleifen muss man überall statt i[x][y] einfach gesamt[x][y].wert schreiben! */
int eingabe() {
int x, y, z;
printf("\nUm in die y-te Spalte der x-ten Zeile den Wert z zu schreiben, \n");
printf("geben Sie bitte die einen Ausdruck der Form (x,y)=z ein:\n");
scanf("(%d,%d)=%d", &x, &y, &z);
gesamt[x-1][y-1].wert = z;
}
int isSolved() {
int m, p, n, q;
int zaehler = 0;
int spaltengesamt = 0;
int zeilengesamt = 0;
int blockgesamt = 0;
for (m = 0; m <= 8; m++) { /*Die For-Schleife geht alle Zeilen durch*/
for (p = 1; p <= 9; p++) { /*In jeder Zeile wird überprüft, ob jeder Wert zwischen 1 und 9 mindestens einmal vorkommt.*/
if (gesamt[m][0].wert == p || gesamt[m][1].wert == p || gesamt[m][2].wert == p || gesamt[m][3].wert == p || gesamt[m][4].wert == p || gesamt[m][5].wert == p || gesamt[m][6].wert == p || gesamt[m][7].wert == p || gesamt[m][8].wert == p ) {
zaehler++; /*Wenn die Zahl p in der aktuellen Zeile mindestens einmal vorkommt, wird die Variable zaehler um eins erhöht.*/
}
}
if (zaehler == 9){ /*Wenn jede Zahl von 1 bis 9 in der aktuellen Zeile vorkommt, hat zaehler hier den Wert 9.*/
zeilengesamt++; /*Die Variable zeilengesamt wird dann um eins erhöht.*/
zaehler = 0; /*Außerdem wird der Zähler wieder auf Null gesetzt.*/
}
}
for (n = 0; n <= 8; n++) { /*Dieselbe Prozedur wie für die Zeilen wird nun auf alle Spalten angewandt.*/
for (p = 1; p <= 9; p++) {
if (gesamt[0][n].wert == p || gesamt[1][n].wert == p || gesamt[2][n].wert == p || gesamt[3][n].wert == p || gesamt[4][n].wert == p || gesamt[5][n].wert == p || gesamt[6][n].wert == p || gesamt[7][n].wert == p || gesamt[8][n].wert == p ) {
zaehler++;
}
}
if (zaehler == 9){
spaltengesamt++;
zaehler = 0;
}
}
for (q = 0; q <= 8; q = q+3) { /*q wird bei jedem Durchlauf um 3 erhöht => es gibt 3 Durchläufe*/
for (p = 1; p <= 9; p++) {
/*Immer, wenn in einem 3x3 Block (hier werden die drei Blöcke am linken Rand durchlaufen)*/
/*jede Zahl zwischen 1 und 9 vorkommt, wird der Zähler um 1 erhöht.*/
if (gesamt[q][0].wert == p || gesamt[q][1].wert == p || gesamt[q][2].wert == p || gesamt[q+1][0].wert == p || gesamt[q+1][1].wert == p || gesamt[q+1][2].wert == p || gesamt[q+2][0].wert == p || gesamt[q+2][1].wert == p || gesamt[q+2][2].wert == p ) {
zaehler++;
}
}
if (zaehler == 9) { /*gleiches Prinzip wie bei den Zeilen und Spalten!*/
blockgesamt++;
zaehler = 0;
}
for (p = 1; p <= 9; p++) {
/*Hier werden die drei 3x3-Blöcke aus der Mitte durchlaufen (also die mit den Spalten 4,5,6).*/
if (gesamt[q][3].wert == p || gesamt[q][4].wert == p || gesamt[q][5].wert == p || gesamt[q+1][3].wert == p || gesamt[q+1][4].wert == p || gesamt[q+1][5].wert == p || gesamt[q+2][3].wert == p || gesamt[q+2][4].wert == p || gesamt[q+2][5].wert == p ) {
zaehler++;
}
}
if (zaehler == 9) {
blockgesamt++;
zaehler = 0;
}
for (p = 1; p <= 9; p++) {
/*Hier werden die drei 3x3-Blöcke vom rechten Rand durchlaufen (also die mit den Spalten 7,8,9).*/
if (gesamt[q][6].wert == p || gesamt[q][7].wert == p || gesamt[q][8].wert == p || gesamt[q+1][6].wert == p || gesamt[q+1][7].wert == p || gesamt[q+1][8].wert == p || gesamt[q+2][6].wert == p || gesamt[q+2][7].wert == p || gesamt[q+2][8].wert == p ) {
zaehler++;
}
}
if (zaehler == 9) {
blockgesamt++;
zaehler = 0;
}
}
/*Wenn jede Zahl von 1 bis 9 nun in jeder Zeile, in jeder Spalte und in jedem 3x3-Block vorhanden war, dann*/
/*haben die drei "-gesamt" Variablen jeweils den Wert 9. Ist dies der Fall, so gibt isSolved() den*/
/*Wert 1 zurück, andernfalls den Wert 0.*/
if (spaltengesamt == 9 && zeilengesamt == 9 && blockgesamt == 9) {
return 1;
}
else {return 0;}
}
void setValue() {
int x, y, a, b, m, n, g_zei, g_sp, zeile, spalte, zaehler;
zaehler = 1;
/*Bei jedem neuen Aufruf der Funktion setValue() werden zunächst die Streichlisten
in ihre "Ausgangslage" zurückversetzt, d.h. jede Streichliste enthält nun wieder
alle Zahlen 1-9. Dadurch lassen sich nämlich feste Werte, die bereits eingegeben
wurden wieder löschen (indem man eine Null in die betreffende Zelle schreibt) oder
überschreiben (einfach eine andere Ziffer in die jeweilige Zelle schreiben).*/
for (g_zei = 0; g_zei < 9; g_zei++) {
for (g_sp = 0; g_sp < 9; g_sp++) {
for (zeile = 0; zeile < 3; zeile++) {
for (spalte = 0; spalte < 3; spalte++) {
gesamt[g_zei][g_sp].liste[zeile][spalte] = zaehler;
zaehler++;
if (zaehler == 10) {zaehler = 1;}
}}}}
/*Im Folgenden werden zunächst zwei for-Schleifen durchlaufen, eine für
die Zeilen des Arrays gesamt[9][9] (das aus Strukturen besteht) und eine
für die Spalten.
In diesen zwei Schleifen befinden sich wiederum neun (else) if-Anweisungen, die
die Komponenten ".wert" der Strukturen betrachtet. Falls dieser Wert Null ist, d.h.
falls in dieser Sudoku-Zelle noch kein fester Wert steht, so passiert nichts.
Falls jedoch in dieser Zelle schon ein Wert steht, so werden die betroffenen Streich-
listen aktualisiert:
Mit zwei weitere for-Schleifen werden alle Felder des Arrays gesamt[][] durchlaufen,
die die gleiche Zeile bzw. die gleiche Spalte haben, wie das Feld, in dem bereits ein
fester Wert steht. Der Wert, der in dieser einen Zelle schon steht, wird nun in allen
Streichlisten, die sich in dieser Zeile bzw. Spalte befinden gleich Null gesetzt.
Dieses Prozedere wird nun für alle Zellen des Arrays gesamt[][] durchgeführt.*/
for (x = 0; x < 9; x++) {
for (y = 0; y < 9; y++) {
if (gesamt[x][y].wert == 1) {
for (a = 0; a < 9; a++) {
for (b = 0; b < 9; b++) {
gesamt[a][y].liste[0][0] = 0;
gesamt[x][b].liste[0][0] = 0;
}}
}
else if (gesamt[x][y].wert == 2) {
for (a = 0; a < 9; a++) {
for (b = 0; b < 9; b++) {
gesamt[a][y].liste[0][1] = 0;
gesamt[x][b].liste[0][1] = 0;
}}
}
else if (gesamt[x][y].wert == 3) {
for (a = 0; a < 9; a++) {
for (b = 0; b < 9; b++) {
gesamt[a][y].liste[0][2] = 0;
gesamt[x][b].liste[0][2] = 0;
}}
}
else if (gesamt[x][y].wert == 4) {
for (a = 0; a < 9; a++) {
for (b = 0; b < 9; b++) {
gesamt[a][y].liste[1][0] = 0;
gesamt[x][b].liste[1][0] = 0;
}}
}
else if (gesamt[x][y].wert == 5) {
for (a = 0; a < 9; a++) {
for (b = 0; b < 9; b++) {
gesamt[a][y].liste[1][1] = 0;
gesamt[x][b].liste[1][1] = 0;
}}
}
else if (gesamt[x][y].wert == 6) {
for (a = 0; a < 9; a++) {
for (b = 0; b < 9; b++) {
gesamt[a][y].liste[1][2] = 0;
gesamt[x][b].liste[1][2] = 0;
}}
}
else if (gesamt[x][y].wert == 7) {
for (a = 0; a < 9; a++) {
for (b = 0; b < 9; b++) {
gesamt[a][y].liste[2][0] = 0;
gesamt[x][b].liste[2][0] = 0;
}}
}
else if (gesamt[x][y].wert == 8) {
for (a = 0; a < 9; a++) {
for (b = 0; b < 9; b++) {
gesamt[a][y].liste[2][1] = 0;
gesamt[x][b].liste[2][1] = 0;
}}
}
else if (gesamt[x][y].wert == 9) {
for (a = 0; a < 9; a++) {
for (b = 0; b < 9; b++) {
gesamt[a][y].liste[2][2] = 0;
gesamt[x][b].liste[2][2] = 0;
}}
}
/*Nachdem die Zeilen und Spalten der Streichlisten nun aktualisiert
wurden, muss man sich noch um die 9 3x3-Blöcke kümmern. Dies geschieht
mit der Funktion blockdurchlauf() (siehe unten).
Dabei durchlaufen m und n jeweils eine for-Schleife mit Schrittweite 3,
insgesamt nehmen m und n folglich dabei die Werte 0, 3 und 6 an.
m und n werden schließlich unten von blockdurchlauf() aufgerufen.*/
for (m = 0; m < 9; m += 3) {
for (n = 0; n < 9; n += 3) {
blockdurchlauf(m,n);
}}
}}}
void blockdurchlauf(int m, int n) {
/*Im Folgenden werden mit den beiden for-Schleifen über e und f die Zeilen
und Spalten des Arrays gesamt[9][9] durchlaufen. In jeder Zelle wird dann
die Komponente ".wert" mit der Laufvariablen g verglichen.
Falls diese beiden für irgendeinen Wert von g übereinstimmen (sprich: falls
in irgendeiner Zelle von gesamt[][] bereits ein fester Wert steht), dann werden
mit Hilfe von if-Anweisungen und einer weiteren for-Schleife mit Laufvariablen h
bei allen Streichlisten in dem betreffenden 3x3-Block des Sudokus dieser Wert
gleich Null gesetzt.*/
int e, f, g, h, k, l;
/*e durchläuft drei Werte (0,1,2 oder 3,4,5 oder 6,7,8): die Zeilen von gesamt[][]*/
for (e = m; e < (m+3); e++) {
/*f durchläuft die gleichen Werte wie e: die Spalten von gesamt[][]*/
for (f = n; f < (n+3); f++) {
/*g durchläuft die Werte 1 bis 4*/
for (g = 1; g < 4; g++) {
/*Falls der Wert der e-ten Zeile und f-ten Spalte gleich 1,2 oder 3 ist,
beginnen zwei weitere for-Schleifen*/
if (gesamt[e][f].wert == g) {
/*In den beiden folgenden Schleifen durchlaufen k und l die gleichen
Werte wie e und f.*/
for (k = m; k < (m+3); k++) {
for (l = n; l < (n+3); l++) {
/*Alle festen Werte, die in den oberen Schleifen gefunden wurden
werden aus den Streichlisten gestrichen (bzw. gleich 0 gesetzt).*/
gesamt[k][l].liste[0][g-1] = 0;
/*[g-1] muss man schreiben, weil der Wert 1 in .liste[0][0] steht,
der Wert 2 in .liste[0][1] und der Wert 3 in .liste[0][2].*/
}}}}
for (g = 4; g < 7; g++) {
if (gesamt[e][f].wert == g) {
for (k = m; k < (m+3); k++) {
for (l = n; l < (n+3); l++) {
gesamt[k][l].liste[1][g-4] = 0;
/*[g-4] muss man schreiben, weil der Wert 4 in .liste[1][0] steht,
der Wert 5 in .liste[1][1] und der Wert 6 in .liste[1][2].*/
}}}}
for (g = 7; g < 10; g++) {
if (gesamt[e][f].wert == g) {
for (k = m; k < (m+3); k++) {
for (l = n; l < (n+3); l++) {
gesamt[k][l].liste[2][g-7] = 0;
/*[g-7] muss man schreiben, weil der Wert 7 in .liste[2][0] steht,
der Wert 8 in .liste[2][1] und der Wert 9 in .liste[2][2].*/
}}}}
}}}
void printGrid()
{
/*Im Folgenden werden jeweils die notwendigen Funktionen zeile1-6() (siehe unten) aufgerufen,
so dass im Endeffekt ein Sudoku-Gitter entsteht, dass die Streichliste, bzw. den feststehenden
Wert in die jeweilige Zelle schreibt.*/
printf("#########################################################################");printf("\n#");
zeile1(0,0);zeile1(0,1);zeile4(0,2);zeile1(0,3);zeile1(0,4);zeile4(0,5);zeile1(0,6);zeile1(0,7);zeile4(0,8);printf("\n#");
zeile2(0,0);zeile2(0,1);zeile5(0,2);zeile2(0,3);zeile2(0,4);zeile5(0,5);zeile2(0,6);zeile2(0,7);zeile5(0,8);printf("\n#");
zeile3(0,0);zeile3(0,1);zeile6(0,2);zeile3(0,3);zeile3(0,4);zeile6(0,5);zeile3(0,6);zeile3(0,7);zeile6(0,8);printf("\n#");
printf("-------+-------+-------#-------+-------+-------#-------+-------+-------#");printf("\n#");
zeile1(1,0);zeile1(1,1);zeile4(1,2);zeile1(1,3);zeile1(1,4);zeile4(1,5);zeile1(1,6);zeile1(1,7);zeile4(1,8);printf("\n#");
zeile2(1,0);zeile2(1,1);zeile5(1,2);zeile2(1,3);zeile2(1,4);zeile5(1,5);zeile2(1,6);zeile2(1,7);zeile5(1,8);printf("\n#");
zeile3(1,0);zeile3(1,1);zeile6(1,2);zeile3(1,3);zeile3(1,4);zeile6(1,5);zeile3(1,6);zeile3(1,7);zeile6(1,8);printf("\n#");
printf("-------+-------+-------#-------+-------+-------#-------+-------+-------#");printf("\n#");
zeile1(2,0);zeile1(2,1);zeile4(2,2);zeile1(2,3);zeile1(2,4);zeile4(2,5);zeile1(2,6);zeile1(2,7);zeile4(2,8);printf("\n#");
zeile2(2,0);zeile2(2,1);zeile5(2,2);zeile2(2,3);zeile2(2,4);zeile5(2,5);zeile2(2,6);zeile2(2,7);zeile5(2,8);printf("\n#");
zeile3(2,0);zeile3(2,1);zeile6(2,2);zeile3(2,3);zeile3(2,4);zeile6(2,5);zeile3(2,6);zeile3(2,7);zeile6(2,8);printf("\n#");
printf("########################################################################");printf("\n#");
zeile1(3,0);zeile1(3,1);zeile4(3,2);zeile1(3,3);zeile1(3,4);zeile4(3,5);zeile1(3,6);zeile1(3,7);zeile4(3,8);printf("\n#");
zeile2(3,0);zeile2(3,1);zeile5(3,2);zeile2(3,3);zeile2(3,4);zeile5(3,5);zeile2(3,6);zeile2(3,7);zeile5(3,8);printf("\n#");
zeile3(3,0);zeile3(3,1);zeile6(3,2);zeile3(3,3);zeile3(3,4);zeile6(3,5);zeile3(3,6);zeile3(3,7);zeile6(3,8);printf("\n#");
printf("-------+-------+-------#-------+-------+-------#-------+-------+-------#");printf("\n#");
zeile1(4,0);zeile1(4,1);zeile4(4,2);zeile1(4,3);zeile1(4,4);zeile4(4,5);zeile1(4,6);zeile1(4,7);zeile4(4,8);printf("\n#");
zeile2(4,0);zeile2(4,1);zeile5(4,2);zeile2(4,3);zeile2(4,4);zeile5(4,5);zeile2(4,6);zeile2(4,7);zeile5(4,8);printf("\n#");
zeile3(4,0);zeile3(4,1);zeile6(4,2);zeile3(4,3);zeile3(4,4);zeile6(4,5);zeile3(4,6);zeile3(4,7);zeile6(4,8);printf("\n#");
printf("-------+-------+-------#-------+-------+-------#-------+-------+-------#");printf("\n#");
zeile1(5,0);zeile1(5,1);zeile4(5,2);zeile1(5,3);zeile1(5,4);zeile4(5,5);zeile1(5,6);zeile1(5,7);zeile4(5,8);printf("\n#");
zeile2(5,0);zeile2(5,1);zeile5(5,2);zeile2(5,3);zeile2(5,4);zeile5(5,5);zeile2(5,6);zeile2(5,7);zeile5(5,8);printf("\n#");
zeile3(5,0);zeile3(5,1);zeile6(5,2);zeile3(5,3);zeile3(5,4);zeile6(5,5);zeile3(5,6);zeile3(5,7);zeile6(5,8);printf("\n#");
printf("########################################################################");printf("\n#");
zeile1(6,0);zeile1(6,1);zeile4(6,2);zeile1(6,3);zeile1(6,4);zeile4(6,5);zeile1(6,6);zeile1(6,7);zeile4(6,8);printf("\n#");
zeile2(6,0);zeile2(6,1);zeile5(6,2);zeile2(6,3);zeile2(6,4);zeile5(6,5);zeile2(6,6);zeile2(6,7);zeile5(6,8);printf("\n#");
zeile3(6,0);zeile3(6,1);zeile6(6,2);zeile3(6,3);zeile3(6,4);zeile6(6,5);zeile3(6,6);zeile3(6,7);zeile6(6,8);printf("\n#");
printf("-------+-------+-------#-------+-------+-------#-------+-------+-------#");printf("\n#");
zeile1(7,0);zeile1(7,1);zeile4(7,2);zeile1(7,3);zeile1(7,4);zeile4(7,5);zeile1(7,6);zeile1(7,7);zeile4(7,8);printf("\n#");
zeile2(7,0);zeile2(7,1);zeile5(7,2);zeile2(7,3);zeile2(7,4);zeile5(7,5);zeile2(7,6);zeile2(7,7);zeile5(7,8);printf("\n#");
zeile3(7,0);zeile3(7,1);zeile6(7,2);zeile3(7,3);zeile3(7,4);zeile6(7,5);zeile3(7,6);zeile3(7,7);zeile6(7,8);printf("\n#");
printf("-------+-------+-------#-------+-------+-------#-------+-------+-------#");printf("\n#");
zeile1(8,0);zeile1(8,1);zeile4(8,2);zeile1(8,3);zeile1(8,4);zeile4(8,5);zeile1(8,6);zeile1(8,7);zeile4(8,8);printf("\n#");
zeile2(8,0);zeile2(8,1);zeile5(8,2);zeile2(8,3);zeile2(8,4);zeile5(8,5);zeile2(8,6);zeile2(8,7);zeile5(8,8);printf("\n#");
zeile3(8,0);zeile3(8,1);zeile6(8,2);zeile3(8,3);zeile3(8,4);zeile6(8,5);zeile3(8,6);zeile3(8,7);zeile6(8,8);printf("\n#");
printf("########################################################################\n");
}
/*Im Folgenden werden sechs Funktionen zeile1-6() definiert, die zwei int-Variablen erwarten.
Der Sinn dabei ist, dass dadurch die sechs verschiedenen Arten von "Zeilen", die im Sudoku benötigt werden
mit Hilfe von Schleifen umgesetzt werden können ("Zeilen" meint dabei die Zeichenkette vom linken bis zum
rechten Rand einer Zelle, wobei unterschieden werden muss, ob in der betreffenden Zelle schon ein fester Wert
steht, oder ob die Streichliste hineingeschrieben werden soll. Dies wiederum wird in jeder zeile()-Funktion
mit einer if-Anweisung umgesetzt.
Diese besagt jeweils, dass in den Zeilen 1 und 3 einer Zelle abgesehen vom Rahmen nichts steht, falls schon ein
fester Wert in dieser Zelle steht. Falls noch kein fester Wert in der Zelle steht, dann werden in diese beiden
Zeilen die verbleibenden Werte (1, 2, 3 oder 7, 8, 9) der Streichliste geschrieben.
In die mittlere Zeile (Zeile 2) einer Zelle wird entweder der schon feststehende Wert, oder die restlichen Werte
der Streichliste (4, 5, 6) geschrieben).
Auf insgesamt 6 zeilen()-Funktionen kommt man, weil immer noch unterschieden werden muss, ob die Zellen voneinander
mit | oder # getrennt sind.
Die beiden int-Werte c und d, die die Funktion erwartet meinen übrigens immer die Zelle, die durch die c+1-te Zeile
und die d+1-te Spalte beschrieben wird.*/
void zeile1(int c, int d) {
if (gesamt[c][d].wert != 0) {
printf(" |");
}
else {for (i = 0; i < 3; i++) {
if (gesamt[c][d].liste[0][i] == 0) {
printf(" ");
}
else { printf(" %d", gesamt[c][d].liste[0][i]);}
}
printf(" |");
}}
void zeile2(int c, int d) {
if (gesamt[c][d].wert != 0) {
printf(" %d |", gesamt[c][d].wert);
}
else {for (i = 0; i < 3; i++) {
if (gesamt[c][d].liste[1][i] == 0) {
printf(" ");
}
else { printf(" %d", gesamt[c][d].liste[1][i]);}
}
printf(" |");
}}
void zeile3(int c, int d) {
if (gesamt[c][d].wert != 0) {
printf(" |");
}
else {for (i = 0; i < 3; i++) {
if (gesamt[c][d].liste[2][i] == 0) {
printf(" ");
}
else { printf(" %d", gesamt[c][d].liste[2][i]);}
}
printf(" |");
}}
void zeile4(int c, int d) {
if (gesamt[c][d].wert != 0) {
printf(" #");
}
else {for (i = 0; i < 3; i++) {
if (gesamt[c][d].liste[0][i] == 0) {
printf(" ");
}
else { printf(" %d", gesamt[c][d].liste[0][i]);}
}
printf(" #");
}}
void zeile5(int c, int d) {
if (gesamt[c][d].wert != 0) {
printf(" %d #", gesamt[c][d].wert);
}
else {for (i = 0; i < 3; i++) {
if (gesamt[c][d].liste[1][i] == 0) {
printf(" ");
}
else { printf(" %d", gesamt[c][d].liste[1][i]);}
}
printf(" #");
}}
void zeile6(int c, int d) {
if (gesamt[c][d].wert != 0) {
printf(" #");
}
else {for (i = 0; i < 3; i++) {
if (gesamt[c][d].liste[2][i] == 0) {
printf(" ");
}
else { printf(" %d", gesamt[c][d].liste[2][i]);}
}
printf(" #");
}}