import java.util.Scanner;
import java.io.PrintStream;

public class tegelzetten2 {

	//full title: public class tegelzettenOpgave2, char[] representatie van 'm'

	/*~~~~~~~~~~ 
	
	Maak een rechthoek van 27 hoog x 23 breed met de volgende stenen: 
	
		A 	1x1
		B 	2x2
		C 	3x3
		D 	4x4
		E 	5x5
		F 	6x6
		G 	7x7
		H 	8x8
		I 	9x9
		J 	10x10
		K	6x7
		L 	6x3
		M	8x9
		N	10x4
		O	8x8
	
	Over dit programma: 
	- Dit programma maakt een matrix 'm' met daarin alle tegels op een random positie. Overlappingen komen voor.
	- Het programma is specifiek geschreven voor opgave 2. Matrix 'm' is een 27x23 matrix + nog wat ruimte om het programma niet meteen te laten crashen als tegels buiten het vlak vallen. Samen maakt dit een 37x33 matrix. Als tegels er buiten vallen is dit te zien in de uitvoer.
	- Jouw taak: maak een betere heuristiek dan deze randomiser, zodanig dat je een oplossing vindt.
	
	*/
	

	//------------------ Variabelen -------------------------

	char[][]	A	= { {'A'} };
	char[][] B	= { {'B','B'}, {'B','B'} };
	char[][] C	= { {'C', 'C', 'C' } , { 'C', 'C', 'C'} , { 'C', 'C', 'C'} };
	char[][] D	= { {'D', 'D', 'D', 'D' } , { 'D', 'D', 'D', 'D' } , { 'D', 'D', 'D', 'D' } , { 'D', 'D', 'D', 'D' } };
	char[][] E	= { {'E', 'E', 'E', 'E', 'E' } , { 'E', 'E', 'E', 'E', 'E' } , { 'E', 'E', 'E', 'E', 'E' } , { 'E', 'E', 'E', 'E', 'E' } , { 'E', 'E', 'E', 'E', 'E'} };
	char[][] F	= { {'F', 'F', 'F', 'F', 'F', 'F' } , { 'F', 'F', 'F', 'F', 'F', 'F' } , { 'F', 'F', 'F', 'F', 'F', 'F'} , { 'F', 'F', 'F', 'F', 'F', 'F'} , { 'F', 'F', 'F', 'F', 'F', 'F' } , { 'F', 'F', 'F', 'F', 'F', 'F'} };
	char[][] G	= { {'G', 'G', 'G', 'G', 'G', 'G', 'G' } , { 'G', 'G', 'G', 'G', 'G', 'G', 'G' } , { 'G', 'G', 'G', 'G', 'G', 'G', 'G'} , { 'G', 'G', 'G', 'G', 'G', 'G', 'G'} , { 'G', 'G', 'G', 'G', 'G', 'G', 'G'} , { 'G', 'G', 'G', 'G', 'G', 'G', 'G'} , { 'G', 'G', 'G', 'G', 'G', 'G', 'G' } };
	char[][] H	= { {'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H' } , { 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H' } , { 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H' } , { 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H' } , { 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H' } , { 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H' } , { 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H' } , { 'H', 'H', 'H', 'H', 'H', 'H', 'H', 'H'  } };
	char[][] I	= { {'I', 'I', 'I', 'I', 'I', 'I', 'I', 'I', 'I' } , { 'I', 'I', 'I', 'I', 'I', 'I', 'I', 'I', 'I' } , { 'I', 'I', 'I', 'I', 'I', 'I', 'I', 'I', 'I' } , { 'I', 'I', 'I', 'I', 'I', 'I', 'I', 'I', 'I' } , { 'I', 'I', 'I', 'I', 'I', 'I', 'I', 'I', 'I' } , { 'I', 'I', 'I', 'I', 'I', 'I', 'I', 'I', 'I' } , { 'I', 'I', 'I', 'I', 'I', 'I', 'I', 'I', 'I' } , { 'I', 'I', 'I', 'I', 'I', 'I', 'I', 'I', 'I' } , { 'I', 'I', 'I', 'I', 'I', 'I', 'I', 'I', 'I' } };
	char[][] J	= { {'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J' } , { 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J' } , { 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J' } , { 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J' } , { 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J' } , { 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J' } , { 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J' } , { 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J' } , { 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J' } , { 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J', 'J' } };
	char[][] K	= { {'K','K','K','K','K','K','K' } , { 'K','K','K','K','K','K','K' } , { 'K','K','K','K','K','K','K' } , { 'K','K','K','K','K','K','K' } , { 'K','K','K','K','K','K','K' } , { 'K','K','K','K','K','K','K' } };
	char[][] L	= { {'L','L','L' } , { 'L','L','L' } , { 'L','L','L' } , { 'L','L','L' } , { 'L','L','L' } , { 'L','L','L' } };
	char[][] M	= { {'M','M','M','M','M','M','M','M','M' } , { 'M','M','M','M','M','M','M','M','M' } , { 'M','M','M','M','M','M','M','M','M' } , { 'M','M','M','M','M','M','M','M','M' } , { 'M','M','M','M','M','M','M','M','M' } , { 'M','M','M','M','M','M','M','M','M' } , { 'M','M','M','M','M','M','M','M','M' } , { 'M','M','M','M','M','M','M','M','M' } };
	char[][] N	= { {'N','N','N','N'} , { 'N','N','N','N'} , { 'N','N','N','N'} , { 'N','N','N','N'} , { 'N','N','N','N'} , { 'N','N','N','N'} , { 'N','N','N','N'} , { 'N','N','N','N'} , { 'N','N','N','N'} , { 'N','N','N','N' } };
	char[][] O	= { {'O','O','O','O','O','O','O','O' } , { 'O','O','O','O','O','O','O','O'} , { 'O','O','O','O','O','O','O','O' } , { 'O','O','O','O','O','O','O','O' } , { 'O','O','O','O','O','O','O','O'} , { 'O','O','O','O','O','O','O','O' } , { 'O','O','O','O','O','O','O','O' } , { 'O','O','O','O','O','O','O','O' } };

	char[][] m = new char [37][33];   //lege matrix. Extra groot vanwege out of bounds, eigenlijk 27x23
	
	PrintStream out;
	


	
	//------------------ Start -------------------------
	
	
	public void start(){
	
		//maakt Matrix m met daarin alle tegels op een random positie. Overlappingen komen voor. 
	
		m = prepareMatrix(m);
			
		//maken van matrix m:

			//write one A
			int rij = (int) (Math.random()*26);	 //zoek maar tot 26 om out of bounds te voorkomen
			int kolom = (int) (Math.random()*22);
			draw('A', m, rij, kolom);
			printMatrix(m);	

			//write one B
			rij = (int) (Math.random()*25); 
			kolom = (int) (Math.random()*21);
			draw('B', m, rij, kolom);
			printMatrix(m);	

			//write one C
			rij = (int) (Math.random()*24); 	//zoek maar tot 24 om out of bounds te voorkomen
			kolom = (int) (Math.random()*20);
			draw('C', m, rij, kolom);
			printMatrix(m);	

			//write one D
			rij = (int) (Math.random()*23); 	//zoek maar tot 23 om out of bounds te voorkomen
			kolom = (int) (Math.random()*19);
			draw('D', m, rij, kolom);
			printMatrix(m);	

			//write one E
			rij = (int) (Math.random()*22); 	//zoek maar tot 22 om out of bounds te voorkomen
			kolom = (int) (Math.random()*18);
			draw('E', m, rij, kolom);
			printMatrix(m);	

			//write one F
			rij = (int) (Math.random()*21); //zoek maar tot 21 om out of bounds te voorkomen 
			kolom = (int) (Math.random()*17);
			draw('F', m, rij, kolom);
			printMatrix(m);	

			//write one G
			rij = (int) (Math.random()*20); //zoek maar tot 20 om out of bounds te voorkomen
			kolom = (int) (Math.random()*16);
			draw('G', m, rij, kolom);
			printMatrix(m);	

			//write one H
			rij = (int) (Math.random()*19); //zoek maar tot 19 om out of bounds te voorkomen 
			kolom = (int) (Math.random()*15);
			draw('H', m, rij, kolom);
			printMatrix(m);	

			//write one I
			rij = (int) (Math.random()*18); //zoek maar tot 18 om out of bounds te voorkomen 
			kolom = (int) (Math.random()*14);
			draw('I', m, rij, kolom);
			printMatrix(m);	

			//write one J
			rij = (int) (Math.random()*17); //zoek maar tot 17 om out of bounds te voorkomen 
			kolom = (int) (Math.random()*13);
			draw('J', m, rij, kolom);
			printMatrix(m);	

			//write one K
			rij = (int) (Math.random()*21); //zoek maar tot 21 om out of bounds te voorkomen 
			kolom = (int) (Math.random()*16);
			draw('K', m, rij, kolom);
			printMatrix(m);	

			//write one L
			rij = (int) (Math.random()*21); //zoek maar tot 21 om out of bounds te voorkomen 
			kolom = (int) (Math.random()*20);
			draw('L', m, rij, kolom);
			printMatrix(m);	

			//write one M
			rij = (int) (Math.random()*19); //zoek maar tot 19 om out of bounds te voorkomen 
			kolom = (int) (Math.random()*14);
			draw('M', m, rij, kolom);
			printMatrix(m);	

			//write one N
			rij = (int) (Math.random()*17); //zoek maar tot 17 om out of bounds te voorkomen 
			kolom = (int) (Math.random()*19);
			draw('N', m, rij, kolom);
			printMatrix(m);	

			//write one O
			rij = (int) (Math.random()*19); //zoek maar tot 19 om out of bounds te voorkomen 
			kolom = (int) (Math.random()*15);
			draw('O', m, rij, kolom);
			printMatrix(m);					
		
	}

		
	
	//schrijf de letter naar de matrix m op positie [rij,kolom]
	public char[][] draw (char letter, char[][] m, int rij, int kolom) {
				
		if(letter == 'A'){  	//A=1x1		
			//schrijf A naar het bord:			
			m[rij][kolom] = 'A';
		} else if (letter == 'B'){	//B=2x2
			//schrijf B naar het bord:			
			for (int i=rij; i<=rij+1; i++) {
				for (int j=kolom; j<=kolom+1; j++) {
						m[i][j] = 'B';
				}
			}
		} else if(letter == 'C'){  	//C=3x3
			//schrijf C naar het bord:			
			for (int i=rij; i<rij+3; i++) {
				for (int j=kolom; j<kolom+3; j++) {
						m[i][j] = 'C';
				}
			}
		} else if(letter == 'D'){  	//D=4x4
			//schrijf D naar het bord:			
			for (int i=rij; i<rij+4; i++) {
				for (int j=kolom; j<kolom+4; j++) {
						m[i][j] = 'D';
				}
			}
		} else if(letter == 'E'){  	//E=5x5
			//schrijf E naar het bord:			
			for (int i=rij; i<rij+5; i++) {
				for (int j=kolom; j<kolom+5; j++) {
						m[i][j] = 'E';
				}
			}
		} else if(letter == 'F'){  	//F=6x6
			//schrijf C naar het bord:			
			for (int i=rij; i<rij+6; i++) {
				for (int j=kolom; j<kolom+6; j++) {
						m[i][j] = 'F';
				}
			}			
		} else if(letter == 'G'){  	//G=7x7
			//schrijf G naar het bord:			
			for (int i=rij; i<rij+7; i++) {
				for (int j=kolom; j<kolom+7; j++) {
						m[i][j] = 'G';
				}
			}
		} else if(letter == 'H'){  	//H=8x8
			//schrijf H naar het bord:			
			for (int i=rij; i<rij+8; i++) {
				for (int j=kolom; j<kolom+8; j++) {
						m[i][j] = 'H';
				}
			}			
		} else if(letter == 'I'){  	//I=9x9
			//schrijf I naar het bord:			
			for (int i=rij; i<rij+9; i++) {
				for (int j=kolom; j<kolom+9; j++) {
						m[i][j] = 'I';
				}
			}
		} else if(letter == 'J'){  	//J=10x10
			//schrijf J naar het bord:			
			for (int i=rij; i<rij+10; i++) {
				for (int j=kolom; j<kolom+10; j++) {
						m[i][j] = 'J';
				}
			}		
		} else if(letter == 'K'){  	//K=6x7
			//schrijf K naar het bord:			
			for (int i=rij; i<rij+6; i++) {
				for (int j=kolom; j<kolom+7; j++) {
						m[i][j] = 'K';
				}
			}
		} else if(letter == 'L'){  	//L=6x3
			//schrijf L naar het bord:			
			for (int i=rij; i<rij+6; i++) {
				for (int j=kolom; j<kolom+3; j++) {
						m[i][j] = 'L';
				}
			}
		} else if(letter == 'M'){  	//M=8x9
			//schrijf M naar het bord:			
			for (int i=rij; i<rij+8; i++) {
				for (int j=kolom; j<kolom+9; j++) {
						m[i][j] = 'M';
				}
			}
		} else if(letter == 'N'){  	//N=10x4
			//schrijf N naar het bord:			
			for (int i=rij; i<rij+10; i++) {
				for (int j=kolom; j<kolom+4; j++) {
						m[i][j] = 'N';
				}
			}						
		} else if(letter == 'O'){  	//O=8x8
			//schrijf O naar het bord:			
			for (int i=rij; i<rij+8; i++) {
				for (int j=kolom; j<kolom+8; j++) {
						m[i][j] = 'O';
				}
			}			
		} else {  
			//Als het geen A-O was, dan is er iets mis
			out.printf("ERROR: draw(): fout in de representatie! Kan %c niet plotten, het is geen ABCD. \n", letter);
		}	
		
		return m;
	}



	
	//------------------ Hulpmethodes -------------------------


	//Maakt een matrix van 37x33, waaronder 27x23 voor de tegels en wat ruimte om out-of-bound errors op te vangen.
	public char[][] prepareMatrix(char[][] m) {

		for (int i=0; i<27; i++) {	
			for (int j=0; j<23; j++){
				m[i][j] = '.';
			}
			for (int j=23; j<33; j++){
				m[i][j] = '*';
			}
		}
		
		for (int i=27; i<37; i++) {	
			for (int j=0; j<33; j++){
				m[i][j] = '*';
			}
		}
		
		return m;
	}



	//print een letter op het scherm
	public void printLetter(char[][] c){

		for (int i=0; i<c.length; i++) {	
			for (int j=0; j<c[0].length; j++){
				out.print(c[i][j]);
			}
			out.println();
		}
	}



	//print matrix m op het scherm
	public void printMatrix(char[][] m){

		for (int i=0; i<37; i++) {	
			for (int j=0; j<33; j++){
				out.print(m[i][j]);
			}
			out.println();
		}
		out.printf("\n \n");
	}	
	



	
	
	//de constructor  
    tegelzetten2(){
		out = new PrintStream(System.out);
	}
	
	//java begin-nonsense, laten staan	
    public static void main(String[] args) {
		tegelzetten2 t = new tegelzetten2();
		t.start();
	}
	
	

}