转换多个数字字符exp[i]为一个整型数num

可以使用以下代码将多个数字字符转换为一个整型数：

exp = '12345'
num = int(exp)
print(num)

这将输出整型数 `12345`。如果你要将多个数字字符转换为整型数，可以将它们连接成一个字符串，然后使用 `int()` 函数将其转换为整型数。

相关问题

算术表达式求值。演示程序和源程序已给出。用户从键盘输入一个算术表达式，数字都是十进制整型（必须支持负数），运算符支持+-*/()。 编写源程序中的 double deal_exp (char *exp) 函数，对这个算术表达式求值，返回结果。不限制方法，你可以用“原始”的多遍扫描字符串，也可以用先进一点的栈

以下是使用栈实现算术表达式求值的代码示例：

#include <iostream>
#include <stack>
#include <string>

using namespace std;

// 判断字符是否为数字
bool is_digit(char c) {
    return c >= '0' && c <= '9';
}

// 将字符转换成数字
int char_to_digit(char c) {
    return c - '0';
}

// 计算两个数字的运算结果
double calculate(double a, double b, char op) {
    switch (op) {
        case '+':
            return a + b;
        case '-':
            return a - b;
        case '*':
            return a * b;
        case '/':
            return a / b;
        default:
            return 0.0;
    }
}

// 处理算术表达式
double deal_exp(char *exp) {
    stack<double> nums;     // 存放数字的栈
    stack<char> ops;        // 存放运算符的栈

    for (int i = 0; exp[i] != '\0'; i++) {
        if (is_digit(exp[i])) {     // 如果当前字符是数字，则将其转换成数字并入栈
            int num = char_to_digit(exp[i]);
            i++;
            while (is_digit(exp[i])) {
                num = num * 10 + char_to_digit(exp[i]);
                i++;
            }
            i--;
            nums.push(num);
        } else if (exp[i] == '(') {  // 如果当前字符是左括号，则将其入栈
            ops.push(exp[i]);
        } else if (exp[i] == ')') {  // 如果当前字符是右括号，则进行计算直到遇到左括号
            while (ops.top() != '(') {
                double b = nums.top();
                nums.pop();
                double a = nums.top();
                nums.pop();
                char op = ops.top();
                ops.pop();
                nums.push(calculate(a, b, op));
            }
            ops.pop();
        } else if (exp[i] == '+' || exp[i] == '-') {   // 如果当前字符是加减号
            while (!ops.empty() && ops.top() != '(') { // 如果栈顶元素是乘除号，则进行计算
                double b = nums.top();
                nums.pop();
                double a = nums.top();
                nums.pop();
                char op = ops.top();
                ops.pop();
                nums.push(calculate(a, b, op));
            }
            ops.push(exp[i]);
        } else if (exp[i] == '*' || exp[i] == '/') {   // 如果当前字符是乘除号
            while (!ops.empty() && (ops.top() == '*' || ops.top() == '/')) { // 如果栈顶元素是乘除号，则进行计算
                double b = nums.top();
                nums.pop();
                double a = nums.top();
                nums.pop();
                char op = ops.top();
                ops.pop();
                nums.push(calculate(a, b, op));
            }
            ops.push(exp[i]);
        }
    }

    while (!ops.empty()) {  // 处理剩余的运算符和数字
        double b = nums.top();
        nums.pop();
        double a = nums.top();
        nums.pop();
        char op = ops.top();
        ops.pop();
        nums.push(calculate(a, b, op));
    }

    return nums.top();
}

int main() {
    char exp[100];
    cout << "请输入算术表达式：";
    cin >> exp;

    double result = deal_exp(exp);

    cout << "计算结果为：" << result << endl;

    return 0;
}

这个程序使用两个栈分别存放数字和运算符。扫描算术表达式，遇到数字就入数字栈，遇到运算符就和运算符栈顶元素比较优先级，如果当前运算符优先级较高，则入栈；否则，取出数字栈中的两个数字和运算符栈顶元素进行计算，并将结果入数字栈，重复上述操作直到扫描完整个算术表达式。最后，将数字栈中的唯一元素作为计算结果返回。

用c语言写算术表达式求值。演示程序和源程序已给出。用户从键盘输入一个算术表达式，数字都是十进制整型（必须支持负数），运算符支持+-*/()。 编写源程序中的 double deal_exp (char *exp) 函数，对这个算术表达式求值，返回结果。不限制方法，你可以用“原始”的多遍扫描字符串，也可以用先进一点的栈

以下是用栈实现的 C 语言源代码：

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>

#define MAX_LEN 100 // 定义最大字符串长度
#define MAX_STACK 50 // 定义栈的最大深度

// 定义栈结构体
typedef struct {
    int top;
    double data[MAX_STACK];
} Stack;

// 初始化栈
void init_stack(Stack *s) {
    s->top = -1;
}

// 判断栈是否为空
int is_empty(Stack *s) {
    return s->top == -1;
}

// 判断栈是否已满
int is_full(Stack *s) {
    return s->top == MAX_STACK - 1;
}

// 入栈操作
void push(Stack *s, double value) {
    if (is_full(s)) {
        printf("Stack Overflow!\n");
        exit(1);
    }
    s->data[++s->top] = value;
}

// 出栈操作
double pop(Stack *s) {
    if (is_empty(s)) {
        printf("Stack Underflow!\n");
        exit(1);
    }
    return s->data[s->top--];
}

// 获取栈顶元素
double top(Stack *s) {
    if (is_empty(s)) {
        printf("Stack Underflow!\n");
        exit(1);
    }
    return s->data[s->top];
}

// 判断当前字符是否为操作符
int is_operator(char c) {
    return (c == '+' || c == '-' || c == '*' || c == '/');
}

// 判断当前字符是否为左括号
int is_left_parenthesis(char c) {
    return (c == '(');
}

// 判断当前字符是否为右括号
int is_right_parenthesis(char c) {
    return (c == ')');
}

// 获取操作符的优先级
int get_priority(char c) {
    int priority = 0;
    switch(c) {
        case '+':
        case '-':
            priority = 1;
            break;
        case '*':
        case '/':
            priority = 2;
            break;
        default:
            break;
    }
    return priority;
}

// 计算表达式
double calculate(double a, char operator, double b) {
    double result = 0.0;
    switch(operator) {
        case '+':
            result = a + b;
            break;
        case '-':
            result = a - b;
            break;
        case '*':
            result = a * b;
            break;
        case '/':
            if (b == 0) {
                printf("Divide by zero error!\n");
                exit(1);
            }
            result = a / b;
            break;
        default:
            break;
    }
    return result;
}

// 处理表达式
double deal_exp(char *exp) {
    Stack num_stack, op_stack;
    double num1, num2;
    char c, op;

    init_stack(&num_stack);
    init_stack(&op_stack);
    while (*exp != '\0') {
        if (isdigit(*exp) || *exp == '-') {
            char *p = exp;
            while (isdigit(*++exp)); // 找到数字的末尾
            int len = exp - p;
            char str_num[MAX_LEN];
            strncpy(str_num, p, len); // 将数字转成字符串
            str_num[len] = '\0';
            double num = atof(str_num); // 将字符串转成浮点数
            push(&num_stack, num);
        }
        else if (is_operator(*exp)) {
            while (!is_empty(&op_stack) && get_priority(*exp) <= get_priority(top(&op_stack))) {
                num2 = pop(&num_stack);
                num1 = pop(&num_stack);
                op = pop(&op_stack);
                push(&num_stack, calculate(num1, op, num2));
            }
            push(&op_stack, *exp);
            exp++;
        }
        else if (is_left_parenthesis(*exp)) {
            push(&op_stack, *exp);
            exp++;
        }
        else if (is_right_parenthesis(*exp)) {
            while (!is_left_parenthesis(top(&op_stack))) {
                num2 = pop(&num_stack);
                num1 = pop(&num_stack);
                op = pop(&op_stack);
                push(&num_stack, calculate(num1, op, num2));
            }
            pop(&op_stack); // 弹出左括号
            exp++;
        }
        else {
            exp++;
        }
    }
    while (!is_empty(&op_stack)) {
        num2 = pop(&num_stack);
        num1 = pop(&num_stack);
        op = pop(&op_stack);
        push(&num_stack, calculate(num1, op, num2));
    }

    return pop(&num_stack);
}

int main() {
    char exp[MAX_LEN];
    printf("请输入算术表达式：\n");
    scanf("%s", exp);
    double result = deal_exp(exp);
    printf("结果为：%lf\n", result);
    return 0;
}

使用方法：

用户输入一个算术表达式，程序将自动计算表达式的值并输出。例如，输入表达式"-2*(3+4)/5"，程序将输出结果"-2.800000"。