#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(" #");
}}