UVa Problem 10033 Interpreter （解释器）

[cpp] view plain copy print ?

1. // Interpreter （解释器）   
2. // PC/UVa IDs: 110106/10033, Popularity: B, Success rate: low Level: 2   
3. // Verdict: Accepted   
4. // Submission Date: 2011-04-09   
5. // UVa Run Time: 0.008s   
6. //   
7. // 版权所有（C）2011，邱秋。metaphysis # yeah dot net   
8. //   
9. // 根据题意模拟即可。   
10.       
11. #include <iostream>   
12. #include <cstdlib>   
13. #include <cstring>   
14.       
15. using namespace std;  
16.       
17. int execute(int *reg, int *mem)  
18. {  
19.     int pointer = 0, step = 0, code = mem[0], a, b, c;  
20.     while (code != 100 && pointer < 1000)  
21.     {  
22.         code = mem[pointer];  
23.         a = code / 100;     // 操作类型。   
24.         b = (code / 10) % 10;   // 寄存器。   
25.         c = code % 10;      // 操作数或地址或寄存器。   
26.       
27.         switch (a)  
28.         {  
29.             // 如果寄存器c中的地址不为0，则跳转到寄存器b所指向的指令。   
30.             case 0:  
31.                 if (reg[c] != 0)  
32.                     pointer = reg[b] - 1;  
33.                 break;  
34.             // 100结束。   
35.             case 1:  
36.                 if (!b && !c)  
37.                     return (1 + step);  
38.             // 将寄存器b的值设置为c。   
39.             case 2:  
40.                 reg[b] = c;  
41.                 break;  
42.             // 将寄存器b的值增加c。   
43.             case 3:  
44.                 reg[b] += c;  
45.                 break;  
46.             // 将寄存器b的值自乘c。   
47.             case 4:  
48.                 reg[b] *= c;  
49.                 break;  
50.             // 将寄存器b的值设置为寄存器c的值。   
51.             case 5:  
52.                 reg[b] = reg[c];  
53.                 break;  
54.             // 将寄存器c的值加上寄存器b的值然后放到寄存器b中。   
55.             case 6:  
56.                 reg[b] += reg[c];  
57.                 break;  
58.             // 将寄存器b的值乘以寄存器c的值然后放到寄存器b中   
59.             case 7:  
60.                 reg[b] *= reg[c];  
61.                 break;  
62.             // 将寄存器b的值设置为寄存器c的值所指向的地址存储的值。   
63.             case 8:  
64.                 reg[b] = mem[reg[c]];  
65.                 break;  
66.             // 将地址为寄存器c的值的内容设置为寄存器b内所存储的值。   
67.             case 9:  
68.                 mem[reg[c]] = reg[b];  
69.                 break;  
70.         }  
71.           
72.         // 所有结果均取1000的模。执行步骤和当前指令均自增1。   
73.         reg[b] %= 1000;  
74.         step++;  
75.         pointer++;  
76.     }  
77. }  
78.   
79. int main(int argc, char *argv[])  
80. {  
81.     int reg[10], mem[1000], cases = 0, i = 0, j = 0;  
82.     string line;  
83.       
84.     // 读入测试用例数。   
85.     cin >> cases;  
86.     cin.ignore();  
87.     getline(cin, line);  
88.       
89.     while (cases--)  
90.     {  
91.         // 重置存储内容。   
92.         memset(mem, 0, sizeof(mem));  
93.         memset(reg, 0, sizeof(reg));  
94.           
95.         // 读入代码。   
96.         for (int i = 0; getline(cin, line) && line.length(); i++)  
97.             mem[i] = atoi(line.data());  
98.       
99.         // 模拟执行过程。   
100.         cout << execute(reg, mem) << endl;  
101.   
102.         if (cases)  
103.             cout << endl;  
104.   
105.     }  
106.       
107.     return 0;  
108. }  

// Interpreter （解释器）
// PC/UVa IDs: 110106/10033, Popularity: B, Success rate: low Level: 2
// Verdict: Accepted
// Submission Date: 2011-04-09
// UVa Run Time: 0.008s
//
// 版权所有（C）2011，邱秋。metaphysis # yeah dot net
//
// 根据题意模拟即可。
	
#include <iostream>
#include <cstdlib>
#include <cstring>
	
using namespace std;
	
int execute(int *reg, int *mem)
{
	int pointer = 0, step = 0, code = mem[0], a, b, c;
	while (code != 100 && pointer < 1000)
	{
		code = mem[pointer];
		a = code / 100;		// 操作类型。
		b = (code / 10) % 10;	// 寄存器。
		c = code % 10;		// 操作数或地址或寄存器。
	
		switch (a)
		{
			// 如果寄存器c中的地址不为0，则跳转到寄存器b所指向的指令。
			case 0:
				if (reg[c] != 0)
					pointer = reg[b] - 1;
				break;
			// 100结束。
			case 1:
				if (!b && !c)
					return (1 + step);
			// 将寄存器b的值设置为c。
			case 2:
				reg[b] = c;
				break;
			// 将寄存器b的值增加c。
			case 3:
				reg[b] += c;
				break;
			// 将寄存器b的值自乘c。
			case 4:
				reg[b] *= c;
				break;
			// 将寄存器b的值设置为寄存器c的值。
			case 5:
				reg[b] = reg[c];
				break;
			// 将寄存器c的值加上寄存器b的值然后放到寄存器b中。
			case 6:
				reg[b] += reg[c];
				break;
			// 将寄存器b的值乘以寄存器c的值然后放到寄存器b中
			case 7:
				reg[b] *= reg[c];
				break;
			// 将寄存器b的值设置为寄存器c的值所指向的地址存储的值。
			case 8:
				reg[b] = mem[reg[c]];
				break;
			// 将地址为寄存器c的值的内容设置为寄存器b内所存储的值。
			case 9:
				mem[reg[c]] = reg[b];
				break;
		}
		
		// 所有结果均取1000的模。执行步骤和当前指令均自增1。
		reg[b] %= 1000;
		step++;
		pointer++;
	}
}

int main(int argc, char *argv[])
{
	int reg[10], mem[1000], cases = 0, i = 0, j = 0;
	string line;
	
	// 读入测试用例数。
	cin >> cases;
	cin.ignore();
	getline(cin, line);
	
	while (cases--)
	{
		// 重置存储内容。
		memset(mem, 0, sizeof(mem));
		memset(reg, 0, sizeof(reg));
		
		// 读入代码。
		for (int i = 0; getline(cin, line) && line.length(); i++)
			mem[i] = atoi(line.data());
	
		// 模拟执行过程。
		cout << execute(reg, mem) << endl;

		if (cases)
			cout << endl;

	}
	
	return 0;
}