# Prgramm zu kürzen



## discere (23. Nov 2012)

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


```
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);

			
		}
	}
		
}
```


----------



## SlaterB (23. Nov 2012)

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

```
if(1 <a && a <4) golX[x][y] = true;
 else golX[x][y] = false;
```
in jedem Fall, wobei bei

```
if ( a == 3) golB[x][y] = true;
```
im else-Fall gar nichts passiert, evtl. also noch bisschen komplizierter, kenne gerade die Regeln nicht genau


----------



## Kevin94 (23. Nov 2012)

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:

```
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.


----------



## Marco13 (23. Nov 2012)

Es gibt schon viele Threads dazu. In Anbetracht von http://www.java-forum.org/hausaufgaben/108203-spiel-lebens.html sollte ich "Alles wiederholt sich" vielleicht zu meiner Signatur machen. Ich bin nicht sicher, ob ... die "stilistischen Schwerpunkte" (oder wie man das sagen soll) zu diesem Thread hier passen, aber ... es gibt auch welche, wo es rudimentärer zuging (d.h. direkt auf den Arrays gearbeitet wurde).


----------



## JohannisderKaeufer (23. Nov 2012)

Sowas, kann man in zwei Schritten vereinfachen

```
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 

```
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

```
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.

```
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.

```
for(int[] n : neighbours) {
  a += test(x,y,n[0],n[1]);
}
```


----------



## pappawinni (24. Nov 2012)

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.


----------

