ganz kleiner bug in pro gefixxt

Einfügen in Zellen geht und eine Tabelle einlesen oder die aktuelle speichern.

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/misc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="21" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/PR1-Spreadsheet.iml" filepath="$PROJECT_DIR$/PR1-Spreadsheet.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

Axel/resources/zahlen.csv

@@ -1,4 +1,10 @@
-1,2
+123,,,,,,,,,1111
-3,4
+1,,,,,,,,,
-5,6
+,,,,,,,,,
-7,8
+,,,,,,,,,
+,,,,,,,,,=7*6
+,,,,,,,,,=3/2
+,,,,,,,,,
+,,,,,,,,,
+,=41+A2,,,,,,,,
+,,,,,,,,,

Axel/resources/zahlen2.csv

@@ -0,0 +1,10 @@
+,,,,,,,,,
+1,,,,,,,,,
+123,,,,,,,,,
+,,,,,,,,,
+,,,,,,,,,=7*6
+,,,,,,,,,=3/2
+,,,,,,,,,
+,,,,,,,,,
+,=41+A2,,,,,,,,
+,,,,,,,,,

Axel/src/de/hs_mannheim/informatik/spreadsheet/Axel.java

@@ -1,6 +1,7 @@
 package de.hs_mannheim.informatik.spreadsheet;
 
 import java.io.FileNotFoundException;
+import java.util.Scanner;
 
 /**
  * Part of a simplified spreadsheet system for the PR1 programming lab at Hochschule Mannheim.
@@ -8,22 +9,208 @@ import java.io.FileNotFoundException;
  * @author  Oliver Hummel
  */
 public class Axel {
-
 	public static void main(String[] args) throws FileNotFoundException {
-		Spreadsheet spr = new Spreadsheet(10,10);
+		/*
+		Spreadsheet spr = new Spreadsheet(100,100);
 		
-		spr.put("A3", "123");
+		spr.put("A1", "123");
 		spr.put("A2", "1");
 		
 		spr.put("B9", "=41+A2");
 		spr.put("J5", "=7*6");
 		spr.put("J6", "=3/2");
 
+		spr.put("J10", "1111"); // Das Programm konnte keine Zellen mit 2 Stellen (>9) einlesen! (-> Programm macht es an Stelle 1 statt 10)
+		spr.put("Z2", "23");
+		 */
+		
+		//You might want to put "UI loop" for entering value and formulas here resp. in some UI methods.
+		String eingabe = "";
+		String merker = "";
+		int auswahl = 0;
+		boolean weiter;
+		int zeilen = 0, spalten = 0;
+
+		System.out.println();
+		System.out.println("Willkommen zum Spreadsheet Programm");
+		System.out.println();
+		System.out.println("Wie groß soll das Spreadsheet sein?");
+
+		do {
+			weiter = false;
+			System.out.print("Zeilen(1-26): ");
+			eingabe = abfrage();
+			try {
+				zeilen = Integer.parseInt(eingabe);
+			} catch (Exception ignored) {
+				weiter = true;
+				System.out.println("Falsche eingabe, versuchen Sie es erneut: ");
+			}
+		}while(weiter);
+
+		do {
+			weiter = false;
+			System.out.print("Spalten(1-99): ");
+			eingabe = abfrage();
+			try {
+				spalten = Integer.parseInt(eingabe);
+			} catch (Exception ignored) {
+				weiter = true;
+				System.out.println("Falsche eingabe, versuchen Sie es erneut: ");
+			}
+		}while(weiter);
+
+		Spreadsheet spr = new Spreadsheet(zeilen,spalten);
+
+		do {
+			weiter = true;
+			System.out.println();
 			System.out.println(spr);
 
-		spr.saveCsv("/tmp/test.csv");
+			auswahl = menue(spr);
 
-		// TODO: You might want to put "UI loop" for entering value and formulas here resp. in some UI methods.
+			switch(auswahl){
+				case 0:
+					System.out.println("Programm wird beendet");
+					weiter = false;
+					break;
+				case 1:
+					zelle_bearbeiten(spr);
+					break;
+				case 2:
+					tabelle_einlesen(spr);
+					break;
+				case 3:
+					tabelle_speichern(spr);
+					break;
+				default:
+					System.out.println("Unbekannter Fehler - Menü wird neu geöffnet");
+					break;
+
+
+			}
+		}while(weiter);
 	}
 
+	/**
+	 * Speichert eine Tabelle in einem Path den man (der Benutzer) per Scanner eingeben muss.
+	 * @param spr Tabelle die gespeichert werden soll.
+	 * @throws FileNotFoundException
+	 */
+	private static void tabelle_speichern(Spreadsheet spr) throws FileNotFoundException {
+		System.out.print("Path von der csv Datei: ");
+		String path = abfrage();
+
+		spr.saveCsv(path);
+
+		System.out.println("Tabelle wurde gespeichert");
+	}
+
+	/**
+	 * Liest eine Tabelle aus einer csv Datei ein, dafür muss man path, separator und startcell angeben.
+	 * @param spr Tabelle die gespeichert werden soll.
+	 * @throws FileNotFoundException
+	 */
+	private static void tabelle_einlesen(Spreadsheet spr) throws FileNotFoundException {
+		String eingabe, path, startcell;
+		char separator;
+
+			System.out.print("Path von der csv Datei: ");
+			eingabe = abfrage();
+			path = eingabe;
+
+			System.out.print("Separator zwischen den Zellen in der csb Datei: ");
+			eingabe = abfrage();
+			separator = eingabe.charAt(0);
+
+			System.out.print("Obere Linke Zelle, in die Daten aus der csb-Datei eingefügt werden sollen: ");
+			eingabe = abfrage();
+			startcell = eingabe;
+
+			spr.readCsv(path, separator, startcell);
+
+	}
+
+	/**
+	 * Fragt so lange ab bis man (der Benutzer) eine richtige Zelle angibt, dort kann man dann etwas einfügen.
+	 * @param spr Tabelle
+	 */
+	private static void zelle_bearbeiten(Spreadsheet spr) {
+		String eingabe;
+		do {
+			System.out.print("Welche Zelle?");
+			System.out.print("(Buchstabe+Zahl): ");
+			eingabe = abfrage();
+			eingabe = eingabe.toUpperCase();
+			if (spr.zelleneingabe_pruefen(eingabe)) {
+				break;
+			} else{
+				System.out.println();
+				System.out.println("Fehler bei Eingabe - Zelle wurde nicht gefunden");
+				System.out.println("Versuchen Sie es erneut");
+			}
+		}while(true);
+
+		String merker = eingabe;
+
+		System.out.print("Was soll in Zelle " +eingabe+ " rein?:");
+		eingabe = abfrage();
+
+		spr.put(merker, eingabe);
+	}
+
+	/**
+	 * Gibt ein kleines Menü auf der Console aus, dort kann man dann per eingabe (Zahl) wählen, was man tun will.
+	 * @param spr
+	 * @return Gibt die Zahl zurück, die der Benutzer eingegeben hat.
+	 * @throws FileNotFoundException
+	 */
+	private static int menue(Spreadsheet spr) throws FileNotFoundException {
+		do {
+			System.out.println();
+			System.out.println("Auswahl Möglichkeiten:");
+			System.out.println("1. Zelle bearbeiten 2. Tabelle einfügen 3. Tabelle speichern | oder \"exit\"");
+
+			System.out.print("Ihre auswahl: ");
+
+			String eingabe = abfrage();
+
+			if (eingabe.length() == 1 && eingabe.charAt(0) <= '3' && eingabe.charAt(0) >= '1') {
+				return Integer.parseInt(eingabe);
+			}else {
+				if (!(eingabe.equals("exit"))) {
+					System.out.println("Fehler bei Eingabe!");
+					System.out.print("Wollen Sie das Programm beenden?(J/N): ");
+
+					eingabe = abfrage();
+					eingabe = eingabe.toUpperCase();
+					if (eingabe.equals("NEIN") || eingabe.equals("N") || eingabe.equals("NO") || eingabe.equals("NE")) {
+						continue;
+					}
+				}
+
+				System.out.print("Programm ohne speichern beenden?(J/N)");
+				eingabe = abfrage();
+				eingabe = eingabe.toUpperCase();
+				if (eingabe.equals("JA") || eingabe.equals("J") || eingabe.equals("Y") || eingabe.equals("YES")) {
+					break;
+				} else {
+					tabelle_speichern(spr);
+					break;
+				}
+			}
+		}while(true);
+
+		return 0;
+	}
+
+	/**
+	 * Hier hab ich etwas getrickst und den Scanner den ich öfter brauche einfach in eine Methode geschrieben. Sollte man wahrscheinlich so eher nicht tun.
+	 * @return Was der Benutzer eingibt (String)
+	 */
+	private static String abfrage() {
+		Scanner sc = new Scanner(System.in);
+		String x = sc.nextLine();
+		return x;
+	}
 }

Axel/src/de/hs_mannheim/informatik/spreadsheet/Spreadsheet.java

@@ -1,15 +1,18 @@
 package de.hs_mannheim.informatik.spreadsheet;
 
+import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.PrintWriter;
+import java.util.Scanner;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.ArrayList;
 
 /**
  * A simplified spreadsheet class for the PR1 programming lab at Hochschule Mannheim.
  * One aspect worth mentioning is that it only supports long numbers, not doubles.
- *
+ *p
  * @author  Oliver Hummel
  */
 public class Spreadsheet {
@@ -24,6 +27,18 @@ public class Spreadsheet {
 
 		// TODO limit the maximum size on 99 (1..99) rows and 26 (A..Z) columns
 
+		if (rows > 99) {
+			rows = 99;
+		} else if (rows <= 0) {
+			rows = 1;
+		}
+
+		if (cols > 26) {
+			cols = 26;
+		} else if (cols <= 0) {
+			cols = 1;
+		}
+
 		cells = new Cell[rows][cols];
 
 		for (int r = 0; r < rows; r++)
@@ -57,12 +72,46 @@ public class Spreadsheet {
 		put(getRow(cellName), getCol(cellName), value);
 	}
 
+
 	private int getCol(String cellName) {
-		return cellName.charAt(0) - 'A';
+		int merker = 0;
+		for (int i = 0; i < cellName.length(); i++) {
+			if (cellName.charAt(i) >= 'A' && cellName.charAt(i) <= 'Z') {
+				merker = (merker * 10) + (cellName.charAt(i) - ('A'-1));
+			} else {
+				break;
+			}
+		}
+		return merker-1;
 	}
 
+
 	private int getRow(String cellName) {
-		return cellName.charAt(1) - '1';
+		int merker = 0;
+		for (int i = 0; i < cellName.length(); i++) {
+			if (!(cellName.charAt(i) >= 'A' && cellName.charAt(i) <= 'Z')) {
+				merker = (merker * 10) + (cellName.charAt(i) - '0');
+			}
+		}
+		return merker-1;
+	}
+
+	/**
+	 * Hier wird überprüft, ob die Zelle existiert.
+	 * @param a Name der Zelle
+	 * @return true = Zelle existiert, false = Zelle existent nicht (zumindest nicht in der Tabelle)
+	 */
+	public boolean zelleneingabe_pruefen(String a) {
+		if (a.length() < 2) {		//es soll eine einzelne Zelle angesprochen werde, also muss dafür die länge >2 sein
+			return false;
+		}
+		if (getRow(a) < 0 || getRow(a) >= cells.length) { //überprüfung, ob die eingabe in die rows länge passt
+			return false;
+		}
+		if (getCol(a) < 0 || getCol(a) >= cells[0].length) { //überprüfung, ob die eingabe in die Columns länge passt
+			return false;
+		}
+		return true;
 	}
 
 	// -----
@@ -72,12 +121,42 @@ public class Spreadsheet {
 	 * A method for reading in data from a CSV file.
 	 * @param path The file to read.
 	 * @param separator The char used to split up the input, e.g. a comma or a semicolon.
-	 * @param starCellName The upper left cell where data from the CSV file should be inserted.
+	 * @param startCellName The upper left cell where data from the CSV file should be inserted.
 	 * @return Nothing.
 	 * @exception IOException If path does not exist.
 	 */
 	public void readCsv(String path, char separator, String startCellName) throws FileNotFoundException {
-		// TODO: implement this
+		//implement this
+		ArrayList<String> lines = readFile(path);
+		String[] einzelnde_lines = new String[lines.size()];
+		int row_startcell = getRow(startCellName);
+		int col_startcell = getCol(startCellName);
+		String[][] zwischenspeicher = new String[cells.length - row_startcell][cells[0].length - col_startcell];
+		for (int i = 0; i < einzelnde_lines.length; i++) {
+			zwischenspeicher[i] = lines.get(i).split(separator+""); // +"" um aus dem Char ein String zu machen
+			for (int j = 0; j < zwischenspeicher[i].length; j++) {
+				put(row_startcell+i,col_startcell+j,zwischenspeicher[i][j]);
+			}
+		}
+	}
+
+	/**
+	 * Liest eine csb Datei ein und speichert sie in eine ArrayList
+	 * @param path von der Datei
+	 * @return Liste mit den gespeicherten Zeilen von der csv Datei
+	 * @throws FileNotFoundException
+	 */
+	public static ArrayList<String> readFile(String path) throws FileNotFoundException {
+		ArrayList<String> lines = new ArrayList<>();
+		Scanner sc = new Scanner(new File(path));
+
+		while (sc.hasNextLine()) {
+			lines.add(sc.nextLine());
+		}
+
+		sc.close();
+
+		return lines;
 	}
 
 	/**
@@ -96,7 +175,7 @@ public class Spreadsheet {
 				else
 					out.print(cell.getValue());
 
-				if (cell != row[cells.length-1])
+				if (cell != row[cells[0].length-1]) // "[0]" -> nimmt sonst die falsche Länge!
 					out.print(",");
 			}
 			out.println();
@@ -115,20 +194,20 @@ public class Spreadsheet {
 		String result = "";
 
 		if (formula.startsWith("SUMME("))  // e.g. SUMME(A3:A8)
-			result = "" + sum(formula.substring(6, 8), formula.substring(9, 11));  // TODO adapt to cells with two digits
+			result = "" + sum(formula.substring(6, 8), formula.substring(9, 11));  // adapt to cells with two digits
 		else if (formula.startsWith("PRODUKT("))  // e.g. PRODUKT(A3:B9)
-			result = "TODO"; // TODO
+			result = "" + pro(formula.substring(8, 10), formula.substring(11, 13));
 		else if (formula.startsWith("MITTELWERT("))  // e.g. MITTELWERT(A3:A5)
-			result = "TODO"; // TODO
+			result = "" + mittelwert(formula.substring(11, 13), formula.substring(14, 16));
 		else if (formula.startsWith("STABW("))  // e.g. STABW(C6:D8) -> Standardabweichung
-			result = "TODO"; // TODO
+			result = "" + stabw(formula.substring(6, 8), formula.substring(9, 11));
-		else if (formula.startsWith("MIN("))  // e.g. MIN(C13:H13) -> größter Wert
+		else if (formula.startsWith("MIN("))  // e.g. MIN(C13:H13) -> kleinster Wert
-			result = "TODO"; // TODO
+			result = "" + min(formula.substring(4, 6), formula.substring(7, 9));
-		else if (formula.startsWith("MAX("))  // e.g. MAX(A1:A10) -> Standardabweichung
+		else if (formula.startsWith("MAX("))  // e.g. MAX(A1:A10) ->  größter Wert
-			result = "TODO"; // TODO
+			result = "" + max(formula.substring(4, 6), formula.substring(7, 9));
 		else if (!formula.isEmpty()) {
 			try {
-				result = "" + calculate(formula);
+				result = "" + calculate(formula); //geht nicht?
 			} catch(ArithmeticException ae) {
 				result = "exc.";
 			}
@@ -137,6 +216,47 @@ public class Spreadsheet {
 		cells[row][col].setValue("" + result);
 	}
 
+	/**
+	 * Berechnet die Standardabweichung
+	 * @param startCellName The name of the cell in the upper left corner of the rectangle.
+	 * @param endCellName The name of the cell in the lower right corner of the rectangle.
+	 * @return Ergebnis bzw. die Standardabweichung
+	 */
+	private int stabw(String startCellName, String endCellName) {
+		int startCellRow = getRow(startCellName);
+		int startCellCol = getCol(startCellName);
+		int endCellRow = getRow(endCellName);
+		int endCellCol = getCol(endCellName);
+		int res = 0;
+
+		int merker = 0;
+		int anzahl = 0;
+		int mittelwert = (int) (mittelwert(startCellName, endCellName));
+
+		//System.out.println("Mittelwert: "+mittelwert);
+
+		for (int i = startCellRow; i <= endCellRow; i++) {
+			for (int j = startCellCol; j <= endCellCol; j++) {
+				merker = Integer.parseInt(cells[i][j].getValue());
+				if (merker <= mittelwert) {
+					res = res + (mittelwert-merker)*(mittelwert-merker);
+					//System.out.println((mittelwert-merker));
+				} else {
+					res = res + (merker - mittelwert)*(merker - mittelwert);
+					//System.out.println((merker - mittelwert));
+				}
+				anzahl++;
+			}
+		}
+		//System.out.println(res);
+		//System.out.println(anzahl);
+		res = res/(anzahl-1); // oder: res = res/(anzahl-1);
+
+		res = (int) Math.sqrt(res);
+
+		return res;
+	}
+
 	/**
 	 * Method for calculating the sum of a rectangular block of cells, such as from A1 to B3.
 	 * @param startCellName The name of the cell in the upper left corner of the rectangle.
@@ -144,9 +264,124 @@ public class Spreadsheet {
 	 * @return The sum calculated.
 	 */
 	private long sum(String startCellName, String endCellName) {
-		// TODO implement
+		int startCellRow = getRow(startCellName);
+		int startCellCol = getCol(startCellName);
+		int endCellRow = getRow(endCellName);
+		int endCellCol = getCol(endCellName);
 
-		return 0;
+		long res = 0;
+
+		for (int i = startCellRow; i <= endCellRow; i++) {
+			for (int j = startCellCol; j <= endCellCol; j++) {
+					res = res + (Integer.parseInt(cells[i][j].getValue()));
+            }
+		}
+		
+		return res;
+	}
+
+	/**
+	 * Rechnet das Produkt aus den Zellen von einem Viereck.
+	 * @param startCellName The name of the cell in the upper left corner of the rectangle.
+	 * @param endCellName The name of the cell in the lower right corner of the rectangle.
+	 * @return Das Ergebnis.
+	 */
+	private long pro(String startCellName, String endCellName) {
+		int startCellRow = getRow(startCellName);
+		int startCellCol = getCol(startCellName);
+		int endCellRow = getRow(endCellName);
+		int endCellCol = getCol(endCellName);
+
+		long res = 1;
+
+		for (int i = startCellRow; i <= endCellRow; i++) {
+			for (int j = startCellCol; j <= endCellCol; j++) {
+				res = res * (Integer.parseInt(cells[i][j].getValue()));
+			}
+		}
+
+		return res;
+	}
+
+	/**
+	 * Gibt die kleinste Zahl aus den Zellen von einem Viereck.
+	 * @param startCellName The name of the cell in the upper left corner of the rectangle.
+	 * @param endCellName The name of the cell in the lower right corner of the rectangle.
+	 * @return Kleinste Zahl
+	 */
+	private long min(String startCellName, String endCellName) {
+		int startCellRow = getRow(startCellName);
+		int startCellCol = getCol(startCellName);
+		int endCellRow = getRow(endCellName);
+		int endCellCol = getCol(endCellName);
+
+		long res = Long.MAX_VALUE;
+		long merker;
+
+		for (int i = startCellRow; i <= endCellRow; i++) {
+			for (int j = startCellCol; j <= endCellCol; j++) {
+				merker = Integer.parseInt(cells[i][j].getValue());
+				if (merker < res) {
+					res = merker;
+				}
+			}
+		}
+
+		return res;
+	}
+
+	/**
+	 * Gibt die größte Zahl aus den Zellen von einem Viereck.
+	 * @param startCellName The name of the cell in the upper left corner of the rectangle.
+	 * @param endCellName The name of the cell in the lower right corner of the rectangle.
+	 * @return größte Zahl
+	 */
+	private long max(String startCellName, String endCellName) {
+		int startCellRow = getRow(startCellName);
+		int startCellCol = getCol(startCellName);
+		int endCellRow = getRow(endCellName);
+		int endCellCol = getCol(endCellName);
+
+		long res = Long.MIN_VALUE;
+		long merker;
+
+		for (int i = startCellRow; i <= endCellRow; i++) {
+			for (int j = startCellCol; j <= endCellCol; j++) {
+				merker = Integer.parseInt(cells[i][j].getValue());
+				if (merker > res) {
+					res = merker;
+				}
+			}
+		}
+
+		return res;
+	}
+
+	/**
+	 * Berechnet den Durchschnitt aus den Zellen von einem Viereck. (Summe von allen geteilt durch die Anzahl der Zellen)
+	 * @param startCellName The name of the cell in the upper left corner of the rectangle.
+	 * @param endCellName The name of the cell in the lower right corner of the rectangle.
+	 * @return Durchschnitt
+	 */
+	private long mittelwert(String startCellName, String endCellName) {
+		int startCellRow = getRow(startCellName);
+		int startCellCol = getCol(startCellName);
+		int endCellRow = getRow(endCellName);
+		int endCellCol = getCol(endCellName);
+
+		long anzahl = 0;
+
+		long res = 0;
+
+		for (int i = startCellRow; i <= endCellRow; i++) {
+			for (int j = startCellCol; j <= endCellCol; j++) {
+				res = res + (Integer.parseInt(cells[i][j].getValue()));
+				anzahl++;
+			}
+		}
+		res = res/anzahl;
+
+		return res;
 	}
 
 	/**
@@ -158,22 +393,88 @@ public class Spreadsheet {
 	 * @param formula The expression to be evaluated.
 	 * @return The result calculated.
 	 */
-	private long calculate(String formula) throws ArithmeticException {
+	public long calculate(String formula) throws ArithmeticException {
 		Matcher m = Pattern.compile("([A-Z][0-9]*)|[-\\+\\*/]|[0-9]*").matcher(formula);
 
 		long res = 0;
 
 		// TODO implement
+		int merker = 0;
+		int zaehler = 0;
+		int neue_zahl = 0;
 
 		// uncomment the following to see an example how the elements of a formula can be accessed
 		while (m.find()) {        // m.find() must always be used before m.group()
 			String s = m.group();
 			if (!s.isEmpty()) {
-				System.out.println(s);
+				//System.out.println(s);
+				zaehler++;
+
+				switch (zaehler){
+					case 1:
+						try {
+							res = Integer.parseInt(s);
+						}catch (Exception ignored){
+							res = Integer.parseInt(get(s));
 						}
+						break;
+					case 2:
+						switch(s) {
+							case "+":
+								merker = 1;
+								break;
+							case "-":
+								merker = 2;
+								break;
+							case "*":
+								merker = 3;
+								break;
+							case "/":
+								merker = 4;
+								break;
+							default:
+								System.out.println("ERROR");
+								break;
+						}
+						break;
+					case 3:
+						try {
+							neue_zahl = Integer.parseInt(s);
+						}catch (Exception ignored){
+							neue_zahl = Integer.parseInt(get(s));
+						}
+						res = rechne(res, merker, neue_zahl);
+
+						zaehler = 1;
+						break;
+				}
+			}
+		}
+		return res;
 	}
 
-		return res;
+	/**
+	 * Berechnet 2 beliebige Zahlen, plus, minus, mal oder geteilt. (muss man angeben)
+	 * @param auswahl hiermit wird bestimmt welche Rechenart benutzt werden soll.
+	 * @param a erste Zahl
+	 * @param b zweite Zahl
+	 * @return Ergebnis
+	 */
+	private long rechne(long a, int auswahl, int b) {
+		switch(auswahl){
+			case 1:
+				return a + b;
+			case 2:
+				return a - b;
+			case 3:
+				return a * b;
+			case 4:
+				return a / b;
+			default:
+				System.out.println("ERROR");
+				break;
+		}
+		return 0;
 	}
 
 	// -----
@@ -182,7 +483,7 @@ public class Spreadsheet {
 		StringBuilder sb = new StringBuilder();
 
 		sb.append("    ");
-		for (int i = 0; i < cells.length; i++) {
+		for (int i = 0; i < cells[0].length; i++) {		// "[0]" -> nimmt sonst die falsche Länge!
 			sb.append("  " + (char)('A'+ i) + "  | ");
 		}
 
@@ -198,5 +499,4 @@ public class Spreadsheet {
 		}
 		return sb.toString();
 	}
-
 }

Axel/src/de/hs_mannheim/informatik/spreadsheet/SpreadsheetTest.java

@@ -0,0 +1,55 @@
+package de.hs_mannheim.informatik.spreadsheet;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class SpreadsheetTest {
+
+    @Test
+    void sum() {
+    }
+
+    @Test
+    void pro() {
+    }
+
+    @Test
+    void min() {
+    }
+
+    @Test
+    void max() {
+    }
+
+    @Test
+    void mittelwert() {
+    }
+
+    @Test
+    void calculate() {
+        Spreadsheet spr = new Spreadsheet(20,20);
+
+        assertEquals(spr.calculate("20+2"), 22);
+        assertEquals(spr.calculate("4-3"), 1);
+        assertEquals(spr.calculate("3*3"), 9);
+        assertEquals(spr.calculate("9/3"), 3);
+
+
+        spr.put("A1", "3");
+        spr.put("A2", "3");
+
+        assertEquals(spr.calculate("A1+20"), 23);
+
+        assertEquals(spr.calculate("A1+A2"), 6);
+        assertEquals(spr.calculate("A1-A2"), 0);
+        assertEquals(spr.calculate("A1*A2"), 9);
+        assertEquals(spr.calculate("A1/A2"), 1);
+    }
+
+    @Test
+    void rechne() {
+        // 1 = +, 2 = -, 3 = *, 4 = /
+        //assertEquals(Spreadsheet.rechne(), );
+    }
+}

PR1-Spreadsheet.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/Axel/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>