Prgramm zu kürzen

D

discere

Mitglied
Ich schreibe das Programm " spiel des lebens". Es funktioniert! Ich denke, es ist zu viel! Wie kann ich das Programm kürzen. Das möchte ich auch lernen. Könnt ihr mir tipps geben. Danke

Java: 
package gdp.stdlib;


public class SDL {


	public static void visualize(boolean[][] gol) {
		while (true){
		StdDraw.clear();

		for (int i = 0; i < gol.length; ++i) {
			for (int j = 0; j < gol[i].length; ++j) {
				if (gol[i][j]) {
					StdDraw.setPenColor(StdDraw.BLUE);
					StdDraw.filledCircle(i+0.5, j+0.5, 0.5);
				}
			}	

		}
		StdDraw.show(500);

		 
		
			boolean [][] golX =  new boolean[gol.length][gol[0].length];
			boolean [][] golB =  new boolean[gol.length][gol[0].length]; 
			boolean [][] golnew =  new boolean[gol.length][gol[0].length]; 

	
		for( int x = 0; x < gol.length; ++x) {
			for(int y =0; y < gol[x].length; ++y) {

			
			//Zelle bleiben oder tot
		
					if(gol[x][y]){		//1 T Field
						
						int a;
						if ( x == 0 && y == 0) { //1
							a = 0;
							if(gol[x][y+1]) a++;
							if (gol[x+1][y]) a++;
							if (gol[x+1][y+1]) a++;
							
							if( 1<a && a <4) golX[x][y] = true;
							else golX[x][y] = false;
						}
				    	   
			        	if ( y == 0 && x < gol.length-1 && 0 < x) { // 2
			        		a = 0;
			        		if(gol[x-1][y]) a++;
			        		if(gol[x-1][y+1]) a++;
			        		if(gol[x][y+1]) a++;
			        		if(gol[x+1][y+1]) a++;
			        		if(gol[x+1][y]) a++;
			        		
			        		if(1 <a && a <4) golX[x][y] = true;
			        		else golX[x][y] = false;
			        		
			        	}
			        	
			        	if ( y == 0 && x == gol.length -1) { //3
			        		
			        		a = 0;
			        		if(gol[x-1][y]) a++;
			        		if(gol[x-1][y+1]) a++;
			        		if(gol[x][y+1]) a++;
			        		
			        		if(1 <a && a <4) golX[x][y] = true;
			        		else golX[x][y] = false;
			        		
			        	}
			        	
			        	if ( y < gol[x].length-1 && 0 <y && x == gol.length-1) { //4
			        		
			        		a =0;
			        		
			        		if(gol[x][y-1]) a++;
			        		if(gol[x-1][y-1]) a++;
			        		if(gol[x-1][y]) a++;
			        		if(gol[x-1][y+1]) a++;
			        		if(gol[x][y+1]) a++;
			        		
			        		if(1 <a && a <4) golX[x][y] = true;
			        		else golX[x][y] = false;
			        		
			        	}
			        	
			        	if (y == gol[x].length-1 && x == gol.length-1) { //5
			        		
			        		a=0;
			        		if(gol[x-1][y])a++;
			        		if(gol[x-1][y-1])a++;
			        		if(gol[x][y-1]) a++;
			        		
			        		if(1 <a && a <4) golX[x][y] = true;
			        		else golX[x][y] = false;
			        		
			        	}
			        	
			        	if (x > 0 && x < gol.length-1 && y == gol[x].length-1 ){ //6
			        		
			        		a =0;
			        		if(gol[x-1][y]) a++;
			        		if(gol[x-1][y-1]) a++;
			        		if(gol[x][y-1]) a++;
			        		if(gol[x+1][y-1])a++;
			        		if(gol[x+1][y])a++;
			        		
			        		if(1 <a && a <4) golX[x][y] = true;
			        		else golX[x][y] = false;
			        		
			        	}
			        	
			        	if (x == 0 && y == gol[x].length-1) { //7
			        		
			        		a =0;
			        		if(gol[x][y-1]) a++;
			        		if(gol[x+1][y-1]) a++;
			        		if(gol[x+1][y])a++;
			        		
			        		if(1 <a && a <4) golX[x][y] = true;
			        		else golX[x][y] = false;
			        		
			        	}
			        	
			        	if ( x == 0 && y< gol[x].length-1 && 0<y) { //8
			        		
			        		a=0;
			        		if(gol[x][y+1])a++;
			        		if(gol[x+1][y+1])a++;
			        		if(gol[x+1][y])a++;
			        		if(gol[x+1][y-1])a++;
			        		if(gol[x][y-1])a++;
			        		
			        		if(1 <a && a <4) golX[x][y] = true;
			        		else golX[x][y] = false;
			        		
			        	}
			        	
						if (0<x && x<gol.length-1 && y>0 && y<gol[x].length-1) {   //9
							 a=0;
							 if(gol[x-1][y-1]) a++;	
						   	 if(gol[x-1][y])a++;
							 if(gol[x-1][y+1])a++;
							 if(gol[x][y-1])a++;
							 if(gol[x][y+1])a++;
							 if(gol[x+1][y-1])a++;
							 if(gol[x+1][y])a++;
							 if(gol[x+1][y+1])a++;
			        		
			       	   	 	if(1 <a && a <4) golX[x][y] = true;
			       	   	 	else golX[x][y] = false;
			        	}
		        	
		           }
					
					
					
					if(!gol[x][y]){		//1 for F Field
						int a;
						
						if ( x == 0 && y == 0) { //1
							a = 0;
							if(gol[x][y+1]) a++;
							if (gol[x+1][y]) a++;
							if (gol[x+1][y+1]) a++;
							
							if ( a == 3) golB[x][y] = true;
							
						}
				    	   
			        	if ( y == 0 && x < gol.length-1 && 0 < x) { // 2
			        		a = 0;
			        		if(gol[x-1][y]) a++;
			        		if(gol[x-1][y+1]) a++;
			        		if(gol[x][y+1]) a++;
			        		if(gol[x+1][y+1]) a++;
			        		if(gol[x+1][y]) a++;
			        		
			        		if ( a == 3) golB[x][y] = true;
			        		
			        	}
			        	
			        	if ( y == 0 && x == gol.length -1) { //3
			        		
			        		a = 0;
			        		if(gol[x-1][y]) a++;
			        		if(gol[x-1][y+1]) a++;
			        		if(gol[x][y+1]) a++;
			        		
			        		if ( a == 3) golB[x][y] = true;
			        		
			        	}
			        	
			        	if ( y < gol[x].length-1 && 0 <y && x == gol.length-1) { //4
			        		
			        		a =0;
			        		
			        		if(gol[x][y-1]) a++;
			        		if(gol[x-1][y-1]) a++;
			        		if(gol[x-1][y]) a++;
			        		if(gol[x-1][y+1]) a++;
			        		if(gol[x][y+1]) a++;
			        		
			        		if ( a == 3) golB[x][y] = true;
			        		
			        	}
			        	
			        	if (y == gol[x].length-1 && x == gol.length-1) { //5
			        		
			        		a=0;
			        		if(gol[x-1][y])a++;
			        		if(gol[x-1][y-1])a++;
			        		if(gol[x][y-1]) a++;
			        		
			        		if ( a == 3) golB[x][y] = true;
			        		
			        	}
			        	
			        	if (x > 0 && x < gol.length-1 && y == gol[x].length-1 ){ //6
			        		
			        		a =0;
			        		if(gol[x-1][y]) a++;
			        		if(gol[x-1][y-1]) a++;
			        		if(gol[x][y-1]) a++;
			        		if(gol[x+1][y-1])a++;
			        		if(gol[x+1][y])a++;
			        		
			        		if ( a == 3) golB[x][y] = true;
			        		
			        	}
			        	
			        	if (x == 0 && y == gol[x].length-1) { //7
			        		
			        		a =0;
			        		if(gol[x][y-1]) a++;
			        		if(gol[x+1][y-1]) a++;
			        		if(gol[x+1][y])a++;
			        		
			        		if ( a == 3) golB[x][y] = true;
			        		
			        	}
			        	
			        	if ( x == 0 && y< gol[x].length-1 && 0<y) { //8
			        		
			        		a=0;
			        		if(gol[x][y+1])a++;
			        		if(gol[x+1][y+1])a++;
			        		if(gol[x+1][y])a++;
			        		if(gol[x+1][y-1])a++;
			        		if(gol[x][y-1])a++;
			        		
			        		if ( a == 3) golB[x][y] = true;
			        		
			        	}
			        	
						if (0<x && x<gol.length-1 && y>0 && y<gol[x].length-1) {   //9
							 a=0;
							 if(gol[x-1][y-1]) a++;	
						   	 if(gol[x-1][y])a++;
							 if(gol[x-1][y+1])a++;
							 if(gol[x][y-1])a++;
							 if(gol[x][y+1])a++;
							 if(gol[x+1][y-1])a++;
							 if(gol[x+1][y])a++;
							 if(gol[x+1][y+1])a++;
			        		
			       	   	 	if ( a == 3) golB[x][y] = true;
			        	}
			        	
				}
					
			}
			
					
		}

			for (int x =0; x < gol.length; ++x ) {
				for(int y = 0 ; y < gol[x].length; ++y){
					if (!golX[x][y] && golB[x][y]) 
					golX[x][y] = true;
					
					
		} 
	}
				gol = golX;
				golB = golnew; 
				golX = golnew;
	}
}	
	
	
	public static void main(String[] args) {

		int x = 10; //Integer.parseInt(args[0]);
		int y = 10; //Integer.parseInt(args[0]);
		
		StdDraw.setXscale(0, x);
		StdDraw.setYscale(0, y);
		StdDraw.show(50);
		
		boolean[][] gol = new boolean[x][y];
		
		for (int i = 0; i < x; ++i) {
			for (int j = 0; j < y; ++j) {
				gol[i][j] = (Math.random() >= 0.5)?true:false;
			}
		}
		while (true) {
			visualize(gol);

			
		}
	}
		
}
 
S

SlaterB

Gast
wenn du gol nur g nennen würdest wäre schon ein gewisser Prozentsatz Quellcode gespart..,
deine vielen Unterscheidungen sind abhängig von der Position, am Rand oder in der Mitte?

verzichte auf die Unterscheidungen, frühstühige die Berechnung von a in einem Durchlauf ab,
dafür dann bisschen komplizierter für alle Nachbarn:
if(test(x-1,y-1)) a++;
if(test(x-1,y)) a++;
usw.
die Methode test schaut, ob die beiden Indexe eine Position außerhalb des Spielfelds beschreiben (< 0, >= length usw.),
gibt dann fallse zurück, schaut ansonsten im Array nach

-------

was du danach mit a machen musst sehe ich noch nicht so ganz, da hast du mindestens 2 Varianten,
vielleicht reicht
Java: 
 if(1 <a && a <4) golX[x][y] = true;
 else golX[x][y] = false;
in jedem Fall, wobei bei
Java: 
 if ( a == 3) golB[x][y] = true;
im else-Fall gar nichts passiert, evtl. also noch bisschen komplizierter, kenne gerade die Regeln nicht genau
 
K

Kevin94

Top Contributor
Da lässt sich einiges wegkürzen. Zu aller erst sei mal gesagt, das es zu einem if auch else else if gibt, einige der if's sind redundant. Das macht den Code zwar nicht kürzer aber logisch besser und in der Ausführung ein winzig kleines bisschen schneller.
Dann würde ich diese ewige unterscheidung ob du dich gerade am Rand befindes sein lassen und vor dem prüfen der einzelnen Zellen schauen, ob die Koordinate nicht ausserhalb des Arrays ist, so spart du dir eine Menge redundanten Code. Ausserdem kann man die Unterscheidung ob die Zelle gesetz war oder nicht auch erst nach dem berechnen, wie viele Zellen aussenrum gesetzt sind machen. Die este und zweite Schleife kann man ausserdem zu einer zusammenfassen.
So zusammengekürzt wäre das der ganze Inhalt der einen for-Schleife:
Java: 
a=0;
if(x>0 && y>0 && gol[x-1][y-1]) a++; 
if(x>0 && gol[x-1][y])a++;
if(x>0 && y<(gol[x].length-1) && gol[x-1][y+1])a++;
if(y>0 && gol[x][y-1])a++;
if(y<(gol[x].length-1) && gol[x][y+1])a++;
if(x<(gol.length-1) && y>0 gol[x+1][y-1])a++;
if(x<(gol.length-1) && gol[x+1][y])a++;
if(x<(gol.length-1) && y<(gol[x].length-1) && gol[x+1][y+1])a++;
                  
if(gol[x][y] && 1 <a && a <4) golX[x][y] = true;
else if (gol[x][y]) golX[x][y] = false;
else if (!gol[x][y] && a == 3) golB[x][y] = true;

if (!golX[x][y] && golB[x][y])  golX[x][y] = true;

Inwiefern du die Arrays golX,bolB und golnew überhaupt brauchst oder ob dir ein einziges Pufferarray reicht kann ich nicht sagen, so genau kenn ich die Regeln dann auch nicht.

Mit ner Methode zum Testen der Indizes wie bei SlaterB gehts natürlich auch, macht das ganze wesentlich übersichtlicher.
 
J

JohannisderKaeufer

Gast
Sowas, kann man in zwei Schritten vereinfachen
Java: 
if(gol[x-1][y-1]) a++; 
if(gol[x-1][y])a++;
if(gol[x-1][y+1])a++;
if(gol[x][y-1])a++;
if(gol[x][y+1])a++;
if(gol[x+1][y-1])a++;
if(gol[x+1][y])a++;
if(gol[x+1][y+1])a++;

Zum einen kann man sich ein int[][] nachbarn erstellen, indem alle Kombinationen zu einem Nachbarn zu gelangen vorhanden sind
(-1, -1) (-1, 0) (-1,1) (0, -1) (0,1) (1, -1) (1, 0) (1,1)

also
Java: 
int[][] neighbours = int[8][2];
int[] n0 = {-1,-1};
neighbours[0] = n0;
...
Das müßte insofern nur ein mal erstellt werden.

Dann könnte man darüber iterieren
Java: 
for(int[] n : neighbours) {
  if(gol[x+n[0]][y+n[1]]) a++;
}

nimmt man nun für gol[][] integer Werte anstatt booleans, (0 = false, 1 = true)
dann bräuchte man an dieser Stelle nur iterieren.
Java: 
for(int[] n : neighbours) {
  a += (gol[x+n[0]][y+n[1]]);
}

Eine Methode test, die überprüft ob ein Nachbar vorhanden ist könnte man auch so definieren, daß sie wenn einen int Wert zurückgibt. Und zwar 0 für false, 1 für true und falls der Nachbar nicht vorhanden ist auch 0.
Dann könnte die Schleife auch so aussehen.
Java: 
for(int[] n : neighbours) {
  a += test(x,y,n[0],n[1]);
}
 
P

pappawinni

Gast
Was sich gerne wiederholen dürfte wäre, dass der "Danke"-Button benutzt wird, wenn ein Hinweis hilfreich war und auch,
dass der Button "Thema als 'erledigt' markieren" betätigt wird, wenn die Frage hinreichend beantwortet ist.
;)
 

Aktuelle Jobs

Neue Themen


Oben