Question

非常感谢任何帮助或建议。我试图创建一个简单的游戏，生成十个不同的随机问题。问题可以包含2,3或4个整数。所以像这样：55 2 - 4 - 101,102 / 3 / 3,589 - 281,123 + 5 6 + 2.

问题将显示在textview中，然后用户可以猜测，在编辑文本中输入值，然后单击我创建的自定义键盘上的键将检查答案，然后显示下一个问题按照10的顺序。

我知道如何创建随机数，只是努力研究如何使用随机运算符创建整个问题（+， - ，/，*）。

非常感谢有时间构建回复的人。

Answer 1

创建一个数组char[] ops = { '+', '-', '/', '*' }并在范围[0,3]中创建一个随机的int i，然后选择ops[i]

您需要注意不要产生除以零问题。

您可以通过创建interface MathOp并创建实现它的4个类来使其更加通用：Divide，Sum，...并创建一个数组：{{1}而不是MathOp[] ops
使用它，它还可以让您更轻松地在以后查看结果...

Answer 2

一些业余时间为您的案例制作了完整示例。创建新的RandomMathQuestionGenerator.java文件并将其编译以进行编译。

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Random;

public class RandomMathQuestionGenerator {

    private static final int NUMBER_OF_QUESTIONS = 10;
    private static final int MIN_QUESTION_ELEMENTS = 2;
    private static final int MAX_QUESTION_ELEMENTS = 4;
    private static final int MIN_QUESTION_ELEMENT_VALUE = 1;
    private static final int MAX_QUESTION_ELEMENT_VALUE = 100;
    private final Random randomGenerator = new Random();

    public static void main(String[] args) {
        RandomMathQuestionGenerator questionGenerator = new RandomMathQuestionGenerator();
        List<Question> randomQuestions = questionGenerator.getGeneratedRandomQuestions();
        for (Question question : randomQuestions) {
            System.out.println(question);
        }
    }

    public List<Question> getGeneratedRandomQuestions() {
        List<Question> randomQuestions = new ArrayList<Question>(NUMBER_OF_QUESTIONS);
        for (int i = 0; i < NUMBER_OF_QUESTIONS; i++) {
            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;
    }
}

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();
    }
}

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()) + " ";
    }
}

enum Operator {

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

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

    public String getDisplayValue() {
        return displayValue;
    }
}

Run and preview.希望这有帮助。

感谢：

Answer 3

将运算符放在一个数组（4个元素）中，生成一个0到3的随机整数，然后选择数组中此索引处的运算符。

每次你需要一个随机算子时，即在除了最后一个之外的每个问题之后都这样做。

Answer 4

创建一个数组，每个运算符都有一个条目。然后生成一个介于0和数组长度减去1之间的随机数。

Answer 5

因此，由于每个操作都是二进制的，因此您可以担心找出基本情况，然后从那里构建表达式。一种简单的方法就是选择一个随机数，以确定将使用哪种操作。

int displayAnswer(int leftSide, int rightSide, int operation {
int answer;
string operation;
    switch(operation) {
        case 1:
            operation = "+";
            answer = leftSide + rightSide;
            break;
        case 2:
            operation = "-";
            answer = leftSide - rightSide;
            break;
        case 3:
            operation = "*";
            answer = leftSide * rightSide;
            break;
        case 4:
            operation = "/";
            answer = leftSide / rightSide:
            break;
    }
    textView.setText(leftSide + operation + rightSide);
    return answer;
}

Android的随机数学问题生成器

5 个答案: