Aufgabenstellung v1.0
parent
8cf8a8a613
commit
c21d162358
|
|
@ -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>
|
||||
|
|
@ -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
63
README.md
|
|
@ -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
|
||||
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
|
@ -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));
|
||||
}
|
||||
|
||||
}
|
||||
Loading…
Reference in New Issue