四则运算

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {

    // 存放算数优先级
    public static HashMap<Character, Integer> map = new
    HashMap<Character, Integer>() { //这里泛型必须写
        // 声明优先级
        {
            put('-', 1);
            put('+', 1);
            put('*', 2);
            put('/', 2);
        }
    };

    public static boolean isNumber(char c) {
        return Character.isDigit(c);
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        System.out.println(calculate(str));
    }

    public static int calculate(String str) {

        // 处理特殊括号,注意替换后的值，不要写错了。且replace后要重新赋值给str
        str = str.replaceAll("\\[", "(").replaceAll("\\{", "(").replaceAll("\\]",
                ")").replaceAll("\\}", ")").replaceAll(" ", "");

        // 处理负数
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) == '-') {
                if (i == 0 || str.charAt(i - 1) == '+' || str.charAt(i - 1) == '-' ||
                        str.charAt(i - 1) == '*' || str.charAt(i - 1) == '/' ||
                        str.charAt(i - 1) == '(')
                    str = str.substring(0, i) + "#" + str.substring(i + 1);

            }
        }

        //初始化两个栈，分别存放运算术和运算符
        Stack<Integer> nums = new Stack<>();
        Stack<Character> opts = new Stack<>();
        char[] cs = str.toCharArray();
        int n = cs.length;
        for (int i = 0; i < n; i++) {
            char c = cs[i];

            //判断负数、左括号、右括号、普通运算数、+-*/
            if (c == '#') {
                int j = i + 1, v =
                            0; // 运算符往后一位，所以是i+1，正数会直接是j=i
                while (j < n && isNumber(cs[j])) {
                    v = v * 10 + cs[j++] - '0';
                }
                nums.add(-v);
                i = j - 1; //多位数处理
            } else if (c == '(') {
                opts.add(c);
            } else if (c == ')') {
                // 计算括号内的数据，直到栈顶为（为止
                while (opts.peek() != '(') {
                    cal(nums, opts);
                }
                opts.pop(); //左括号出栈
            } else {

                // 正数
                if (isNumber(c)) {
                    int j = i, v = 0;
                    while (j < n && isNumber(cs[j])) {
                        v = v * 10 + cs[j++] - '0';
                    }
                    nums.add(v);
                    i = j - 1;
                } else {
                    while(!opts.isEmpty() && opts.peek() != '('){
                        char prev = opts.peek();
                        if(map.get(prev) >= map.get(c)){
                            cal(nums,opts);
                        }else{
                            break;
                        }
                    }
                    opts.add(c);
                    
            }
        
        }
        }

        while (!opts.isEmpty()) {
            cal(nums, opts);
        }

        return nums.peek();

    }

    public static void cal(Stack<Integer> nums, Stack<Character> opts) {
        if (nums.isEmpty() || nums.size() < 2) {
            return;
        }

        if (opts.isEmpty()) {
            return;
        }

        int b = nums.pop(), a = nums.pop();
        char op = opts.pop();
        int ans = 0;
        switch (op) {
            case '+' :
                ans = a + b;
                break;
            case '-':
                ans = a - b;
                break;
            case '*':
                ans = a * b;
                break;
            case '/':
                ans = a / b;
                break;
            default:
                break;
        }
        nums.add(ans);
    }

}

import java.util.Scanner;
import java.util.*;
import java.util.stream.Collectors;
import java.text.DecimalFormat;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    private static Map<Character, Integer> ***bsp;= new HashMap<>();

    public static void main(String[] args) {
        por.put('+', 0);
        por.put('-', 0);
        por.put('*', 1);
        por.put('/', 1);
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextLine()) {
            String str = sc.nextLine().trim().replace("{", "(").replace("}", ")")
                    .replace("[", "(").replace("]", ")");
            if (str.startsWith("-")) {
                str = "0" + str;
            }
            StringBuilder sb0 = new StringBuilder();
            for (int i = 0; i < str.length(); i++) {
                if (i > 0 && str.charAt(i) == '-' && str.charAt(i - 1) == '(') {
                    sb0.append("0");
                }
                sb0.append(str.charAt(i));
            }
            str = sb0.toString();
//            System.out.println(str);
            Stack<Character> stack = new Stack<>();
            List<String> list = new ArrayList<>();
            for (int i = 0; i < str.length(); i++) {
                char c = str.charAt(i);
                switch (c) {
                    case '+':
                    case '-':
                    case '*':
                    case '/':
                        while (stack.size() > 0 && stack.peek() != '(' && por.get(c) <= por.get(stack.peek())) {
                            list.add(stack.pop() + "");
                        }
                        stack.push(c);
                        break;
                    case '(':
                        stack.push(c);
                        break;
                    case ')':
                        while (stack.size() > 0) {
                            Character pop = stack.pop();
                            if (pop != '(') {
                                list.add(pop + "");
                            } else {
                                break;
                            }
                        }
                        break;
                    default:
                        String num = c + "";
                        while (i < str.length() - 1 && str.charAt(i + 1) >= '0' && str.charAt(i + 1) <= '9') {
                            num += str.charAt(i + 1);
                            i++;
                        }
                        list.add(num);
                }
            }
            while (stack.size() > 0) {
                list.add(stack.pop() + "");
            }
            double res = calc(list.toArray(new String[]{}));
            DecimalFormat df = new DecimalFormat("0.################");
            System.out.println(df.format(res));
        }
    }

    private static double calc(String[] pattern) {
        for (int i = pattern.length - 1; i >= 0; i--) {
            String s = pattern[i];
            if (s.length() == 1 && por.containsKey(s.charAt(0)) && i > 1 && isNum(pattern[i - 1]) && isNum(pattern[i - 2])) {
                double v1 = Double.parseDouble(pattern[i - 1]);
                double v2 = Double.parseDouble(pattern[i - 2]);
                double res = getRes(s, v1, v2);
                pattern[i] = "null";
                pattern[i - 2] = res + "";
                pattern[i - 1] = "null";
            }
        }
        String[] arr = Arrays.stream(pattern).filter(s -> !s.equals("null")).collect(Collectors.toList()).toArray(new String[]{});
        if(arr.length==1){
            return Double.parseDouble(arr[0]);
        }
        if (arr.length == 3) {
            double r = getRes(arr[arr.length - 1], Double.parseDouble(arr[1]), Double.parseDouble(arr[0]));
            return r;
        }
        return calc(arr);
    }

    private static double getRes(String op, double v1, double v2) {
        double res;
        switch (op) {
            case "+":
                res = v2 + v1;
                break;
            case "-":
                res = v2 - v1;
                break;
            case "*":
                res = v2 * v1;
                break;
            default:
                res = v2 / v1;
                break;
        }
        return res;
    }

    private static boolean isNum(String value) {
        try {
            Double.parseDouble(value);
        } catch (NumberFormatException e) {
            return false;
        }
        return true;
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

/**
 * @className: _4_9
 * @author: Lian
 * @date: 2023-10-03 16:51
 */
public class _5_0 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        Stack<Character> operator = new Stack<>();
        ArrayList<String> list = new ArrayList<>();
        Map<Character, Integer> hashMap = new HashMap<>();
        Stack<Double> stack = new Stack<>();
        hashMap.put('(', 0);
        hashMap.put('-', 1);
        hashMap.put('+', 1);
        hashMap.put('*', 2);
        hashMap.put('/', 2);
        StringBuilder str = new StringBuilder(br.readLine().replace('{', '(').replace('}', ')').replace('[', '(').replace(']', ')'));
        int count = 0;
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) == '-')
                count++;
        }
        while (true) {
            for (int i = 0; i < str.length(); i++) {
                if (str.charAt(i) == '-') {
                    if (i == 0 ||str.charAt(i)=='(') {
                        str.insert(i + 2, ")");
                        str.insert(i, "(0");
                        break;
                    }
                }
            }
            break;
        }

        char[] chars = str.toString().toCharArray();

        for (int i = 0; i < chars.length; i++) {
            if (Character.isDigit(chars[i])) {
                int j = 0;
                while (i+j<chars.length&&Character.isDigit(chars[i + j])) {
                    j++;
                }
                list.add(String.copyValueOf(chars, i, j));
                i=i+j-1;
                continue;
            }
            if (chars[i] == '(') {
                operator.push(chars[i]);
                continue;
            }
            if (chars[i] == ')') {
                while (operator.peek() != '(') {
                    char c = operator.pop();
                    list.add(String.valueOf(c));
                }
                operator.pop();
                continue;
            }
            if (operator.isEmpty()) {
                operator.push(chars[i]);
                continue;
            }
            while (!operator.isEmpty() && hashMap.get(chars[i]) <= hashMap.get(operator.peek())) {
                char c = operator.pop();
                list.add(String.valueOf(c));
            }
            operator.push(chars[i]);
        }
        while (!operator.isEmpty()) {
            list.add(String.valueOf(operator.pop()));
        }

        for (int i = 0; i < list.size(); i++) {
            if (Character.isDigit(list.get(i).charAt(0))) {
                stack.push(Double.valueOf(list.get(i)));
                continue;
            }
            double a = stack.pop();
            double b = stack.pop();
            if (list.get(i).equals("+")) {
                stack.push(a + b);
                continue;
            }
            if (list.get(i).equals("*")) {
                stack.push(a * b);
                continue;
            }
            if (list.get(i).equals("-")) {
                stack.push(b - a);
                continue;
            }
            if (list.get(i).equals("/")) {
                stack.push(b / a);
            }
        }

        System.out.printf("%.0f%n", stack.peek());
    }
}

public class Test01 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) { 
            String str = in.nextLine();
            System.out.println(solution(str));
        }
    }
    public static int solution(String str){
        Stack<Integer> numStack = new Stack<>();
        Stack<Character> pStack = new Stack<>();
        for (int i = 0; i < str.length(); i++) {
            char a = str.charAt(i);
            //1、如果是括号
            if(a=='('||a=='['||a=='{'){ 
                pStack.push(a);
                int end = i;
                //找到括号的结尾
                for (int j = i+1; j < str.length(); j++) {
                    char k = str.charAt(j);
                    if(k=='('||k=='['||k=='{'){
                        pStack.push(k);
                    }else if(k==')'||k==']'||k=='}'){
                        pStack.pop();
                        if(pStack.isEmpty()||(pStack.peek()!='('&& pStack.peek()!='{'&& pStack.peek()!='[')){
                            end = j;
                            break;
                        }
                    }
                }
                //递归计算括号中的结果push到数字栈中。
                numStack.push(solution(str.substring(i+1,end)));
                //更新i的值。
                i=end;
            }else if((i==0&&a=='-')||Character.isDigit(a)){ //2、找到的是数字，需要考虑负数开头。
                String num = a+"";
                i++;
                while(i<str.length()&&Character.isDigit(str.charAt(i))){
                    num+=str.charAt(i);
                    i++;
                }
                numStack.push(Integer.parseInt(num));
                i--;
            }else{ //3、找到的是符号
                if(!pStack.isEmpty()){
                    //如果找到的符号运算级小于等于栈中的符号，则先计算栈中的，如果大于栈中运算符，直接push。
                    if(a=='+'||a=='-'){
                        //遇到+、-需要将栈中的全部都计算了。
                        while(!pStack.isEmpty()){
                            numStack.push(operation(numStack.pop(),numStack.pop(),pStack.pop()));
                        }
                    }else if((a=='*'|| a=='/')&&(pStack.peek()=='*'||pStack.peek()=='/')){
                        numStack.push(operation(numStack.pop(),numStack.pop(),pStack.pop()));
                    }
                }
                //将运算符压入符号栈。
                pStack.push(a);
            }
        }
        //计算剩余元素的结果。
        while(!pStack.isEmpty()){
            numStack.push(operation(numStack.pop(),numStack.pop(),pStack.pop()));
        }
        return numStack.pop();
    }
    public static int operation(int a , int b , Character p){
        if(p=='+'){
            return b+a;
        }else if(p=='-'){
            return b-a;
        }else if(p=='*'){
            return b*a;
        }else{
            return b/a;
        }
    }
}

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String express = in.next();
        express = express.replace("{", "(");
        express = express.replace("[", "(");
        express = express.replace("}", ")");
        express = express.replace("]", ")");

        System.out.print(comput(dealParent(express)));

    }
    // 处理括号
    public static String dealParent(String str) {
        ArrayList<Integer> parent = new ArrayList<>();
        char[] carr = str.toCharArray();
        String temp = str;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < carr.length; i++) {
            if (carr[i] == '(') {
                parent.add(i);
            }
            if (carr[i] == ')') {
                int start = parent.get(parent.size() - 1);
                String com = temp.substring(start + 1, i);
                String res = comput(com);
                sb.append(temp.substring(0, start));
                // 添加空格补齐位数
                int differ = i - start + 1 - res.length();
                for (int j = 0; j < differ; j++) {
                    sb.append(" ");
                }
                sb.append(res);
                if (i != carr.length - 1) {
                    sb.append(temp.substring(i + 1, temp.length()));
                }
                temp = sb.toString();
                sb.setLength(0);
                parent.remove(parent.size() - 1);
            }
        }
        return temp;
    }
    // 将字符串公式拆分成字符串数组
    public static ArrayList<String> toStrArr(String str) {
        str = str.replace(" ", "");
        ArrayList<String> exArr = new ArrayList<>();
        char[] carr = str.toCharArray();
        int start = 0;
        for (int i = 0; i < carr.length; i++) {
            if (i == 0 && carr[i] == '-') {
                continue;
            }
            if (carr[i] == '-' && (carr[i - 1] == '+' || carr[i - 1] == '*' ||
                                   carr[i - 1] == '/' || carr[i - 1] == '-')) {
                continue;
            }
            if (carr[i] == '+' || carr[i] == '-' || carr[i] == '*' || carr[i] == '/') {
                exArr.add(str.substring(start, i));
                exArr.add(str.substring(i, i + 1));
                start = i + 1;
            }
            if (i == carr.length - 1) {
                exArr.add(str.substring(start, carr.length));
            }
        }
        return exArr;
    }
    // 不带括号的计算
    public static String comput(String str) {
        ArrayList<String> arr = toStrArr(str);
        for (int i = 0; i < arr.size(); i++) {
            if (arr.get(i).equals("*") || arr.get(i).equals("/")) {
                int a = Integer.parseInt(arr.get(i - 1));
                int b = Integer.parseInt(arr.get(i + 1));
                int res;
                if (arr.get(i).equals("*")) {
                    res = a * b;
                } else {
                    res = a / b;
                }
                arr.set(i + 1, String.valueOf(res));
                arr.set(i, " ");
                arr.set(i - 1, " ");
                i++;
            }
        }
        while (arr.contains(" ")) {
            arr.remove(" ");
        }
        for (int i = 0; i < arr.size(); i++) {
            if (arr.get(i).equals("+") || arr.get(i).equals("-")) {
                int a = Integer.parseInt(arr.get(i - 1));
                int b = Integer.parseInt(arr.get(i + 1));
                int res;
                if (arr.get(i).equals("+")) {
                    res = a + b;
                } else {
                    res = a - b;
                }
                arr.set(i + 1, String.valueOf(res));
                arr.set(i, " ");
                arr.set(i - 1, " ");
                i++;
            }
        }
        while (arr.contains(" ")) {
            arr.remove(" ");
        }
        return arr.get(0);
    }

}

import java.util.*;

// 大无语，怎么有这种这么繁琐的题啊 ！！！！
public class Main {
    public static int index = 0;
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.next();
        System.out.println(getExpression(s));
    }
    public static int getExpression(String s) {
        ArrayList<Integer> numArray = new ArrayList<>();
        ArrayList<Character> signArray = new ArrayList<>();
        HashMap<Character, Character> hp = new HashMap<>();
        hp.put('[', ']');
        hp.put('(', ')');
        hp.put('{', '}');

        int i = 0;
        int count = 0;
        StringBuilder strBuilder;
        while (i < s.length()) {
            if (i >= s.length()) break;
            char ch = s.charAt(i);
            if (ch == '(' || ch == '[' || ch == '{') {
                i++;
                count = 0;
                strBuilder = new StringBuilder();
                while (i < s.length() && (s.charAt(i) != hp.get(ch) || count != 0)) {
                    if (s.charAt(i) == ch) count++;
                    if (s.charAt(i) == hp.get(ch)) count--;
                    strBuilder.append(s.charAt(i));
                    i++;
                }
                i++;
                numArray.add(getExpression(strBuilder.toString()));
            }else if (ch == '+' || ch == '-' || ch == '*' || ch == '/') {
                signArray.add(ch);
                i++;
            } else {
                int num = 0;
                while (i < s.length() && s.charAt(i) >= '0' && s.charAt(i) <= '9') {
                    num = num * 10 + s.charAt(i) - '0';
                    i++;
                }
                numArray.add(num);
            }
        }
        
        Stack<Character> signStack = new Stack<>();
        Stack<Integer> numStack = new Stack<>();
        int indexArrayNum = 0, indexArraySign = 0;
        if (numArray.size() == signArray.size()) {
            numArray.set(0,-numArray.get(0));
            indexArraySign++;
        }
        numStack.push(numArray.get(indexArrayNum++));
        while (indexArraySign < signArray.size()) {
            char ch = signArray.get(indexArraySign++);
            if (ch == '+' || ch == '-') {
                signStack.push(ch);
                numStack.push(numArray.get(indexArrayNum++));
            }
            else if (ch == '*') {
                int a = numStack.pop();
                int b = numArray.get(indexArrayNum++);
                numStack.push(a * b);
            }else {
                int a = numStack.pop();
                int b = numArray.get(indexArrayNum++);
                numStack.push(a / b);
            }
        }
        Stack<Character> signStack02 = new Stack<>();
        Stack<Integer> numStack02 = new Stack<>();
        while (!signStack.isEmpty()) {
            signStack02.push(signStack.pop());
        }
        while (!numStack.isEmpty()) {
            numStack02.push(numStack.pop());
        }
        while (!signStack02.isEmpty()) {
            int a = numStack02.pop();
            int b = numStack02.pop();
            char ch = signStack02.pop();
            if (ch == '+')
                numStack02.push(a + b);
            else
                numStack02.push(a - b);
        }

        return numStack02.pop();
    }
}

import java.util.Scanner;
import java.util.List;
import java.util.ArrayList;
import java.util.Stack;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        //中括号、大括号全部转为小括号，方便处理
        str = str.replace('[', '(');
        str = str.replace('{', '(');
        str = str.replace(']', ')');
        str = str.replace('}', ')');
        //1.将String类型的中缀表达式转成List<String>类型的中缀表达式
        List<String> infixList = infixStringToList(str);
        //2.将List<String>类型的中缀表达式转成List<String>类型的后缀表达式
        List<String> suffixList = infixToSuffix(infixList);
        //3.将List<String>类型的后缀表达式进行计算
        int res = calculateSuffixNotation(suffixList);
        System.out.println(res);
    }
    //1.将String类型的中缀表达式转成List<String>类型
    public static List<String> infixStringToList(String str) {
        List<String> list = new ArrayList<>();
        int i = 0;
        while (i < str.length()) {
            if (str.charAt(i) == '+' || str.charAt(i) == '*' || str.charAt(i) == '/' || str.charAt(i) == '(' || str.charAt(i) == ')') {
                list.add(String.valueOf(str.charAt(i)));
                i++;
            } else if (str.charAt(i) == '-') {//考虑负数
                if ((str.charAt(i) == '-' && str.charAt(i-1) == '(' && str.charAt(i+1)>= 48 && str.charAt(i+1)<= 57) || (str.charAt(i) == '-' && i == 0 && str.charAt(i+1)>= 48 && str.charAt(i+1)<= 57)) {
                    list.add(String.valueOf(str.charAt(i))+String.valueOf(str.charAt(i+1)));
                    i = i + 2;
                } else {
                    list.add(String.valueOf(str.charAt(i)));
                    i++;
                }
            } else {
                StringBuilder sb = new StringBuilder();
                //考虑多位数
                while (i < str.length() && str.charAt(i) >= 48 && str.charAt(i) <= 57) {
                    sb.append(str.charAt(i));
                    i++;
                }
                list.add(sb.toString());
            }
        }
        return list;
    }
    //2.将List<String>类型的中缀表达式转成List<String>类型的后缀表达式
    public static List<String> infixToSuffix(List<String> infixList) {
        Stack<String> operationStack = new Stack<>();
        List<String> tempResList = new ArrayList<>();
        for (String s : infixList) {
            if (s.matches("\\d+")) {
                tempResList.add(s);
            } else if (s.matches("-\\d+")) {
                tempResList.add(s);
            } else if ("(".equals(s)) {
                operationStack.push(s);
            } else if (")".equals(s)) {
                while (!operationStack.peek().equals("(")) {
                    tempResList.add(operationStack.pop());
                }
                operationStack.pop();//去掉"("
            } else {
                //如果s的运算优先级小于等于operationStack栈顶元素的优先级
                //将operationStack栈顶元素弹出并加入tempResList中
                //直到s可以入operationStack栈
                while (operationStack.size() != 0 && operationPriority(s) <= operationPriority(operationStack.peek())) {
                    tempResList.add(operationStack.pop());
                }
                operationStack.push(s);
            }
        }
        while (operationStack.size() != 0) {
            tempResList.add(operationStack.pop());
        }
        return tempResList;
    }
    //3.将List<String>类型的后缀表达式进行计算
    //思想：遇到数字入栈,遇到操作符则将栈顶元素和栈顶元素的下一个元素进行操作符对应的运算后入栈
    //     其中被减数和被除数是栈顶元素的下一个元素
    public static int calculateSuffixNotation(List<String> suffixList) {
        Stack<Integer> stack = new Stack<>();
        for (String s : suffixList) {
            if ("+".equals(s)) {
                stack.push(stack.pop()+stack.pop());
            } else if ("-".equals(s)) {
                stack.push(-stack.pop()+stack.pop());
            } else if ("*".equals(s)) {
                stack.push(stack.pop()*stack.pop());
            } else if ("/".equals(s)) {
                int temp1 = stack.pop();
                int temp2 = stack.pop();
                stack.push(temp2 / temp1);
            } else {
                stack.push(Integer.parseInt(s));
            }
        }
        //经过以上运算最终栈中只剩下一个元素
        return stack.pop();
    }
    public static int operationPriority(String operation) {
        if ("+".equals(operation) || "-".equals(operation)) {
            return 0;
        } else if ("*".equals(operation) || "/".equals(operation)) {
            return 1;
        } else {
            return -1;
        }
    }
}

import java.util.LinkedList;
import java.util.Scanner;
public class Main {
    public static void main(String[] args)  {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String s = sc.nextLine();
            s.replace("{", "(");
            s.replace("}", ")");
            s.replace("[", "(");
            s.replace("]", ")");
            char[] chars = s.toCharArray();
            LinkedList stringStack = new LinkedList();
            LinkedList digitStack = new LinkedList();
            //先将输入的运算表达式变为后缀表达式
            //创建一个链表存放后缀表达式
            LinkedList list = new LinkedList();
            //存放数字字符
            StringBuilder digit = new StringBuilder();
            for (int i = 0; i < chars.length; i++) {
                if (Character.isDigit(chars[i])) {
                    if (i == chars.length - 1) {
                        digit.append(chars[i]);
                        list.add(digit.toString());
                        digit.delete(0, digit.length());
                    } else if (Character.isDigit(chars[i + 1])) {
                        digit.append(chars[i]);
                    } else {
                        digit.append(chars[i]);
                        list.add(digit.toString());
                        digit.delete(0, digit.length());
                    }
                } else if (chars[i] == '(') {
                    stringStack.push(String.valueOf(chars[i]));
                } else if (chars[i] == ')') {
                    while (stringStack.peek() != null) {
                        if (stringStack.peek().equals("(")) {
                            stringStack.pop();
                            break;
                        }
                        list.add(stringStack.pop());
                    }
                } else {
                    if (chars[i] == '+' || chars[i] == '-') {
                        while (stringStack.peek() != null && (stringStack.peek().equals("*")
                                                              || stringStack.peek().equals("/")
                                                              || stringStack.peek().equals("+")
                                                              || stringStack.peek().equals("-"))) {
                            if (stringStack.peek().equals("(")) {
                                break;
                            }
                            list.add(stringStack.pop());
                        }
                    }
                    stringStack.push(String.valueOf(chars[i]));
                }
                if (i == chars.length - 1) {
                    while (stringStack.peek() != null) {
                        list.add(stringStack.pop());
                    }
                }
            }
            int num1 = 0;
            int num2 = 0;
            //将后缀表达式进行计算
            for (int i = 0; i < list.size(); i++) {
                char[] c = list.get(i).toCharArray();
                if (Character.isDigit(c[0])) {
                    digitStack.push(Integer.parseInt(list.get(i)));
                    continue;
                }
                switch (list.get(i)) {
                    case "-":
                        num2 = digitStack.pop();
                        num1 = digitStack.pop();
                        digitStack.push(num1 - num2);
                        break;
                    case "+":
                        num2 = digitStack.pop();
                        num1 = digitStack.pop();
                        digitStack.push(num1 + num2);
                        break;
                    case "*":
                        num2 = digitStack.pop();
                        num1 = digitStack.pop();
                        digitStack.push(num1 * num2);
                        break;
                    case "/":
                        num2 = digitStack.pop();
                        num1 = digitStack.pop();
                        digitStack.push(num1 / num2);
                        break;
                }
            }
            System.out.println(digitStack.peek());
        }
    }
}

// 只需注意第一个数和括号里面的第一个数是否为负数，如果是负数，提前加个0
// 如果未遇到右括号时，运算符以左括号为边界，如(1+2+3*4)，先计算1+2->(3+3*4)
import java.util.*;

public class Main{
    static Deque<Character> ops = new LinkedList<>();
    static Deque<Integer> nums = new LinkedList<>();
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        if (s.charAt(0) == '-') {
            nums.push(0);
        }
        Map<Character, Integer> map = new HashMap<>();
        map.put('+', 1);
        map.put('-', 1);
        map.put('*', 2);
        map.put('/', 2);
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (Character.isDigit(c)) {
                int num = 0, j = i;
                while (j < s.length() && Character.isDigit(s.charAt(j))) {
                    num = num * 10 + s.charAt(j++) - '0';
                }
                nums.push(num);
                i = j - 1;
            } else if (c == '(' || c == '{' || c == '[') {
                ops.push(c);
                if (s.charAt(i + 1) == '-') {
                    nums.push(0);
                }
            } else if (c == ')' || c == '}' || c == ']') {
                while (ops.peek() != '(') {
                    eval();
                }
                ops.pop();
            } else {
                while (!ops.isEmpty() && ops.peek() != '(' && map.get(ops.peek()) >= map.get(c)) {
                    eval();
                }
                ops.push(c);
            }
        }
        while (!ops.isEmpty()) {
            eval();
        }
        System.out.println(nums.peek());
    }
    
    static void eval() {
        int b = nums.pop(), a = nums.pop();
        char c = ops.pop();
        if (c == '+') {
            nums.push(a + b);
        } else if (c == '-') {
            nums.push(a - b);
        } else if (c == '*') {
            nums.push(a * b);
        } else {
            nums.push(a / b);
        }
    }
}