3029257
/
PR1_Aufgabensammlung_Rekursiver_Rechner_Aufgabenstellung
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Aufgabenstellung v1.0

main
Lukas Klipfel 2025-12-22 18:04:36 +01:00
parent 8cf8a8a613
commit c21d162358
5 changed files with 219 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
.classpath 100644
View File

@ -0,0 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" path="src"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/5"/>
<classpathentry kind="output" path="bin"/>
</classpath>

17
.project 100644
View File

@ -0,0 +1,17 @@
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>Rekursiver_Rechner</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.eclipse.jdt.core.javabuilder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.eclipse.jdt.core.javanature</nature>
</natures>
</projectDescription>

63
README.md
View File

@ -1,3 +1,62 @@
# Rekursiver_Rechner_Aufgabenstellung # Rekursiver Rechner
## Repo zur Aufgabe
Hier:
finden Sie ein git-repo mit der Aufgabenstellung und Tests. Sie müssen lediglich die Funktion: `double RekursiveSquentielleBerechnung()` vervollständigen. Mit Hilfe der Tests weiß man, ob die Aufgabe korrekt ist.
## Aufgabe
Erstellen Sie einen Rechner der [Sequentielle Eingabe](https://de.wikipedia.org/wiki/Taschenrechner#Eingabelogik) zum Berechnen des Ergebnisses rekursiv verwendet.
In dem Eingabe String sind nur die folgenenden Zeichen erlaubt: 0-9.+-/*
## Immediate execution erklärt
Wikipedia: [Sequentielle Eingabe (Deutsch)](https://de.wikipedia.org/wiki/Taschenrechner#Eingabelogik)
```
Bsp.:
5.5+4.5*10
```
Normale Berechnung(Algebraische Notation):
```
5.5+4.5*10 | Klammern setzen (Rangfolge der Operatoren beachten)
=5.5+(4.5*10)
=5.5+45
=50.5
```
Sequentielle Eingabe:
```
5.5+4.5*10 |Von links nach rechts berechnen (ohne Beachtung der Rangfolge der Operatoren)
=10*10
=100
```
Hinweis: Der "normale" Windows Rechner arbeitet nach dem Sequentiellen Eingabe Prinzip.
## Weitere Hinweise
### Randfälle definiert
Falls ein Operator am Ende des Strings steht, soll er ignoriert werden.
Bsp.:
```
+ - / *
10+ 10- 10/ 10*
=10+0 =10-0 =10/1 =10*1
=10 =10 =10 =10
```
Falls Operator an Operator steht, soll er das Ergebniss nicht ändern.
Bsp.:
```
+++ --- /// *** +-/*
10++++5 10----5 10////5 10***5 10+-/**5
=10+0+0+0+5 =10-0-0-0-5 =10/1/1/1/5 =10*1*1*1*5 =10+0-0/1*1*5
=15 =5 =2 =50 =50
```
Falls ein Operator an erster Stelle steht ist die vorhergehende Zahl 0.
Bsp.:
```
+ - / *
=0+0 =0-0 =0/1 =0*1
=0 =0 =0 =0
```
Zahlen wie "5." entsprechen "5.0" und ".5" entsprechen "0.5".
Nur "." als Zahl ist ungültig.
Bei Rechnungen "/0" soll als Ergebniss `Double.POSITIVE_INFINITY` oder `Double.NEGATIVE_INFINITY` zurück gegeben werden. (Das macht Java bei Rechnungen "/0" von sich aus.)
PR1 Aufgabensammlung

73
src/de/hs_mannheim/Rekursiver_Rechner/Rekursiver_Rechner.java 100644
View File

@ -0,0 +1,73 @@
package de.hs_mannheim.Rekursiver_Rechner;
import java.util.Scanner;
public class Rekursiver_Rechner {
private static Scanner sc;
public static void main(String[] args) {
sc = new Scanner(System.in);
Menu();
System.out.println("Ende.");
}
public static double RekursiveSquentielleBerechnung(String formel) {
//Todo: Implementiere den Rechner rekursiv.
return 0.0;
}
public static void Menu() {
Boolean ende = false;
while(!ende) {
System.out.println("Schreiben Sie eine Rechnung die nach \"Sequentielle Eingabe\" berechnet werden soll (\"exit\" to quit):");
System.out.println();
String eingabe = sc.nextLine();
if("exit".equals(eingabe)) {
ende = true;
continue;
}
if(!isValidString(eingabe)) {
System.out.println("Die Eingegebene Rechnung ist nicht valide. Probieren Sie es nochmal.");
continue;
}
System.out.println("Das Ergebniss ist: "+RekursiveSquentielleBerechnung(eingabe));
}
}
public static Boolean isValidString(String formel) {
//Check if all Chars are allowed
for(int i = 0; i<formel.length(); i++) {
if(!((formel.charAt(i)>='0' && formel.charAt(i)<='9')||formel.charAt(i)=='.'||formel.charAt(i)=='+'||formel.charAt(i)=='-'||formel.charAt(i)=='/'||formel.charAt(i)=='*')) {
return false;
}
}
//Check if all Numbers can be parsed
int startNumber = 0;
int endNumber = 0;
for(int i = 0; i<formel.length(); i++) {
if((formel.charAt(i)=='+'||formel.charAt(i)=='-'||formel.charAt(i)=='/'||formel.charAt(i)=='*')) {
endNumber = i;
if(!CanParseStringToDouble(formel.substring(startNumber,endNumber))) {
return false;
} else {
startNumber = endNumber+1;
}
}
}
//Edge case "."
if(".".equals(formel))
return false;
return true;
}
public static Boolean CanParseStringToDouble(String n) {
if(n == "") {
n = "0.0";
}
try {
Double.parseDouble(n);
} catch (Exception e) {
return false;
}
return true;
}
}

61
src/de/hs_mannheim/Rekursiver_Rechner/Rekursiver_Rechner_Test.java 100644
View File

@ -0,0 +1,61 @@
package de.hs_mannheim.Rekursiver_Rechner;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
class Rekursiver_Rechner_Test {
@Test
void NormaleRechnungen() {
String testRechnung = "5+5*5";
assertEquals(50.0, Rekursiver_Rechner.RekursiveSquentielleBerechnung(testRechnung));
testRechnung = "5*5+5";
assertEquals(30.0, Rekursiver_Rechner.RekursiveSquentielleBerechnung(testRechnung));
testRechnung = "5+5";
assertEquals(10.0, Rekursiver_Rechner.RekursiveSquentielleBerechnung(testRechnung));
testRechnung = "5-5";
assertEquals(0.0, Rekursiver_Rechner.RekursiveSquentielleBerechnung(testRechnung));
testRechnung = "5*5";
assertEquals(25.0, Rekursiver_Rechner.RekursiveSquentielleBerechnung(testRechnung));
testRechnung = "5/5";
assertEquals(1.0, Rekursiver_Rechner.RekursiveSquentielleBerechnung(testRechnung));
testRechnung = "-5";
assertEquals(-5.0, Rekursiver_Rechner.RekursiveSquentielleBerechnung(testRechnung));
}
@Test
void EdgeCases() {
String testRechnung = "5+";
assertEquals(5.0, Rekursiver_Rechner.RekursiveSquentielleBerechnung(testRechnung));
testRechnung = "5-";
assertEquals(5.0, Rekursiver_Rechner.RekursiveSquentielleBerechnung(testRechnung));
testRechnung = "5/";
assertEquals(5.0, Rekursiver_Rechner.RekursiveSquentielleBerechnung(testRechnung));
testRechnung = "5*";
assertEquals(5.0, Rekursiver_Rechner.RekursiveSquentielleBerechnung(testRechnung));
testRechnung = "5+++";
assertEquals(5.0, Rekursiver_Rechner.RekursiveSquentielleBerechnung(testRechnung));
testRechnung = "5---";
assertEquals(5.0, Rekursiver_Rechner.RekursiveSquentielleBerechnung(testRechnung));
testRechnung = "5///";
assertEquals(5.0, Rekursiver_Rechner.RekursiveSquentielleBerechnung(testRechnung));
testRechnung = "5***";
assertEquals(5.0, Rekursiver_Rechner.RekursiveSquentielleBerechnung(testRechnung));
testRechnung = "5+-/*";
assertEquals(5.0, Rekursiver_Rechner.RekursiveSquentielleBerechnung(testRechnung));
testRechnung = "+";
assertEquals(0.0, Rekursiver_Rechner.RekursiveSquentielleBerechnung(testRechnung));
testRechnung = "-";
assertEquals(0.0, Rekursiver_Rechner.RekursiveSquentielleBerechnung(testRechnung));
testRechnung = "/";
assertEquals(0.0, Rekursiver_Rechner.RekursiveSquentielleBerechnung(testRechnung));
testRechnung = "*";
assertEquals(0.0, Rekursiver_Rechner.RekursiveSquentielleBerechnung(testRechnung));
testRechnung = "5/0";
assertEquals(Double.POSITIVE_INFINITY, Rekursiver_Rechner.RekursiveSquentielleBerechnung(testRechnung));
testRechnung = "-5/0";
assertEquals(Double.NEGATIVE_INFINITY, Rekursiver_Rechner.RekursiveSquentielleBerechnung(testRechnung));
}
}