# Feldern Werte zuweisen



## GrindoDingo (5. Jun 2011)

Hi,

Aufgabe 1
Erstellen Sie eine neue Klasse Suchraetsel mit einer main-Methode.
Legen Sie dort ein Feld words vom Typ String und ein zweidimensionales Feld grid vom Typ
char an. Initialisieren Sie words mit den Wörtern, die Sie im Gitter verstecken wollen. An grid
soll ein neues 2D-Array mit Höhe 13 und Breite 30 zugewiesen werden.

Aufgabe 2
Legen Sie eine neue Methode public static void clear(char[][] grid) an. Verwenden Sie
passende Schleifen um jedem Eintrag von grid ein Leerzeichen zuzuweisen. Diese Schleifen sollen
auch dann noch unverändert funktionieren, falls sich die Größe des Felds ändern sollte. Beachten
Sie, dass einzelne Zeichen (char) im Gegensatz zu Zeichenketten (Strings) in einfachen
Anführungszeichen notiert werden.

Aufgabe 3
Schreiben Sie ein neues Unterprogramm public static void print(char[][] c), das den
Inhalt eines zweidimensionalen char-Arrays mit Hilfe von zwei Schleifen auf stdout ausgeben
kann. Die Ausgabe soll am Ende aussehen wie in Abbildung 1, eine Trennung der Buchstaben
einer Zeile beispielsweise durch Leerzeichen ist also nicht erforderlich. Beachten Sie die richtige
Reihenfolge der Koordinaten (in c[0] stehen die Buchstaben der ersten Zeile).


```
public class Suchraetsel {

	public static void main(String[] args) {
		String[] words = { "Hund", "Katze", "Maus" };
		char[][] grid = new char[13][30];
		char[][] c = new char[13][30];
		

	}

	public static void clear(char[][] grid) {
		for (int i = 0; i > grid.length; i = ' ') {
			grid[i][0] = (char) i;
			for (int j = 0; j > grid.length; j = ' ') {
				grid[0][j] = (char) j;
			}
		}
	}

	public static void print(char[][] c) {
		
		for (int i = 0; i > c.length; i = 'a') {
			c[i][0] =  (char)i;
			for (int j = 0; j > c.length; j = 'c') {
				c[0][j] = (char) j;
				System.out.println(c);
			}

		}

	}
	
		
	}
```

Ich hoffe mal, dass meine erste Methode clear stimmt. Das Unterprogramm print stimmt mit sicherheit nicht, weil ich keine ausgabe bekomme. Wo liegt mein Fehler?


----------



## ChrisKu (5. Jun 2011)

Hallo GrindoDingo, da stimmt so einiges nicht, clear() wir so auch nicht funktionieren. Schau dir mal Deine Schleife genau an, die wir nie durchlaufen. Sie soll ja solange durchlaufen werden, wie i > grid.length ist. Du initalisierst "i" aber mit "0"  und damit tritt diese Bedingung nie ein. Auch verstehe ich Deinen letzten Ausdruck in der "for" schleifen nicht, das wird Deinem Schleifenzähler der Wert ' ' zugewiesen?

Also, Deine Schleife in der clear() Methode müsste so beginnen


```
for (int i = 0; i < grid.length; i++) {
//.....
}
```

Dann schaue Dir mal in clear() die zweite innere Schleife an. Neben den Fehlern von der ersten Schleife knüpfst Du die Bedingung auch hier an grid.length, also die Anzahl der Zeilen in grid - Du willst aber hier die Spalten haben, oder?

Hier müsste Deine Schleife so beginnen


```
for (int j = 0; j < grid.length[i]; j++){
//
}
```

Die Zuweisung kannst Du dann insgesamt in der innere Schleife machen. 

Versuche mal mit diesen Hinweisen Deinen Code zu überarbeiten


----------



## Super_Sig (7. Jun 2011)

```
public static void print (char[][] c){

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

				System.out.print(c [i][j]);


			}
			System.out.println();	
		}		
	}
```

So müsste der Print Befehl aufjeden Fall richtig


----------



## nrg (7. Jun 2011)

oder mit for-each:


```
public static void print (char[][] array) {	 
		for(char[] a : array) {
			for (char c : a)
				System.out.print(c);
			System.out.println();   
		}
	}
```


----------



## Andi_CH (7. Jun 2011)

ChrisKu hat gesagt.:


> Hier müsste Deine Schleife so beginnen
> 
> 
> ```
> ...


Falsch.


```
for (int j = 0; j < grid[i].length; j++){
//
}
```

Wäre die richtige Lösung für die innere Schleife

Noch besser ist es auch mit for-each zu initialisieren.
So wie nrg um 12:02 für die Ausgabe vorgeschlagen hat


----------



## ChrisKu (7. Jun 2011)

> Zitat: ChrisKu
> Hier müsste Deine Schleife so beginnen
> 
> 
> ...


_

Hast völlig Recht, typo meinerseits_


----------



## nrg (7. Jun 2011)

Andi_CH hat gesagt.:


> Noch besser ist es auch mit for-each zu initialisieren.



ausgaben ja aber wie soll das bei wertzuweißungen funktionieren?


----------



## Andi_CH (7. Jun 2011)

Bei Wertzuweisungen geht das sehr gut - beim Initialisieren natürlich nicht 

Aufgabe 2: public static void clear(char[][] grid) ....

da würde das perfekt gehen. Na ja - ausser dass da wohl nur die Kopie initialisiert wird, aber das ist ein anderes Thema.


```
public class Test {

	private static char[][] grid;

	private static void init() {
		grid = new char[5][];
		grid[0] = "--- Hello".toCharArray();
		grid[1] = "world".toCharArray();
		grid[2] = "-".toCharArray();
		grid[3] = "Hallo".toCharArray();
		grid[4] = "liebe Welt ---".toCharArray();
	}

	private static void print(char[][] pGrid) {
		// ja ich weiss jetzt notzen gleich wieder ein paar wegen dem pGrid :-)
		// mir ist es egal
		for (char[] ca : pGrid) {
			for (char c : ca) {
				System.out.print(c);
			}
			System.out.print(" ");
		}
		System.out.println();
	}

	private static void clear(char[][] pGrid) {
		for (char[] ca : pGrid) {
			for (char c : ca) {
				c = ' ';
			}
		}
	}

	public static void main(String[] args) {
		init();
		print(grid);
		clear(grid);
		print(grid);
	}
}
```


----------



## Andi_CH (7. Jun 2011)

Da kann der TO jetzt darüber nachdenken, warum die Aufgabe 2, so wie sie gestellt ist, keinen Sinn macht:


```
public class Test {

	private char[][] grid;

	private void init() {
		grid = new char[5][];
		grid[0] = "--- Hello".toCharArray();
		grid[1] = "world".toCharArray();
		grid[2] = "-".toCharArray();
		grid[3] = "Hallo".toCharArray();
		grid[4] = "liebe Welt ---".toCharArray();
	}

	private void print() {
		for (char[] ca : grid) {
			for (char c : ca) {
				System.out.print(c);
			}
			System.out.print(" ");
		}
		System.out.println();
	}

	private static void clear(char[][] pGrid) {
		for (char[] ca : pGrid) {
			for (char c : ca) {
				c = ' ';
			}
		}
	}

	private void clear() {
		for (char[] ca : grid) {
			for (char c : ca) {
				c = ' ';
			}
		}
	}

	public static void main(String[] args) {
		Test t = new Test();
		t.init();
		t.print();
		clear(t.grid);
		t.print();
		t.clear();
		t.print();
	}
}
```


----------



## nrg (7. Jun 2011)

Andi_CH hat gesagt.:


> Da kann der TO jetzt darüber nachdenken, warum die Aufgabe 2, so wie sie gestellt ist, keinen Sinn macht:



warum der to ???:L der vorschlag das array mit einer for-each zu leeren kam doch von dir.


----------



## Andi_CH (7. Jun 2011)

Aehm gehts denn mit for??? Wann ja : Huch !

EDIT: Wirklich Huch! Aber ich kann nicht jedes Mysterium von Java verstehen - vorher verstehe ich warum die Lösung 42 ist oder die Relativitätstheorie aber nicht warum Menschen so inkonsequent arbeiten können. (Wieder ein guter Grund mehr für Ada -> das kennt in, out und inout)


```
private static void clear(char[][] pGrid) {
		for (int i=0; i<pGrid.length; i++) {
			for (int j=0; j<pGrid[i].length; j++) {
				pGrid[i][j] = ' ';
			}
		}
	}
```


----------



## nrg (7. Jun 2011)

entweder reden wir gerade von verschiedenen dingen oder einer steht etwas auf dem schlauch. wenn man einem primitiven array neue werte oder einem objekt array neue referenzen zuweißen will, geht das nur, wenn man das auch mit einer for-schleife und zählern macht (
	
	
	
	





```
array[zaehler] = ....
```
). wenn man in einem objekt array nur paar attribute ändern will, könnte man das natürlich mit einer for-each machen.

edit: hab zwischenrein bisschen gearbeitet und den post bereits vor deinem edit angefangen zu schreiben


----------



## Super_Sig (7. Jun 2011)

Hi ich würde gerne noch die weiteren Aufgaben 4 & 5 hinzufügen.

4. Legen Sie eine weitere Methode an:
public static void write ( char [][] grid , String word , int x, int y,
int dir )
Sie soll das Wort word beginnend an der Stelle x, y (in Array-Koordinaten1) in das Buchstabengitter
grid schreiben. Falls dir den Wert 0 hat, soll das Wort vertikal eingetragen werden,
sonst horizontal.
Beginnen Sie mit einer Schleife, mit der Sie die Zeichen des Strings word der Reihe nach betrachten konnen. Passen Sie in Abhangigkeit von dir nach jedem geschriebenen Buchstaben die
aktuellen Koordinaten (x oder y) an.

5. Als nachstes brauchen Sie eine Methode, mit der Sie vor dem Schreiben uberprufen konnen, ob
ein Wort uberhaupt an eine bestimmte Stelle im Gitter passt:
public static boolean fits ( char [][] grid , String word , int x,
int y, int dir)
Falls das Wort an der Stelle x, y in Richtung dir (0: vertikal, sonst: horizontal) passt, soll der
Wert true zuruckgegeben werden, ansonsten false.
Testen Sie zuerst, ob x, y eine gultige Position ist und ob das Wort von der Lange her in das
Gitter passt. Beachten Sie die moglichen Werte von dir.
Beginnen Sie dann (in Anlehnung an die write-Methode!) bei x, y und uberprufen Sie, ob das
dort stehende Zeichen zum aktuellen Zeichen in word passt. Ein Zeichen passt dann, wenn es mit
dem vorhandenen Zeichen ubereinstimmt, oder wenn im Gitter noch kein Zeichen eingetragen
ist (also noch ein Leerzeichen an der aktuellen Position steht).



Meine Lösung von Aufgabe 4 sieht so aus:


```
public static void write(char [][] grid, String word, int x, int y,int dir){


		if (dir == 0){

			for(int i=0; i < word.length() ;i++){

				grid [y+i][x] = (char) word.charAt(i);

			}	
		}
		else{
			for(int i=0; i < word.length() ;i++){
				
				grid [y][x+i] = (char) word.charAt(i);


			}
		}
	}
```

Nur weiß ich ich nicht wie ich Aufgabe 5 angehen soll, vor allem der Teil in dem ich überprüfen soll, ob ob das dort stehende Zeichen zum aktuellen zeichen  in word passt. Man soll das ja in Anlehnung an die write Methode machen. Nur kann ich doch nicht eine komplette Methode wie die write in ein If bzw. else if Bdeingung übergeben oder?

Für die erste Überprüfung ob x bzw. y bzw der String word inerhalb des 2 dimensionalen Feldes liegt hab ich folgende if Bedingung. Die mir aber ehrlich gesagt etwas zu lang vorkommt und ich des halb nicht glaube das sie wirklich das macht was ich von ihr will ???:L




```
public static boolean fits (char [] [] grid, String word, int x, int y, int dir){
		
		if(dir == 0 && (y > grid[0].length | word.length() > grid[0].length -y ) || dir != 0 && (x > grid.length | word.length() > grid.length -x) ){
			
				
			boolean fits = false;
			
			return fits;
```


----------



## Andi_CH (7. Jun 2011)

nrg hat gesagt.:


> wenn man einem primitiven array neue werte oder einem objekt array neue referenzen zuweißen will, geht das nur, wenn man das auch mit einer for-schleife und zählern macht (
> 
> 
> 
> ...



Ich wusste echt nicht, dass foreach Kopien anlegt - es liegt nicht einmal, wie ich zuerst vermutete, am Parameter - da funktionert call by reference ja

In Aufgabe 2 soll wohl kein neues grid alloziert, sondern nur dem Bestehenden "leere" Werte, also ' ' zugewiesen werden. Na ja, auch ich darf lernen - hoffentlich vergesse ich den, in meinen Augen mehr als unlogischen, Unterschied zwischen for und foreach nicht so bald wieder.


----------



## Super_Sig (7. Jun 2011)

Hallo ich noch einmal. Ich hab ejtzt denke ich fast die Lösung für Aufgabe 4 gefunden. Nur wird mir immer der Fehler "The method must return a type of boolean". Klar ich muss return false oder true machen. Nur wo muss ich das bei meinen versch. schleifen einfügen? Ich komme da nicht weiter wäre nett wenn mir da einer helfen könnte.



```
public static boolean fits (char [] [] grid, String word, int x, int y, int dir){


		if((dir == 0 && (y > grid[0].length | word.length() > grid[0].length -y )) || (dir != 0 && (x > grid.length | word.length() > grid.length -x) )){


				

			return false;


		}else if (dir == 0){

			for(int i=0; i < word.length() ;i++){

				if(grid [y+i][x] != (char) word.charAt(i) || grid [y+i][x] != ' ' ){
	

					return false;
				}
			}	
		}else if(dir != 0){
			for(int i=0; i < word.length() ;i++){

				if(grid [y][x+i] != (char) word.charAt(i) || grid [y+i][x] != ' ' ){

					return false;
				}
				
			}									
		}else{
			
		
			
			return true;
			
		}	

	}
```


----------



## chalkbag (7. Jun 2011)

Da du denn Fehlerfall mit "return false" ja schon ausgiebig behandelst. Einfach den letzten Else{} - Block löschen und am Ende der Methode pauschal "return true" zurückgeben.


```
if ((dir == 0 && (y > grid[0].length | word.length() > grid[0].length- y))
				|| (dir != 0 && (x > grid.length | word.length() > grid.length
						- x))) {
			return false;
		} else if (dir == 0) {
			for (int i = 0; i < word.length(); i++) {
				if (grid[y + i][x] != (char) word.charAt(i)
						|| grid[y + i][x] != ' ') {
					return false;
				}
			}
		} else if (dir != 0) {
			for (int i = 0; i < word.length(); i++) {
				if (grid[y][x + i] != (char) word.charAt(i)
						|| grid[y + i][x] != ' ') {
					return false;
				}
			}
		}
		return true;
```


----------



## nrg (7. Jun 2011)

also die überprüfung, ob das word reinpasst, könnte man so machen:


```
public static boolean fits(char[][] grid, String word, int x, int y, int dir){
		return dir == 0 ?
				x < grid.length && y + word.length() - 1 < grid[x].length :
				x < grid.length + word.length() - 1 && y < grid[x].length;
	}
```

edit: beachtet jetzt aber nicht die ganze aufgabe. sollte nur als beispiel dienen


----------

