Wie berechne ich den Wert des mathematischen Ausdrucks und überprüfe die Benutzerantwort?

Question

Jede Hilfe oder Beratung würde sehr geschätzt werden. Ich drehe ein einfaches Spiel, das zehn verschiedene, zufällige Fragen erzeugt. Die Fragen können aus 2, 3 oder 4 ganzen Zahlen zusammengesetzt sein. Etwas wie dieses: 552 − 4 − 101, 102/3/3, 589 − 281, 123 + 56 + 2.

Die Frage wird in einer Textansicht angezeigt und dann kann der Benutzer raten, Werte in einen Bearbeitungstext eingeben und nach dem Klicken auf eine Taste auf einer benutzerdefinierten Tastatur die Antwort prüfen und dann die nächste Frage bis anzeigen es erreicht 10 Fragen. Ich habe ein Problem mit der Eingabe der Antwort aus dem Code, den ich habe. Egal, was ich hier mache, ich kann die Antwort auf den zufällig generierten Ausdruck nicht eingeben.

public enum Operator { 

PLUS("+"), MINUS("-"), MULTIPLIER("*"), DIVIDER("/"); 
private String displayValue; 

private Operator(String displayValue) { 
    this.displayValue = displayValue; 
} 
public String getDisplayValue() { 
    return displayValue; 
}} 




public class Question{ 

private List<QuestionElement> questionElements; 

public Question(int sizeOfQuestionElemets) { 
    questionElements = new ArrayList<QuestionElement>(sizeOfQuestionElemets); 
} 


public void addElement(QuestionElement questionElement) { 
    questionElements.add(questionElement); 
} 

public List<QuestionElement> getElements() { 
    return questionElements; 
} 

public int size() { 
    return questionElements.size(); 
} 

@Override 
public String toString() { 
    StringBuilder sb = new StringBuilder(); 
    for (QuestionElement questionElement : questionElements) { 
     sb.append(questionElement); 
    } 
    return sb.toString().trim(); 
} 
} 

public class QuestionElement { 

private int value; 
private Operator operator; 

public int getValue() { 
    return value; 
} 

public void setValue(int value) { 
    this.value = value; 
} 

public Operator getOperator() { 
    return operator; 
} 

public void setOperator(Operator operator) { 
    this.operator = operator; 
} 

@Override 
public String toString() { 
    return value + (operator == null ? "" : " " + operator.getDisplayValue()) + " "; 
} 
} 

public class RandomQuestions { 


static QuestionElement q = new QuestionElement(); 
private static final int NUMBER_OF_QUESTIONS = 10; 
private static final int MIN_QUESTION_ELEMENTS = 2; 
private static final int MAX_QUESTION_ELEMENTS = 2; 
private static final int MIN_QUESTION_ELEMENT_VALUE = 1; 
private static final int MAX_QUESTION_ELEMENT_VALUE = 20; 
private final Random randomGenerator = new Random(); 




public List<Question> getGeneratedRandomQuestions() { 
    List<Question> randomQuestions = new ArrayList<>(NUMBER_OF_QUESTIONS); 
    int randomQuestionElementsCapacity = getRandomQuestionElementsCapacity(); 
    Question question = new Question(randomQuestionElementsCapacity); 
    for (int j = 0; j < randomQuestionElementsCapacity; j++) { 
     boolean isLastIteration = j + 1 == randomQuestionElementsCapacity; 

     QuestionElement questionElement = new QuestionElement(); 
     questionElement.setValue(getRandomQuestionElementValue()); 
     questionElement.setOperator(isLastIteration ? null 
       : Operator.values()[randomGenerator.nextInt(Operator.values().length)]); 

     question.addElement(questionElement); 
    } 
    randomQuestions.add(question); 

    return randomQuestions; 
} 

private int getRandomQuestionElementsCapacity() { 
    return getRandomIntegerFromRange(MIN_QUESTION_ELEMENTS, MAX_QUESTION_ELEMENTS); 
} 

private int getRandomQuestionElementValue() { 
    return getRandomIntegerFromRange(MIN_QUESTION_ELEMENT_VALUE, MAX_QUESTION_ELEMENT_VALUE); 
} 

private int getRandomIntegerFromRange(int min, int max) { 
    return randomGenerator.nextInt(max - min + 1) + min; 
} 





public static void main(String[] args) { 
    Scanner input = new Scanner(System.in); 
    RandomQuestions questionGenerator = new RandomQuestions(); 
    List<Question> randomQuestions = questionGenerator.getGeneratedRandomQuestions(); 
    for (Question question : randomQuestions) { 
     System.out.println(""+ question+"=?"); 
     int answer = input.nextInt(); 

     if (answer == q.getValue()) { 
      System.out.println("CORRECT"); 
     }else{ 
      System.err.println("STILL NOT WORKING"); 
     } 

    } 
} 
} 

Answer 1

In Ihrem main() Sie drucken question, eine Antwort von dem Benutzer zu lesen und dann die Antwort auf q.getValue() zu vergleichen. q ist ein Frageelement, das sich nicht auf question bezieht und immer den Wert 0 hat. Also ist der Trick zu beantworten 0 egal, was die Frage ist, dann wird das Programm CORRECT drucken. :-)

Ich habe nirgends in Ihrem Code gefunden, wo Sie den richtigen Wert des mathematischen Ausdrucks berechnen. Dies wäre wahrscheinlich ein guter erster Schritt, um zu überprüfen, ob der Benutzer tatsächlich das richtige Ergebnis eingegeben hat.

Die Berechnung des korrekten Ergebnisses ist nicht wirklich trivial, wenn wir darauf bestehen, die Priorität des Operators zu berücksichtigen. 4 + 3 * 2 sollte 10 sein (nicht 14). Ich glaube, dass Lesen über the Shunting-yard algorithm Sie etwas von dem Weg bekommen sollte. Es ist ein Algorithmus für Analysieren ein mathematischer Ausdruck, der nur der erste Schritt zur Berechnung seines Wertes ist, aber immer noch ein erster Schritt.

Ich schlage vor, dass der objektorientierte Ansatz ist, dass das Objekt Question weiß, wie man eine Antwort überprüft. Hier ist eine Implementierung des Algorithmus auf die vier Operatoren vereinfacht, aber erweitert, um tatsächlich die Berechnung zu tun:

public boolean checkAnswer(int answer) { 
    // calculate correct answer 
    // use shunting yard algorithm 
    Deque<Integer> outputQueue = new ArrayDeque<>(); 
    Deque<Operator> operatorStack = new ArrayDeque<>(); 
    for (QuestionElement element : questionElements) { 
     outputQueue.push(element.getValue()); 
     Operator op = element.getOperator(); 
     if (op != null) { 
      while (!operatorStack.isEmpty() && op.getPrecedence() <= operatorStack.peek().getPrecedence()) { 
       int operand2 = outputQueue.pop(); 
       int operand1 = outputQueue.pop(); 
       outputQueue.push(operatorStack.pop().apply(operand1, operand2)); 
      } 
      operatorStack.push(op); 
     } 
    } 
    while (!operatorStack.isEmpty()) { 
     int operand2 = outputQueue.pop(); 
     int operand1 = outputQueue.pop(); 
     outputQueue.push(operatorStack.pop().apply(operand1, operand2)); 
    } 
    int result = outputQueue.pop(); 
    assert outputQueue.isEmpty(); 

    return answer == result; 
} 

Man merkt, dass ich auch einige neue Anforderungen an Ihre Operator Enum gesetzt haben. Es hat Vorrang. Und die + Betreiber muss wissen, wie zusätzlich zu tun (durch seine apply-Methode), und in ähnlicher Weise für die anderen Betreiber:

PLUS("+", 1) { 
    @Override 
    public int apply(int operand1, int operand2) { 
     return operand1 + operand2; 
    } 
}, 
// etc. 

public abstract int apply(int operand1, int operand2); 

und so weiter. 1 ist der Vorrang; * und / höhere Priorität haben, zum Beispiel 2.

Jetzt in main() Sie müssen nur schreiben:

 if (question.checkAnswer(answer)) { 

Wenn Sie an den Benutzer zu erklären, entscheiden, dass streng von links nach rechts Auswertung angewendet wird, es wird immer etwas einfacher:

public boolean checkAnswer(int answer) { 
    // calculate correct answer 
    // do left to right calculation 
    int result = questionElements.get(0).getValue(); 
    for (int elementIndex = 1; elementIndex < questionElements.size(); elementIndex++) { 
     Operator op = questionElements.get(elementIndex - 1).getOperator(); 
     result = op.apply(result, questionElements.get(elementIndex).getValue()); 
    } 

    return answer == result; 
} 

die Betreiber noch die apply Verfahren haben müssen, aber sie müssen nicht mehr den Vorrang.