用c++实现一个带有记分功能的24点游戏（简易版本，只使用1－13之间的数） 基本要求：程序随机自动生成四张牌（以1－13之间的数值代替），游戏者要求尽快给出表达式，只能使用 ＋ － × ％ 运算。可以使用（），不涉及小数运算。比如机器给出四个数为3、3、6、2，游戏者输入表达式：（3＋3－2）×6，程序检查运算成功。如果给出的四个数不能得出24，如：1、2、1、3，那么游戏者必须输入NO，要求计算机进入下一题，但此次如果是正确判断一样记分。如此玩3次，计算总分。任何一次在要求时间内不能给出表达式或NO，那么游戏此轮结束。 测试数据：任意输入4个1—13之间的数 提高要求： （1）设计游戏进入界面。提供游戏难度设置，高手总分查询和进入、退出游戏选项。 （2）设计相应的游戏积分功能，以给出题目到游戏者输入结果之间的时间记分。超过一定的时间未给出答案则取消该轮，每轮3次，记总分（3次分相加）前三名。 （3）游戏使用出牌到要求给出结果之间的时间限制作为游戏的难度级别，可自行设置。

以下是一个简单的C++实现，仅涵盖基本要求：

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <string>
#include <stack>
#include <cmath>

using namespace std;

const int MAX_TIME = 20; // 每道题的最大计算时间（秒）

int score; // 总分数

// 生成1-13之间的随机整数
int randomNum() {
    return rand() % 13 + 1;
}

// 判断是否能够得出24
bool canGet24(int a, int b, int c, int d) {
    // 枚举所有可能的运算方式
    int ops[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
    do {
        // 枚举所有可能的括号方式
        for (int i = 0; i < 16; i += 4) {
            for (int j = 0; j < 8; j++) {
                stack<int> nums;
                stack<int> opsStack;
                nums.push(a);
                nums.push(b);
                nums.push(c);
                nums.push(d);
                opsStack.push(ops[i]);
                opsStack.push(ops[i + 1]);
                opsStack.push(ops[i + 2]);
                opsStack.push(ops[i + 3]);
                // 将括号引起来的部分转化为一个值
                if (j & 1) {
                    int num1 = nums.top();
                    nums.pop();
                    int op = opsStack.top();
                    opsStack.pop();
                    int num2 = nums.top();
                    nums.pop();
                    if (op == 13) {
                        nums.push(num2 * num1);
                    } else {
                        nums.push(num2 % num1);
                    }
                }
                if (j & 2) {
                    int num1 = nums.top();
                    nums.pop();
                    int op = opsStack.top();
                    opsStack.pop();
                    int num2 = nums.top();
                    nums.pop();
                    if (op == 11) {
                        nums.push(num2 + num1);
                    } else {
                        nums.push(num2 - num1);
                    }
                }
                if (j & 4) {
                    int num1 = nums.top();
                    nums.pop();
                    int op = opsStack.top();
                    opsStack.pop();
                    int num2 = nums.top();
                    nums.pop();
                    if (op == 14) {
                        nums.push(num2 * num1);
                    } else {
                        nums.push(num2 / num1);
                    }
                }
                // 最终栈内只剩一个值，判断是否为24
                if (nums.top() == 24) {
                    return true;
                }
            }
        }
    } while (next_permutation(ops, ops + 16));
    return false;
}

// 计算表达式的值
int calculate(const string& expr) {
    stack<int> nums;
    stack<char> ops;
    for (int i = 0; i < expr.length(); i++) {
        if (isdigit(expr[i])) {
            int num = 0;
            while (isdigit(expr[i])) {
                num = num * 10 + expr[i] - '0';
                i++;
            }
            nums.push(num);
            i--;
        } else if (expr[i] == '(') {
            ops.push(expr[i]);
        } else if (expr[i] == ')') {
            while (ops.top() != '(') {
                int num2 = nums.top();
                nums.pop();
                int num1 = nums.top();
                nums.pop();
                char op = ops.top();
                ops.pop();
                int res;
                switch (op) {
                    case '+':
                        res = num1 + num2;
                        break;
                    case '-':
                        res = num1 - num2;
                        break;
                    case '*':
                        res = num1 * num2;
                        break;
                    case '%':
                        res = num1 % num2;
                        break;
                    default:
                        break;
                }
                nums.push(res);
            }
            ops.pop();
        } else if (expr[i] == '+' || expr[i] == '-') {
            while (!ops.empty() && (ops.top() == '+' || ops.top() == '-' || ops.top() == '*' || ops.top() == '%')) {
                int num2 = nums.top();
                nums.pop();
                int num1 = nums.top();
                nums.pop();
                char op = ops.top();
                ops.pop();
                int res;
                switch (op) {
                    case '+':
                        res = num1 + num2;
                        break;
                    case '-':
                        res = num1 - num2;
                        break;
                    case '*':
                        res = num1 * num2;
                        break;
                    case '%':
                        res = num1 % num2;
                        break;
                    default:
                        break;
                }
                nums.push(res);
            }
            ops.push(expr[i]);
        } else if (expr[i] == '*' || expr[i] == '%') {
            while (!ops.empty() && (ops.top() == '*' || ops.top() == '%')) {
                int num2 = nums.top();
                nums.pop();
                int num1 = nums.top();
                nums.pop();
                char op = ops.top();
                ops.pop();
                int res;
                switch (op) {
                    case '*':
                        res = num1 * num2;
                        break;
                    case '%':
                        res = num1 % num2;
                        break;
                    default:
                        break;
                }
                nums.push(res);
            }
            ops.push(expr[i]);
        }
    }
    while (!ops.empty()) {
        int num2 = nums.top();
        nums.pop();
        int num1 = nums.top();
        nums.pop();
        char op = ops.top();
        ops.pop();
        int res;
        switch (op) {
            case '+':
                res = num1 + num2;
                break;
            case '-':
                res = num1 - num2;
                break;
            case '*':
                res = num1 * num2;
                break;
            case '%':
                res = num1 % num2;
                break;
            default:
                break;
        }
        nums.push(res);
    }
    return nums.top();
}

int main() {
    srand(time(nullptr));
    int level;
    cout << "请选择游戏难度（1-5）：";
    cin >> level;
    int numRound = 3; // 每轮游戏的次数
    for (int round = 1; round <= numRound; round++) {
        int a = randomNum(), b = randomNum(), c = randomNum(), d = randomNum();
        cout << "第" << round << "题：" << a << " " << b << " " << c << " " << d << endl;
        time_t startTime = time(nullptr); // 记录开始时间
        string expr;
        cin >> expr;
        time_t endTime = time(nullptr); // 记录结束时间
        if (expr == "NO") { // 放弃本题
            cout << "您已放弃本题" << endl;
        } else {
            if (canGet24(a, b, c, d) && calculate(expr) == 24) {
                int timeUsed = endTime - startTime;
                if (timeUsed <= MAX_TIME) {
                    score += (MAX_TIME - timeUsed) * level; // 计算得分
                    cout << "回答正确！用时" << timeUsed << "秒，得分" << (MAX_TIME - timeUsed) * level << "分" << endl;
                } else {
                    cout << "回答超时，本题无分" << endl;
                }
            } else {
                cout << "回答错误，本题无分" << endl;
            }
        }
    }
    cout << "本次游戏结束，总得分为" << score << "分" << endl;
    return 0;
}

其中，`randomNum()`函数用于生成1-13之间的随机整数，`canGet24()`函数用于判断是否能够得出24，`calculate()`函数用于计算表达式的值。

在主程序中，首先让用户选择游戏难度，然后进入每轮游戏循环。每轮游戏中，先生成四个随机数，然后让用户输入表达式，记录开始时间和结束时间，并根据所用时间和计算结果计算得分。如果用户放弃本题，则不计分。最后输出总得分。

需要注意的是，由于C++自带的时间函数精度有限，实际计时可能存在一定误差。