表达式求值

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.Stack;
import java.util.regex.Pattern;
public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        List<String> ls = transform(input);
        Stack<String> my = reverse(doTrans(ls));
        int result = doCalc(my);
        System.out.println(result);
    }

    public static Stack<String> reverse(Stack<String> my) {
        Stack<String> stack = new Stack();
        while (!my.empty()) {
            stack.push(my.pop());
        }
        return stack;
    }

    public static int doCalc(Stack<String> my) {
        Stack<Integer> s1 = new Stack();  // 临时存储
        while (!my.empty()) {
            String ch = my.pop();
            switch (ch) {
                case "+":
                    int b1 = s1.pop();
                    int a1 = s1.pop();
                    s1.push(a1 + b1);
                    break;
                case "-":
                    int b2 = s1.pop();
                    int a2 = s1.pop();
                    s1.push(a2 - b2);
                    break;
                case "*":
                    int b3 = s1.pop();
                    int a3 = s1.pop();
                    s1.push(a3 * b3);
                    break;
                case "/":
                    int b4 = s1.pop();
                    int a4 = s1.pop();
                    s1.push(a4 / b4);
                    break;
                default:
                    s1.push(Integer.parseInt(ch));    //如果当前的字符数字, 则直接压入s1
                    break;
            }
        }
        return s1.pop();
    }


    /**
     * 转换中缀表达式为后缀表达式
     *
     * @param ls String
     * @return Stack
     */
    public static Stack<String> doTrans(List<String> ls){
        Stack<String> s1 = new Stack();
        Stack<String> s2 = new Stack();
        if (!ls.isEmpty()) {
            for(String ch : ls) {
                switch (ch) {
                    case "+":
                    case "-":
                        compAndPush(ch, 1, s1, s2);
                        break;
                    case "*":
                    case "/":
                        compAndPush(ch, 2, s1, s2);
                        break;
                    case "(":
                        s1.push(ch); //如果当前字符是'(',则将其入栈
                        break;
                    case ")":
                        gotParen(ch, s1, s2);
                        break;
                    default:
                        //1、如果当前解析的字符是操作数，则直接压入s2
                        s2.push(ch);
                        break;
                }
            }

            while(!s1.isEmpty()){
                s2.push(s1.pop());
            }
        }

        return s2;
    }

    public static void compAndPush(String opThis, int pre1, Stack<String> s1, Stack<String> s2){
        while (!s1.isEmpty()) {
            String opTop = s1.peek();
            if ("(".equals(opTop)) {
                s1.push(opThis);
                break; // 如果栈顶是'(',直接将操作符压入s1,跳出循环
            } else {
                int pre2 = getPriority(opTop); // 获取优先级
                if (pre2 < pre1) {
                    s1.push(opThis);
                    break; // 如果当前运算符比s1栈顶运算符优先级高，则将运算符压入s1,跳出循环
                } else {
                    s2.push(s1.pop()); // 如果当前运算符比s1栈顶运算符优先级低或等于，则将运算符压入s1,结合while继续循环
                }
            }
        }
        if (s1.isEmpty()) {
            s1.push(opThis); // 如果s1为空直接压入s1
        }
    }

    public static int getPriority(String opTop) {
        if ("+".equals(opTop) || "-".equals(opTop)) {
            return 1;
        } else {
            return 2;
        }
    }

    public static void gotParen(String ch, Stack<String> s1, Stack<String> s2){
        while(!s1.isEmpty()){
            String chx = s1.pop();
            if("(".equals(chx)){
                break;
            }else{
                s2.push(chx);
            }
        }
    }

    public static List<String> transform(String str) {
        List<String> ls = new ArrayList<>();
        String[] strLs = str.split("");
        StringBuffer sb = new StringBuffer();
        for (int i = 0 ; i < strLs.length; i++) {
            String s = strLs[i];
            String pattern = "[()*+/]";
            String pattern1 = "[(*+/]";
            if (Pattern.matches(pattern, s)) { //运算符号()*+/
                if (!sb.toString().isEmpty()) {
                    ls.add(sb.toString());
                    sb = new StringBuffer();
                }
                ls.add(s);
            } else {
                if ("-".equals(s)) {
                    if (i == 0 || Pattern.matches(pattern1, strLs[i - 1])) { // 负数
                        sb.append("-");
                    } else {   // 减号
                        if (!sb.toString().isEmpty()) {
                            ls.add(sb.toString());
                            sb = new StringBuffer();
                        }
                        ls.add(s);
                    }
                } else {  // 数字
                    sb.append(s);
                }
            }

        }
        if (!sb.toString().isEmpty()) {
            ls.add(sb.toString());
        }
        return ls;
    }
}

python 3 一行的解法：

print(eval(input()))

//我matlab也不是吃素的
fprintf('%d\n',eval(input('','s')));

//思路：
//1.字符串预处理，针对可能出现的“{，},[,],-”等特殊情况进行替换,判断‘-’是负号还是减号,负号前面+0，转变成减法运算
//2.将中缀字符串转变为后缀字符串数组
//3.对后缀字符串数组进行求解
#include<iostream>
#include<vector>
#include<string>
#include<stack>
#include<sstream>
using namespace std;
bool cmpPriority(char top,char cur)//比较当前字符与栈顶字符的优先级，若栈顶高，返回true
{
    if((top=='+' || top=='-') && (cur=='+' || cur=='-'))
        return true;
 if((top=='*' || top=='/') && (cur=='+' || cur=='-'|| top=='*' || top=='/'))
        return true;
    if(cur==')')
        return true;
    return false;
}
void preProcess(string &str)//对字符串进行预处理
{
    for(int i=0;i<str.size();++i)
    {
        if(str[i]=='{')//将‘{、}、[,]’替换成'()'
            str[i]='(';
        else if(str[i]=='}')
            str[i]=')';
        else if(str[i]=='[')
            str[i]='(';
        else if(str[i]==']')
            str[i]=')';
        else if(str[i]=='-')
        {
            if(i==0)//将'-'前面添加0转变成减法运算
                str.insert(0,1,'0');
            else if(str[i-1]=='(')
                str.insert(i,1,'0');
  }
 }
}
vector<string> mid2post(string &str)
{
    vector<string>vstr;
    stack<char>cstack;
    for(int i=0;i<str.size();++i)//扫描字符串
    {
        string temp="";
        if(str[i]>='0' && str[i]<='9')//若是数字
        {
            temp+=str[i];
            while(i+1<str.size() && str[i+1]>='0' && str[i+1]<='9')
            {
                temp+=str[i+1];//若是连续数字
                ++i;
   }
            vstr.push_back(temp);
  }
        else if(cstack.empty() || str[i]=='(')//若栈空或者字符为'('
            cstack.push(str[i]);
        else if(cmpPriority(cstack.top(),str[i]))//若栈顶元素优先级较高，栈顶元素出栈
        {
            if(str[i]==')')//若当前字符是右括号，栈中元素出栈，入字符串数组中，直到遇到'('
            {
                while(!cstack.empty() && cstack.top()!='(')
                {
                    temp+=cstack.top();
                    cstack.pop();
                    vstr.push_back(temp);
                    temp="";
                }
                cstack.pop();                    
            }
            else//栈中优先级高的元素出栈，入字符串数组，直到优先级低于当前字符
            {
                while(!cstack.empty() && cmpPriority(cstack.top(),str[i]))
                {
                    temp+=cstack.top();
                    cstack.pop();
                    vstr.push_back(temp);
                    temp="";
                }
                cstack.push(str[i]);
   }
        }
        else//当前字符优先级高于栈顶元素，直接入栈
         cstack.push(str[i]);
    }
    while(!cstack.empty())//栈中还存在运算符时，出栈，存入字符串数组
    {
        string temp="";
        temp+=cstack.top();
        cstack.pop();
        vstr.push_back(temp);
    }
    return vstr;
}
int calcPostExp(vector<string> & vstr)//对后缀表达式进行求值，主要是根据运算符取出两个操作数进行运算
{
    int num,op1,op2;
    stack<int>opstack;
    for(int i=0;i<vstr.size();++i)
    {
        string temp=vstr[i];
        if(temp[0]>='0' && temp[0]<='9')//如果当前字符串是数字，利用字符串流转化为int型
        {
            stringstream ss;
            ss<<temp;
            ss>>num;
            opstack.push(num);
        }
        else if(vstr[i]=="+")//若是操作符，取出两个操作数，进行运算，并将结果存入
        {
            op2=opstack.top();
            opstack.pop();
            op1=opstack.top();
            opstack.pop();
            opstack.push(op1+op2);
        }
        else if(vstr[i]=="-")
        {
            op2=opstack.top();
            opstack.pop();
            op1=opstack.top();
            opstack.pop();
            opstack.push(op1-op2);
        }
        else if(vstr[i]=="*")
        {
            op2=opstack.top();
            opstack.pop();
            op1=opstack.top();
            opstack.pop();
            opstack.push(op1*op2);
        }
        else if(vstr[i]=="/")
        {
            op2=opstack.top();
            opstack.pop();
            op1=opstack.top();
            opstack.pop();
            opstack.push(op1/op2);
        }
    }
    return opstack.top();//最终的栈顶元素就是求解的结果
}
void calcExp(string str)
{
    vector<string>vstr;
    preProcess(str);//对字符串进行预处理
    vstr=mid2post(str);//将中缀表达式转为后缀，保存在字符串数组中，方便下一步求解
    int res=calcPostExp(vstr);
    cout<<res<<endl;
}
int main()
{
    string str;
    while(getline(cin,str))
    {
        calcExp(str);
 }
    return 0;
}

这是道简单题？我是沙笔，不想刷NM算法题了，好想上岸

print(eval(input()))

"""
题目说表达式合法性由做题者检查，并非程序检查，所以简单问题简单处理
while True:
    try:
        raw_str = input()
        valid_str = '+-*/()0123456789'
        if len(raw_str) > 100:
            print("Input exceeds maximum length")
        else:
            for i in raw_str:
                if i not in valid_str:
                    print("Input contains invalid string")
            print(eval(raw_str))    
    except:
        break
"""
print(eval(input()))

import java.util.*;
import javax.script.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) throws Exception {
        Scanner scan = new  Scanner(System.in);
        String input = scan.nextLine();
        ScriptEngine scriptEngine = new ScriptEngineManager().getEngineByName("nashorn");
        System.out.println(scriptEngine.eval(input));
    }
}

中缀表达式转后缀，你和我说是简单题

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import java.util.Scanner;

public class Main
{
    public static void main(String args[]) {
        String enter;
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()){
            enter = in.nextLine();
            ScriptEngineManager manager = new ScriptEngineManager();
            ScriptEngine engine = manager.getEngineByName("js");
            try {
                Object result = engine.eval(enter);
                System.out.println(result);
            } catch (ScriptException e) {
                e.printStackTrace();
            }

        }
    }
}

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

using namespace std;
stack<int> nums;
stack<char> sig;
int core(int num1,int num2,char sig)
{
    if(sig=='+')
        return num1+num2;
    if(sig=='-')
        return num2-num1;
    if(sig=='*')
        return num1*num2;
    else if(num1!=0)
        return num2/num1;
    return -1;

}
void calc()
{
    int num1=nums.top();
    nums.pop();
    int num2=nums.top();
    nums.pop();
    char c=sig.top();
    sig.pop();
    nums.push(core(num1,num2,c));

}
int main()
{
    string s;
    while(cin>>s)
    {
        int l=s.length();       
        for(int i=0;i<l;i++)
        {
            if(s[i]>='0'&&s[i]<='9')
            {
                int j=i+1;
                int temp=s[i]-48;
                while(j<l&&s[j]>='0'&&s[j]<='9')
                    temp=temp*10+(s[j++]-48);
                nums.push(temp);
                i=--j;
            }
            else
            {
                if(sig.empty()||s[i]=='(')
                {
                    sig.push(s[i]);
                    continue;
                }
                else if(s[i]=='+'||s[i]=='-')
                {
                    while(!sig.empty()&&sig.top()!='(')
                        calc();
                    sig.push(s[i]);
                }
                else if(s[i]=='*'||s[i]=='/')
                {
                    while(!sig.empty()&&(sig.top()=='*'||sig.top()=='/'))
                        calc();
                    sig.push(s[i]);
                }
                else if(s[i]==')')
                {
                    while(!sig.empty()&&sig.top()!='(')
                        calc();
                    sig.pop();
                }
            }
        }
        while(!sig.empty())
            calc();
        cout<<nums.top()<<endl;
        nums.pop();
    }
}

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void async function () {
    // Write your code here
    while(line = await readline()){
        // console.log(eval(line))
        console.log(Function(`return ${line}`)())
    }
}()

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

using namespace std;

int main() {
    string expre;
    while (cin >> expre) {
        vector<char> exp;
        stack<char> op;
        // 3-10+(0+(10+5+3)-10)
        // 3 10 - 0 10 5 + 3 + + 10 - +
        for (size_t i = 0; i < expre.length(); i++) {
            if (expre[i] >= '0' && expre[i] <= '9') {
                if (i > 0 && expre[i - 1] >= '0' && expre[i - 1] <= '9') {
                    int tmp = exp.back() - '0';
                    tmp = tmp * 10 + expre[i];
                    exp.pop_back();
                    exp.push_back(tmp);
                } else {
                    exp.push_back(expre[i]);
                }
            } else if (expre[i] == ')') {
                while (!op.empty() && op.top() != '(') {
                    exp.push_back(op.top());
                    op.pop();
                }
                op.pop();
            }
            else if (expre[i] == '-' || expre[i] == '+') {
                if (expre[i] == '-') {
                    if (i == 0 || expre[i - 1] == '(') {
                        exp.push_back('0');
                    }
                }
                while (!op.empty() && (op.top() == '+' || op.top() == '-' || op.top() == '*' || op.top() == '/')) {
                    exp.push_back(op.top());
                    op.pop();
                }
                op.push(expre[i]);
            } else if (expre[i] == '*' || expre[i] == '/') {
                while (!op.empty() && (op.top() == '*' || op.top() == '/')) {
                    exp.push_back(op.top());
                    op.pop();
                }
                op.push(expre[i]);
            } else {
                op.push(expre[i]);
            }
        }

        while (!op.empty()) {
            exp.push_back(op.top());
            op.pop();
        }

        stack<int> res;
        for (size_t i = 0; i < exp.size(); i++) {
            if (exp[i] == '+' || exp[i] == '-' || exp[i] == '*' || exp[i] == '/') {
                int val1 = res.top();
                res.pop();
                int val2 = res.top();
                res.pop();
                int tmp;
                if (exp[i] == '+') {
                    tmp = val2 + val1;
                } else if (exp[i] == '-') {
                    tmp = val2 - val1;
                } else if (exp[i] == '*') {
                    tmp = val2 * val1;
                } else if (exp[i] == '/'){
                    tmp = val2 / val1;
                }
                res.push(tmp);
            } else {
                res.push(exp[i] - '0');
            }
        }
        cout << res.top() << endl;
    }

    return 0;
}

let line = readline()
let reg = /^[0-9]|[+-/()*]$/
let isReg = true
for(let temp of line) {
    if(!reg.test(temp)) {
        isReg = false
    }
}
if(isReg) {
    console.log(eval(line))
}