import sys
h = dict()
for line in sys.stdin:
    line = line.strip().split()
    if line[0] == "MOV":
        if line[2].startswith("-") or line[2].isdigit():
            h[line[1]] = eval(line[2])
        else:
            h[line[1]] = h[line[2]]
    elif line[0] == "ADD":
        if line[2] not in h:
            line[2] = eval(line[2])
        if line[3] not in h:
            line[3] = eval(line[3])
        h[line[1]] = h.get(line[2], line[2]) + h.get(line[3], line[3])
    elif line[0] == "SUB":
        if line[2] not in h:
            line[2] = eval(line[2])
        if line[3] not in h:
            line[3] = eval(line[3])
        h[line[1]] = h.get(line[2], line[2]) - h.get(line[3], line[3])
    elif line[0] == "MUL":
        if line[2] not in h:
            line[2] = eval(line[2])
        if line[3] not in h:
            line[3] = eval(line[3])
        h[line[1]] = h.get(line[2], line[2]) * h.get(line[3], line[3])
    elif line[0] == "DIV":
        if line[2] not in h:
            line[2] = eval(line[2])
        if line[3] not in h:
            line[3] = eval(line[3])
        h[line[1]] = h.get(line[2], line[2]) // h.get(line[3], line[3])
    else:
        print(h[line[1]])

def get_index(dst_name):
    return int(dst_name[1:])

def what_src(src,dst):
    if src[0] == 'a':
        return dst[get_index(src)]
    else:
        return int(src)

dst = [0] * 32 
def main():
    import sys
    input = sys.stdin.read
    data = input().strip().split("\n")
    for line in data:
        order = line.split()
        op = order[0]
        if op == 'MOV':
            dst_name, src = order[1],order[2]
            dst[get_index(dst_name)] = what_src(src,dst)
        if op == 'ADD':
            dst_name, src0, src1 = order[1], order[2], order[3]
            dst[get_index(dst_name)] = what_src(src0,dst) + what_src(src1,dst)
        if op == 'SUB':
            dst_name, src0, src1 = order[1], order[2], order[3]
            dst[get_index(dst_name)] = what_src(src0,dst) - what_src(src1,dst)
        if op == 'MUL':
            dst_name, src0, src1 = order[1], order[2], order[3]
            dst[get_index(dst_name)] = what_src(src0,dst) * what_src(src1,dst)
        if op == 'DIV':
            dst_name, src0, src1 = order[1], order[2], order[3]
            dst[get_index(dst_name)] = what_src(src0,dst) // what_src(src1,dst)
        if op == 'PRINT':
            dst_name = order[1]
            print(dst[get_index(dst_name)])

if __name__ == "__main__":
    main()

#include<iostream>
#include <vector>
#include <sstream>
#include <unordered_map>
#include <cmath>

using namespace std;

int main() {
    unordered_map<string, int> map;
    vector<string> vec;
    string str;
    while (getline(cin, str)) {
        vec.push_back(str);
    }
    for (auto s: vec) {
//        cout << s << endl;
        stringstream ss(s);
        vector<string> words;
        string word;
        while (ss >> word) {
            words.push_back(word);
        }
        if (words[0] == "PRINT") {
            cout << map[words[1]] << endl;
        } else if (words[0] == "MOV") {
            map[words[1]] = words[2][0] == 'a' ? map[words[2]] : stoi(words[2]);
        } else if (words[0] == "ADD") {
            int a, b;
            a = words[2][0] == 'a' ? map[words[2]] : stoi(words[2]);
            b = words[3][0] == 'a' ? map[words[3]] : stoi(words[3]);
            map[words[1]] = a + b;
        } else if (words[0] == "SUB") {
            int a, b;
            a = words[2][0] == 'a' ? map[words[2]] : stoi(words[2]);
            b = words[3][0] == 'a' ? map[words[3]] : stoi(words[3]);
            map[words[1]] = a - b;
        } else if (words[0] == "MUL") {
            int a, b;
            a = words[2][0] == 'a' ? map[words[2]] : stoi(words[2]);
            b = words[3][0] == 'a' ? map[words[3]] : stoi(words[3]);
            map[words[1]] = a * b;
        } else if (words[0] == "DIV") {
            float a, b;
            a = words[2][0] == 'a' ? map[words[2]] : stoi(words[2]);
            b = words[3][0] == 'a' ? map[words[3]] : stoi(words[3]);
            map[words[1]] = a/b<0?int(a/b)-1:int(a/b);
        }
    }
    return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <cmath>
using namespace std;

int main()
{
    string operation;
    map<string, int> var_data;
    while(getline(cin, operation))
    {
        int a = operation.find(" ");
        string order = operation.substr(0,a);
        operation = operation.substr(a+1);
        if(order == "MOV")
        {
            int a = operation.find(" ");
            string var = operation.substr(0,a);
            int data = stoi(operation.substr(a+1));
            var_data[var]=data;
        }
        else if(order == "ADD")
        {
            int a = operation.find(" ");
            string var1 = operation.substr(0,a);
            operation = operation.substr(a+1);
            int b = operation.find(" ");
            string var2 = operation.substr(0,b);
            string var3 = operation.substr(b+1);
            if(var_data.find(var2)!=var_data.end() && var_data.find(var3)!=var_data.end())
            {
                var_data[var1]=var_data[var2]+var_data[var3];
            }
            else if(var_data.find(var2)==var_data.end() && var_data.find(var3)!=var_data.end())
            {
                var_data[var1]=stoi(var2)+var_data[var3];
            }
            else if(var_data.find(var2)!=var_data.end() && var_data.find(var3)==var_data.end())
            {
                var_data[var1]=var_data[var2]+stoi(var3);
            }
            else if(var_data.find(var2)==var_data.end() && var_data.find(var3)==var_data.end())
            {
                var_data[var1]=stoi(var2)+stoi(var3);
            }
        }
        else if(order == "SUB")
        {
            int a = operation.find(" ");
            string var1 = operation.substr(0,a);
            operation = operation.substr(a+1);
            int b = operation.find(" ");
            string var2 = operation.substr(0,b);
            string var3 = operation.substr(b+1);
            if(var_data.find(var2)!=var_data.end() && var_data.find(var3)!=var_data.end())
            {
                var_data[var1]=var_data[var2]-var_data[var3];
            }
            else if(var_data.find(var2)==var_data.end() && var_data.find(var3)!=var_data.end())
            {
                var_data[var1]=stof(var2)-var_data[var3];
            }
            else if(var_data.find(var2)!=var_data.end() && var_data.find(var3)==var_data.end())
            {
                var_data[var1]=var_data[var2]-stof(var3);
            }
            else if(var_data.find(var2)==var_data.end() && var_data.find(var3)==var_data.end())
            {
                var_data[var1]=stof(var2)-stof(var3);
            }
        }
        else if(order == "MUL")
        {
            int a = operation.find(" ");
            string var1 = operation.substr(0,a);
            operation = operation.substr(a+1);
            int b = operation.find(" ");
            string var2 = operation.substr(0,b);
            string var3 = operation.substr(b+1);
            if(var_data.find(var2)!=var_data.end() && var_data.find(var3)!=var_data.end())
            {
                var_data[var1]=var_data[var2]*var_data[var3];
            }
            else if(var_data.find(var2)==var_data.end() && var_data.find(var3)!=var_data.end())
            {
                var_data[var1]=stoi(var2)*var_data[var3];
            }
            else if(var_data.find(var2)!=var_data.end() && var_data.find(var3)==var_data.end())
            {
                var_data[var1]=var_data[var2]*stoi(var3);
            }
            else if(var_data.find(var2)==var_data.end() && var_data.find(var3)==var_data.end())
            {
                var_data[var1]=stoi(var2)*stoi(var3);
            }
        }
        else if(order == "DIV")
        {
            int a = operation.find(" ");
            string var1 = operation.substr(0,a);
            operation = operation.substr(a+1);
            int b = operation.find(" ");
            string var2 = operation.substr(0,b);
            string var3 = operation.substr(b+1);
            if(var_data.find(var2)!=var_data.end() && var_data.find(var3)!=var_data.end())
            {
                var_data[var1]=floor(float(var_data[var2])/var_data[var3]);
            }
            else if(var_data.find(var2)==var_data.end() && var_data.find(var3)!=var_data.end())
            {
                var_data[var1]=floor(float(stof(var2))/var_data[var3]);
            }
            else if(var_data.find(var2)!=var_data.end() && var_data.find(var3)==var_data.end())
            {
                var_data[var1]=floor(float(var_data[var2])/stof(var3));
            }
            else if(var_data.find(var2)==var_data.end() && var_data.find(var3)==var_data.end())
            {
                var_data[var1]=floor(float(stoi(var2))/stof(var3));
            }
        }
        else if(order == "PRINT")
        {
            string var1 = operation;
            cout << var_data[var1] <<endl;
        }
    }
    return 0;
}

题面解释:

这道题要求我们设计一个简单的虚拟机解释器，能够解析和执行一系列虚拟指令。虚拟机包含32个32位的整形寄存器（a0到a31），并且只使用寄存器和立即数进行计算。指令可以分为几种类型：MOV dst src 用于将源（src）赋值给目标寄存器（dst）；ADD dst src0 src1 将两个源相加；SUB dst src0 src1 将第一个源减去第二个源；MUL dst src0 src1 将两个源相乘；DIV dst src0 src1 将第一个源除以第二个源并向下取整；PRINT dst 用于输出目标寄存器的值。输入为若干行指令，输出为对每条PRINT指令的寄存器值。

思路

模拟题，根据题意模拟即可。

需要注意的几个点：

• 题目并未事先确定输入的行数，所以需要读到末尾 EOF 为止
• 在进行 ADD 和 SUB 操作时，并不知道两个数是以寄存器形式还是立即数形式给出，所以需要判断出来，然后获取到对应的数值进行计算即可
• 除法操作下取整，C++ 的除法是向零取整，需要自行处理成向下取整

时间复杂度：$O(n)$ ，$n$ 为输入的行数

题解

本题要求我们实现一个简单的虚拟机解释器，能够解析和执行一系列指令。虚拟机的核心在于32个整形寄存器（a0到a31），我们可以使用寄存器和立即数进行计算。指令包括移动数据、加法、减法、乘法、除法以及打印寄存器的值。我们的任务是根据输入的指令，正确地修改寄存器的值，并在遇到PRINT指令时输出相应的寄存器值。

主要操作说明

1. MOV 指令：将源的值（寄存器或立即数）赋给目标寄存器。
2. ADD、SUB、MUL、DIV 指令：分别执行加法、减法、乘法和除法操作，结果存入目标寄存器。特别地，DIV指令需要向下取整，确保结果正确。
3. PRINT 指令：打印指定寄存器的值。

输入输出

• 输入：程序通过标准输入逐行读取指令，直到EOF为止。
• 输出：对于每条PRINT指令，输出目标寄存器的当前值。

特殊情况处理

• 在进行加法、减法、乘法和除法操作时，源值可能是寄存器或立即数，因此需要判断并获取正确的值。
• 为了实现向下取整的除法，需要使用floor函数来处理整除。

代码

C++

#include <iostream>
#include <cstring>
#include <cmath>

using namespace std;

// 获取寄存器或立即数的ID（从字符串的第二个字符开始转为整数）
int getIds(string dstSrc) {
    return stoi(dstSrc.substr(1));
}

// 从源字符串中获取值
int getValueFromSrcStr(string src, int dst[]) {
    // 如果来源是寄存器（以字母'a'开头）
    if (src[0] == 'a') {
        return dst[getIds(src)]; // 返回对应寄存器的值
    }
    // 如果来源是立即数，直接转为整数返回
    return stoi(src); // 将字符串转为整数
}

// 寄存器数组，全局变量，初始化为0
int dst[32];

int main() {
    // 读取用户输入
    string op; // 用于存储当前指令
    // 将寄存器数组初始化为0
    memset(dst, 0, sizeof(dst));

    // 循环读取指令直到输入结束
    while (cin >> op) { // 读取每一条指令
        if (op == "MOV") {
            // MOV指令，获取目标寄存器和源值
            string dstStr, src; // 目标寄存器和源值字符串
            cin >> dstStr >> src; // 读取目标寄存器和源
            dst[getIds(dstStr)] = getValueFromSrcStr(src, dst); // 执行赋值操作
        } else if (op == "ADD") {
            // ADD指令，获取目标寄存器和两个源值
            string dstStr, src0, src1; // 目标寄存器和两个源
            cin >> dstStr >> src0 >> src1; // 读取数据
            dst[getIds(dstStr)] = getValueFromSrcStr(src0, dst) + getValueFromSrcStr(src1, dst); // 执行加法
        } else if (op == "SUB") {
            // SUB指令，获取目标寄存器和两个源值
            string dstStr, src0, src1; // 目标寄存器和两个源
            cin >> dstStr >> src0 >> src1; // 读取数据
            dst[getIds(dstStr)] = getValueFromSrcStr(src0, dst) - getValueFromSrcStr(src1, dst); // 执行减法
        } else if (op == "MUL") {
            // MUL指令，获取目标寄存器和两个源值
            string dstStr, src0, src1; // 目标寄存器和两个源
            cin >> dstStr >> src0 >> src1; // 读取数据
            dst[getIds(dstStr)] = getValueFromSrcStr(src0, dst) * getValueFromSrcStr(src1, dst); // 执行乘法
        } else if (op == "DIV") {
            // DIV指令，获取目标寄存器和两个源值，并进行整除
            string dstStr, src0, src1; // 目标寄存器和两个源
            cin >> dstStr >> src0 >> src1; // 读取数据
            dst[getIds(dstStr)] = (int)floor((double)getValueFromSrcStr(src0, dst) / getValueFromSrcStr(src1, dst)); // 执行向下取整的除法
        } else {
            // PRINT指令，打印目标寄存器的值
            string dstStr; // 目标寄存器
            cin >> dstStr; // 读取目标寄存器
            cout << dst[getIds(dstStr)] << endl; // 输出寄存器的值
        }
    }

    return 0; // 程序结束
}

Python

def get_ids(dst_src):
    # 提取寄存器编号
    return int(dst_src[1:])

def get_value_from_src_str(src):
    # 来源是寄存器
    if src[0] == 'a':
        return dst[get_ids(src)]
    # 来源是立即数
    return int(src)

dst = [0] * 32  # 初始化寄存器数组

def main():
    import sys
    input = sys.stdin.read
    data = input().strip().split("\n")
    
    for line in data:
        parts = line.split()
        op = parts[0]  # 操作码

        if op == "MOV":
            dst_str, src = parts[1], parts[2]
            # 将 src 的值移动到目标寄存器
            dst[get_ids(dst_str)] = get_value_from_src_str(src)
        elif op == "ADD":
            dst_str, src0, src1 = parts[1], parts[2], parts[3]
            # 执行加法运算
            dst[get_ids(dst_str)] = get_value_from_src_str(src0) + get_value_from_src_str(src1)
        elif op == "SUB":
            dst_str, src0, src1 = parts[1], parts[2], parts[3]
            # 执行减法运算
            dst[get_ids(dst_str)] = get_value_from_src_str(src0) - get_value_from_src_str(src1)
        elif op == "MUL":
            dst_str, src0, src1 = parts[1], parts[2], parts[3]
            # 执行乘法运算
            dst[get_ids(dst_str)] = get_value_from_src_str(src0) * get_value_from_src_str(src1)
        elif op == "DIV":
            dst_str, src0, src1 = parts[1], parts[2], parts[3]
            # 执行除法运算，向下取整
            dst[get_ids(dst_str)] = get_value_from_src_str(src0) // get_value_from_src_str(src1)
        else:
            dst_str = parts[1]
            # 输出寄存器的值
            print(dst[get_ids(dst_str)])

if __name__ == "__main__":
    main()

Java

import java.util.Arrays; // 导入数组工具类
import java.util.Scanner; // 导入扫描器类用于输入

public class Main {
    // 从寄存器或立即数字符串中获取寄存器的索引
    private static int getIds(String dstSrc) {
        return Integer.parseInt(dstSrc.substring(1)); // 将字符串从第二个字符开始转换为整数
    }

    // 根据源字符串获取对应的值
    private static int getValueFromSrcStr(String src) {
        // 如果来源是寄存器（以字母'a'开头）
        if (src.charAt(0) == 'a') {
            return dst[getIds(src)]; // 返回对应寄存器的值
        }
        // 如果来源是立即数，直接转为整数返回
        return Integer.parseInt(src); // 将字符串转为整数
    }

    // 定义全局的寄存器数组，长度为32
    static int[] dst = new int[32];

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); // 创建扫描器对象用于输入
        Arrays.fill(dst, 0); // 将寄存器数组初始化为0

        // 循环读取输入直到结束
        while (scanner.hasNext()) {
            String op = scanner.next(); // 读取当前指令
            if (op.equals("MOV")) { // 如果是MOV指令
                String dstStr = scanner.next(); // 读取目标寄存器
                String src = scanner.next(); // 读取源值
                dst[getIds(dstStr)] = getValueFromSrcStr(src); // 将源值赋给目标寄存器
            } else if (op.equals("ADD")) { // 如果是ADD指令
                String dstStr = scanner.next(); // 读取目标寄存器
                String src0 = scanner.next(); // 读取第一个源值
                String src1 = scanner.next(); // 读取第二个源值
                // 执行加法操作并将结果存入目标寄存器
                dst[getIds(dstStr)] = getValueFromSrcStr(src0) + getValueFromSrcStr(src1);
            } else if (op.equals("SUB")) { // 如果是SUB指令
                String dstStr = scanner.next(); // 读取目标寄存器
                String src0 = scanner.next(); // 读取第一个源值
                String src1 = scanner.next(); // 读取第二个源值
                // 执行减法操作并将结果存入目标寄存器
                dst[getIds(dstStr)] = getValueFromSrcStr(src0) - getValueFromSrcStr(src1);
            } else if (op.equals("MUL")) { // 如果是MUL指令
                String dstStr = scanner.next(); // 读取目标寄存器
                String src0 = scanner.next(); // 读取第一个源值
                String src1 = scanner.next(); // 读取第二个源值
                // 执行乘法操作并将结果存入目标寄存器
                dst[getIds(dstStr)] = getValueFromSrcStr(src0) * getValueFromSrcStr(src1);
            } else if (op.equals("DIV")) { // 如果是DIV指令
                String dstStr = scanner.next(); // 读取目标寄存器
                String src0 = scanner.next(); // 读取第一个源值
                String src1 = scanner.next(); // 读取第二个源值
                // 执行除法操作，向下取整并将结果存入目标寄存器
                dst[getIds(dstStr)] = (int)Math.floor((double) getValueFromSrcStr(src0) / getValueFromSrcStr(src1));
            } else { // 如果是PRINT指令
                String dstStr = scanner.next(); // 读取目标寄存器
                System.out.println(dst[getIds(dstStr)]); // 输出寄存器的值
            }
        }
        scanner.close(); // 关闭扫描器
    }
}