ZOJ1072 Microprocessor Simulation

这道题我觉得加法这里比较难懂,和分成高字和低字,分别存放在寄存器AB中。

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> --> #include < iostream >
using namespace std;

const int MAXSIZE = 256 ; // 内存最多有个字
const int WORDWIDTH = 4 ; // 每个字位
int memory[MAXSIZE]; // 内存

// 9种指令
typedef enum
{
LD,
ST,
SWP,
ADD,
INC,
DEC,
BZ,
BR,
STP
};

int main( void )
{
char ch;
int i;
while ( true )
{
// 输入数据
memset(memory, 0 ,MAXSIZE); // 初始化内存
ch = getchar();
while ((ch < ' 0 ' || ch > ' 9 ' ) && (ch < ' A ' || ch > ' F ' ))
cin
>> ch;

if (ch == ' 8 ' )
break ;
// 输入内存数据
for (i = 1 ;i < MAXSIZE; ++ i)
{
cin
>> ch;
if (ch >= ' 0 ' && ch <= ' 9 ' )
{
memory[i]
= ch - ' 0 ' ;
}
else if (ch >= ' A ' && ch <= ' F ' )
{
memory[i]
= ch - ' A ' + 10 ;
}
}
int curOpt,accumA = 0 ,accumB = 0 ,high,low,pos,sum,pc = 0 ;
bool bFinished = false ;
while ( ! bFinished)
{
curOpt
= memory[pc ++ ]; // 当前指令
switch (curOpt)
{
case LD:
{
// 加载数据到寄存器A
high = memory[pc ++ ]; // 高字位
low = memory[pc ++ ]; // 低字位
pos = (high << WORDWIDTH) + low; // 实际位置
accumA = memory[pos];
}
break ;
case ST:
{
// 将寄存器A中数据存到内存
high = memory[pc ++ ]; // 高字位
low = memory[pc ++ ]; // 低字位
pos = (high << WORDWIDTH) + low; // 实际位置
memory[pos] = accumA;
}
break ;
case SWP:
{
// 交换两个数(这种方式避免内存溢出)
accumA = accumA ^ accumB;
accumB
= accumA ^ accumB;
accumA
= accumA ^ accumB;
}
break ;
case ADD:
{
// 寄存器A和寄存器B中数据相加,低字放在A中,高字放在B中
sum = (accumA + accumB) % 0x100 ;
accumA
= sum & 0x0f ;
accumB
= (sum & 0xf0 ) >> WORDWIDTH;
}
break ;
case INC:
{
// 寄存器A中数据自增

if ( ++ accumA == 16 )
{
accumA
= 0 ;
}
}
break ;
case DEC:
{
// 寄存器A中数据自减
if (accumA == 0 )
{
accumA
= 15 ;
}
else
-- accumA;
}
break ;
case BZ:
{
// 寄存器A中数据等于则跳转
high = memory[pc ++ ];
low
= memory[pc ++ ];
pos
= (high << WORDWIDTH) + low;
if (accumA == 0 )
pc
= pos; // 程序计数器指向指定跳转位置
}
break ;
case BR: // pc自增
pc = memory[pc + 1 ]; // 指向下一个位置
break ;
case STP: // 停止执行
bFinished = true ;
break ;
}
}
// 显示最终内存快照
for (i = 0 ;i < MAXSIZE; ++ i)
{
if (memory[i] < 10 )
{
cout
<< memory[i];
}
else
{
ch
= memory[i] - 10 + ' A ' ;
cout
<< ch;
}
}
cout
<< endl;
}
return 0 ;
}

Description 吴泽乐: Consider a small microprocessor that has the following properties: ?Each word is four bits. ?Addresses are two words. The high word always comes first. That is, the high word of a two-word address will always occupy the lower word of memory. ?Memory is 256 words. ?There are two accumulators, A and B, each storing one word. ?There are nine instruction codes. Each instruction requires at least one word to store the code that specifies the instruction. Four instructions have arguments and require an additional two words. Each 4 bit number can have the values from 0 to 15, inclusive, in base 10. We will write these using hexadecimal in the usual way, i.e. A means 10, B means 11, etc. These are the nine instructions: Code Words Description 0 3 LD: Load accumulator A with the contents of memory at the specified argument. 1 3 ST: Write the contents of accumulator A to the memory location specified by the argumen 2 1 SWP: Swap the contents of accumulators A and B. 3 1 ADD: Add the contents of accumulators A and B. The low word of the sum is stored in A, and the high word in B 4 1 INC: Increment accumulator A. Overflow is allowed; that is, incrementing F yields 0. 5 1 DEC: Decrement accumulator A. Underflow is allowed; that is, decrementing 0 yields F. 6 3 BZ: If accumulator A is zero, the next command to be executed is at the location specified by the argument. If A is not zero, the argument is ignored and nothing happens. 7 3 BR: The next command to be executed is at the location specified by the argument. 8 1 STP: Stop execution of the program. The microprocessor always begins by executing the command at location 00. It executes the commands in sequence until it reaches the Stop command. The examples below show partial programs and describe their affect. Program Description 01A8 Load accumulator A with the contents of memory location 1A (26 in decimal) and stop. 01A512F8 Load accumulator A with the contents of memory location 1A (26 in decimal), decrement it, store the result to memory location 2F, then stop. Input The input will consist of several lines of exactly 256 hex characters. Each line is the contents of memory, beginning with address 00 and ending with address FF. The end of the input is indicated by a memory state that has a stop instruction (an "8") at address 00. The input programs will never "fall of the end of memory" that is, you will never execute an instruction that is located between addresses F0 and FF, inclusive. Output For each memory state, you should simulate execution beginning with address 00. When the stop instruction is reached, you will dump the contents of memory to the output as a single string of 256 hex characters followed by a newline character. Sample Input 0102011311321128FF0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 Sample Output 0102011311321128FF1E00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值