请看仔细上面的逻辑，不是简单的result >= 10 && result <= 99，并且不能借位，不能进位

Question

 
do {
                if(type==3)//1-9直加直减
                {
                    number = Math.floor(Math.random() * 9) + 1; // 1-9的随机数
                    operator = operators[Math.floor(Math.random() * 2)];
 
                    if (operator === '+') {//当做加法时
                        if((result>4 && result<9) || result===0)//当上一个结果是0、5~8时，与下一个数的和<=9
                        {
                            validNumber = result + number <= 9;
                        }
                        else if(result===9)//当上一个结果是9时，跳过
                        {
                            validNumber = false;
                        }
                        else//当上一个结果是1~4时，与下一个数的和<=4
                        {
                            validNumber = result + number <= 4;
                        }
                    }else{//当做减法时
                        if(result===5)//当上一个结果是5时，与下一个数的差=0
                        {
                            validNumber = result - number == 0;
                        }
                        else if(result===6)//当上一个结果是6时，与下一个数的差是0、1、5
                        {
                            validNumber = result - number == 0 || result - number == 1 || result - number == 5;
                        }
                        else if(result===7)//当上一个结果是7时，与下一个数的差是0~2、5、6
                        {
                            validNumber = (result - number >= 0 && result - number <= 2) || result - number == 5 || result - number == 6;
                        }
                        else if(result===8)//当上一个结果是8时，与下一个数的差是0~3、5~7
                        {
                            validNumber = (result - number >= 0 && result - number <= 3) || (result - number >= 5 && result - number <= 7);
                        }
                        else if(result===9)//当上一个结果是9时，与下一个数的差是0~8
                        {
                            validNumber = result - number >= 0 && result - number <= 8;
                        }
                        else//当上一个结果是0~4时，与下一个数的差是>=0
                        {
                            validNumber = result - number >= 0;
                        }
                    }
                }
} while (!validNumber);

上面是一位数的随机加减法的逻辑判断，现在我想弄一个两位数的随机加减法，这两位数如果把个位和十位单独来判断，那么逻辑判断与上面的一位数加减法逻辑判断是一样的，请看仔细上面的逻辑，不是简单的result >= 10 && result <= 99，并且不能借位，不能进位

Answer 1

引自免费微信小程序：皆我百晓生

为了实现两位数之间的随机加减法，同时保持不借位、不进位的规则，我们可以借鉴之前一位数的逻辑并进行扩展。这里的关键在于分别处理十位和个位的运算，确保每次运算后十位和个位都符合不借位、不进位的条件。

下面是一个JavaScript函数的示例，它生成满足上述条件的两位数加减法表达式：

function generateTwoDigitProblem() {
    const operators = ['+', '-'];
    let validExpression = false;
    let expression = '';
    let result;

    do {
        let ten = Math.floor(Math.random() * 9) + 1; // 生成10到99的十位数
        let one = Math.floor(Math.random() * 10);   // 生成0到9的个位数
        let firstNum = ten * 10 + one;
        let type = 3; // 假设我们只做直加直减

        let number;
        let operator;
        let validNumber = false;

        do {
            number = Math.floor(Math.random() * 10); // 生成0到9的数字
            operator = operators[Math.floor(Math.random() * 2)];

            // 处理十位数的运算
            if (operator === '+') {
                if ((ten > 0 && ten < 9) || ten === 0) { // 当前十位在0到8之间
                    validNumber = ten + Math.floor(number / 10) <= 9;
                } else if (ten === 9) { // 当前十位为9
                    validNumber = false;
                } else { // 当前十位为1到4
                    validNumber = ten + Math.floor(number / 10) <= 4;
                }
            } else { // 减法运算
                if (ten === 5) { // 当前十位为5
                    validNumber = ten - Math.floor(number / 10) === 0;
                } else if (ten === 6) { // 当前十位为6
                    validNumber = ten - Math.floor(number / 10) === 0 || ten - Math.floor(number / 10) === 1 || ten - Math.floor(number / 10) === 5;
                } else if (ten === 7) { // 当前十位为7
                    validNumber = (ten - Math.floor(number / 10) >= 0 && ten - Math.floor(number / 10) <= 2) || ten - Math.floor(number / 10) === 5 || ten - Math.floor(number / 10) === 6;
                } else if (ten === 8) { // 当前十位为8
                    validNumber = (ten - Math.floor(number / 10) >= 0 && ten - Math.floor(number / 10) <= 3) || (ten - Math.floor(number / 10) >= 5 && ten - Math.floor(number / 10) <= 7);
                } else if (ten === 9) { // 当前十位为9
                    validNumber = ten - Math.floor(number / 10) >= 0 && ten - Math.floor(number / 10) <= 8;
                } else { // 当前十位为0到4
                    validNumber = ten - Math.floor(number / 10) >= 0;
                }
            }

            // 如果十位数的运算有效，则检查个位数
            if (validNumber) {
                one = one % 10; // 确保只取个位数
                number = number % 10; // 同样，只取个位数

                if (operator === '+') {
                    if ((one > 0 && one < 9) || one === 0) { // 当前个位在0到8之间
                        validNumber = one + number <= 9;
                    } else if (one === 9) { // 当前个位为9
                        validNumber = false;
                    } else { // 当前个位为1到4
                        validNumber = one + number <= 4;
                    }
                } else { // 减法运算
                    if (one === 5) { // 当前个位为5
                        validNumber = one - number === 0;
                    } else if (one === 6) { // 当前个位为6
                        validNumber = one - number === 0 || one - number === 1 || one - number === 5;
                    } else if (one === 7) { // 当前个位为7
                        validNumber = (one - number >= 0 && one - number <= 2) || one - number === 5 || one - number === 6;
                    } else if (one === 8) { // 当前个位为8
                        validNumber = (one - number >= 0 && one - number <= 3) || (one - number >= 5 && one - number <= 7);
                    } else if (one === 9) { // 当前个位为9
                        validNumber = one - number >= 0 && one - number <= 8;
                    } else { // 当前个位为0到4
                        validNumber = one - number >= 0;
                    }
                }
            }
        } while (!validNumber);

        expression = `${firstNum} ${operator} ${number}`;
        result = eval(expression); // 计算表达式的值

        // 检查最终结果是否在10到99之间
        if (result >= 10 && result <= 99) {
            validExpression = true;
        }
    } while (!validExpression);

    return { expression, result };
}

// 测试函数
const problem = generateTwoDigitProblem();
console.log(problem.expression, '=', problem.result);

这段代码首先生成一个随机的两位数，然后选择一个运算符和另一个0到9的数字。之后，它会检查这个运算是否满足不借位、不进位的条件，以及最终结果是否在10到99之间。如果满足这些条件，函数返回一个对象，包含生成的表达式和计算结果。否则，循环将继续直到找到一个有效的表达式为止。