import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Stack;

/**
 * @Auther: Arsenal
 * @Date: 2020-03-21 12:53
 * @Description: 解释器模式
 */
public class Interpreter {
    public static void main(String[] args) throws IOException {
        String expStr = getExpStr();
        // 赋值
        HashMap<String, Integer> var = getValue(expStr);
        Calculator cal = new Calculator(expStr);
        System.out.println("运算");
    }

    // 获得表达式
    public static String getExpStr() throws IOException {
        // 新建一个缓冲区，从缓冲区中读取数据
        return (new BufferedReader(new InputStreamReader(System.in))).readLine();
    }

    // 获得值映射
    public static HashMap<String, Integer> getValue(String expStr) throws IOException {
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        // 解析
        for (char ch : expStr.toCharArray()) {
            if (ch != '+' && ch != '-') {
                if (!map.containsKey(String.valueOf(ch))) {
                    // 从缓冲区中，读取整行
                    String in = (new BufferedReader(new InputStreamReader(System.in))).readLine();
                }
            }
        }
        return map;
    }
}

/**
 * 抽象表达式类
 */
abstract class Expression {
    // 解析数值,key是参数，value是数字
    public abstract int interpreter(HashMap<String, Integer> var);
}

/**
 * 变量解析器
 */
class VarExpression extends Expression {
    private String key;

    public VarExpression(String _key) {
        this.key = _key;
    }

    // map取
    public int interpreter(HashMap<String, Integer> var) {
        return var.get(this.key);
    }
}

/**
 * 抽象运算符号解析器
 */
abstract class SymbolExpression extends Expression {
    // 左数值
    protected Expression left;
    // 右数值
    protected Expression right;

    // 初始化
    public SymbolExpression(Expression _left, Expression _right) {
        this.left = _left;
        this.right = _right;
    }
}

/**
 * 对加法进行解析
 */
class AddExpression extends SymbolExpression {
    public AddExpression(Expression _left, Expression _right) {
        super(_left, _right);
    }

    // 进行相加
    public int interpreter(HashMap<String, Integer> var) {
        // 取得，两边的变量都保存在HashMap表中，根据left和right变量，进行相加
        return super.left.interpreter(var) + super.right.interpreter(var);
    }
}

/**
 * 对减法进行解析
 */
class SubExpression extends SymbolExpression {
    public SubExpression(Expression _left, Expression _right) {
        super(_left, _right);
    }

    // 进行相减
    public int interpreter(HashMap<String, Integer> var) {
        return super.left.interpreter(var) - super.right.interpreter(var);
    }
}

/**
 * 再次对解析器进行封装
 */
class Calculator {
    // 定义表达式
    private Expression expression;

    // 传参
    public Calculator(String expStr) {
        // 用于先后顺序
        Stack<Expression> stack = new Stack();
        // 将表达式拆分
        char[] charArray = expStr.toCharArray();
        // 运算
        Expression left = null;
        Expression right = null;
        for (int i = 0; i < charArray.length; i++) {
            switch (charArray[i]) {
                case '+':
                    // 出栈
                    left = stack.pop();
                    right = new VarExpression(String.valueOf(charArray[++i]));
                    // 将结果入栈
                    stack.push(new AddExpression(left, right));
                    break;
                case '-':
                    // 放入栈中
                    left = stack.pop();
                    right = new VarExpression(String.valueOf(charArray[++i]));
                    stack.push(new SubExpression(left, right));
                    break;
                default:
                    stack.push(new VarExpression(String.valueOf(charArray[i])));
            }
        }
        // 运算结果抛出
        this.expression = stack.pop();
    }

    // 运算
    public int run(HashMap<String, Integer> var) {
        return this.expression.interpreter(var);
    }
}