# Array addieren



## Lukases2 (15. Feb 2015)

Sie haben neben Ihrer Arbeit bei der Internetagentur einen kleinen privaten Kundenstamm für den
Sie am Wochenende kleine Anwendungen in Java schreiben. Das Königreich hat in Erinnerung an
die Hexenverfolgung zur Zeit Kanibals seine eigene Währung geschaffen, in der die Preise im
Hexadezimalsystem angegeben werden: den Hexary.
Sie haben drei Kunden für die Sie je drei Dienstleistungen erbracht haben und nur teilweise entlohnt
wurden. Der Lohn, den Sie erhalten haben steht in Matrix A. In Matrix B steht der Lohn, der Ihnen
geschuldet wird.
A =
A0 05 0A
13 D5 21
0C 04 0F 
B = 
5F 94 A0
42 2A 34
C0 95 F0 

Der Preis ist als Zeichenkette dargestellt, die eine ganze Zahl im Hexadezimalsystem enthält. Für
die Umrechnung stehen Ihnen folgende Klassenmethoden zur Verfügung:
Integer.parseInt(String s, 16) Konvertiert einen übergebenen String s, der eine ganze Zahl im
Hexadezimalsystem enthält, zu einem Integerwert.
Integer.toHexString(int i) Konvertiert den übergebenen Integerwert ins Hexadezimalsystem und
gibt ihn als String zurück.
Schreiben Sie eine Klassenmethode public static String[][] addMatrizen(String[][]a, String[][]b),
die zwei Matrizen der Größe n×n addiert und die Ergebnismatrix zurück gibt.

Dazu habe ich geschrieben:

```
public static String[][] addMatrizen(String[][] a, String[][] b){
			for(int i = 0; i < a.length; i++){
				for(int j = 0; j < b.length; j++){
					
					int[][] parsedA = Integer.parseInt(a[i][j]);
					int[][] parsedB = Integer.parseInt(b[i][j]);
					int[][] erg;
			
					erg[i][j] = parsedA[i][j] + parsedB[i][j];
					String[][] parsedErg = Integer.toHexString(erg[i][j]);
			
				}
			}
			return parsedErg;
		}
```
Ich erhalte aber jede Menge Fehlermeldungen (Zeile 11 und 12):
cannot convert from int to int[][]
parsedA und parsedB haben aber doch den Typ int[][], oder nicht?

Zeile 16:
cannot convert from String to String[][]
gleiches Problem nur mit String[][]/String

Zeile 20:
parsedErg cannot be resolved to a variablE
Die habe ich aber doch zuvor festgelegt, oder nicht?

Ich habe das gleiche eingach mal für Variblen mit dem Typ String geschrieben, und hier funktioniert alles:


```
public static String addiereString(String c, String d){
			int parsedC = Integer.parseInt(c);
			int parsedD = Integer.parseInt(d);
			int erg;
			
			erg = parsedC + parsedD;
			String parsedErg = Integer.toHexString(erg);
			
			return parsedErg;
		}
```


----------



## Saheeda (15. Feb 2015)

Zeile 11/12:
parsedA und parsedB sind vom Typ int[][], aber bei  Integer.parseInt(a_[j]) kommt ein integer zurück, kein Array.

Zeile 16:
Oben ist an der Stelle ne Klammer. Vermute aber mal dasselbe Problem wie mit int / int[][]

Zeile 20:
parsedErg ist innerhalb der Schleifen definiert, d.h., wenn die Schleife nicht betreten wird, existiert die Variable und es existiert kein Rückgabewert. Definiere die Variable außerhalb der Schleifen und es geht._


----------



## Lukases2 (16. Feb 2015)

Ganz verstanden habe ich es noch nicht. Theoretische geht es ja auch so:


```
public class Parse {

	static String[][] a = { { "A0", "05", "0A" }, { "13", "D5", "21" },
			{ "0C", "04", "0F" } };
	static String[][] b = { { "5F", "94", "A0" }, { "42", "2A", "34" },
			{ "C0", "95", "F0" } };

	public static String[][] addMatrizen(String[][] a, String[][] b) {

		String a00 = a[0][0];	//a an der Stelle ...
		String a01 = a[0][1];
		String a02 = a[0][2];
		String a10 = a[1][0];
		String a11 = a[1][1];
		String a12 = a[1][2];
		String a20 = a[2][0];
		String a21 = a[2][1];
		String a22 = a[2][2];

		String b00 = b[0][0];	//b an der Stelle ...
		String b01 = b[0][1];
		String b02 = b[0][2];
		String b10 = b[1][0];
		String b11 = b[1][1];
		String b12 = b[1][2];
		String b20 = b[2][0];
		String b21 = b[2][1];
		String b22 = b[2][2];

		int a00P = Integer.parseInt(a00); // P = Parsed
		int a01P = Integer.parseInt(a01);
		int a02P = Integer.parseInt(a02);
		int a10P = Integer.parseInt(a10);
		int a11P = Integer.parseInt(a11);
		int a12P = Integer.parseInt(a12);
		int a20P = Integer.parseInt(a20);
		int a21P = Integer.parseInt(a21);
		int a22P = Integer.parseInt(a22);

		int b00P = Integer.parseInt(b00);
		int b01P = Integer.parseInt(b01);
		int b02P = Integer.parseInt(b02);
		int b10P = Integer.parseInt(b10);
		int b11P = Integer.parseInt(b11);
		int b12P = Integer.parseInt(b12);
		int b20P = Integer.parseInt(b20);
		int b21P = Integer.parseInt(b21);
		int b22P = Integer.parseInt(b22);

		int e00 = a00P + b00P; // e = Ergebnis
		int e01 = a01P + b01P;
		int e02 = a02P + b02P;
		int e10 = a10P + b10P;
		int e11 = a11P + b11P;
		int e12 = a12P + b12P;
		int e20 = a20P + b20P;
		int e21 = a21P + b21P;
		int e22 = a22P + b22P;

		String e00S = Integer.toBinaryString(e00); // S = String
		String e01S = Integer.toBinaryString(e00);
		String e02S = Integer.toBinaryString(e00);
		String e10S = Integer.toBinaryString(e00);
		String e11S = Integer.toBinaryString(e00);
		String e12S = Integer.toBinaryString(e00);
		String e20S = Integer.toBinaryString(e00);
		String e21S = Integer.toBinaryString(e00);
		String e22S = Integer.toBinaryString(e00);

		String[][] ergMat = {{ e00S, e01S, e02S }, { e20S, e11S, e12S },{ e20S, e21S, e22S }};
		
		return ergMat;
	}
}
```

Aber effizient ist das ja nicht gerade. Wie bekomme ich das mit einer Schleife hin?


----------



## Saheeda (17. Feb 2015)

Du kannst das schon mit einer Schleife machen.


```
int[][] parsedA = Integer.parseInt(a[i][j]);
```

Hier steht im Grunde "int[][] parsedA = int a". Oder etwas praktischer: "Korb Äpfel = Apfel".
Das kann nicht funktionieren.
Wenn du die Werte nur ins Array schreiben wolltest, muss vorn in den Klammern ein Index stehen, also z.B. so:


```
int[i][j] parsedA = Integer.parseInt(a[i][j]);
```

oder du weißt den Wert keinem Array zu, sondern einem int:

```
int parsedA = Integer.parseInt(a[i][j]);
```

Allerdings solltest du hier noch die Deklaration des parsedErg-Arrays aus der Schleife rausziehen, sonst erstellst du bei jedem Durchlauf ein komplett neues

```
public static String[][] addMatrizen(String[][] a, String[][] b){
            String[][] parsedErg = new String[a.length][a[0].length];
            
            for(int i = 0; i < a.length; i++){
               for(int j = 0; j < b.length; j++){
 
                      int parsedA = Integer.parseInt(a[i][j]);
                      int parsedB = Integer.parseInt(b[i][j]);
 
                      int erg[i][j] = parsedA + parsedB;
                      parsedErg[i][j] = Integer.toHexString(erg);
 
             }
           }

return parsedErg;
}
```

(Nur Syntax korrigiert, obs richtige Ergebnis rauskommt, hab ich nicht geschaut.)


----------



## Lukases2 (18. Feb 2015)

Ich denke, dass das hier die richtige Lösung ist:


```
public static String[][] addMatrizen(String[][] a, String[][] b) {
		String[][] erg = new String[a.length][b.length];			// erstellt einen zunächst leeren String[][], in dem später das Ergebnis steht
		int[][] aInt = new int[a.length][b.length];					// erstellt einen leeren String, in dem später die umgewandelte Matrix a steht
		int[][] bInt = new int[a.length][b.length];					// erstellt einen leeren String, in dem später die umgewandelte Matrix b steht
		int[][] ergInt = new int[a.length][b.length];
		for (int i = 0; i < a.length; i++) {
			for (int j = 0; j < a.length; j++) {
				aInt[i][j] = Integer.parseInt(a[i][j], 16);			// wandelt die Matrix a in Integer-Werte um
				bInt[i][j] = Integer.parseInt(b[i][j], 16);			// wandelt die Matrix b in Integer-Werte um
				ergInt[i][j] = aInt[i][j] + bInt[i][j];				// verrechnet die Integer-Werte der beiden Matrizen a und b
				erg[i][j] = Integer.toHexString(ergInt[i][j]);		// wandelt die Integer-Werte wieder ins Hexadezimalsystem um
			}
		}
		return erg;
	}
```

Einwände?


----------

