110106 Interpreter

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <vector>

using namespace std;

#define BIT_CNT 3
#define REG_CNT 10
#define MEM_CNT 1000

#define ADD(x, y) (((x) + (y)) % 1000)
#define MULT(x, y) (((x) * (y)) % 1000)

typedef int Value_t;
typedef int Addr_t;

struct OP
{
    OP(Value_t* data) : opType(data[0]), data1(data[1]), data2(data[2])
    {
    }

    Value_t opType;
    Value_t data1, data2;
};

static Value_t GetVal(Value_t* regOrMem)
{
    return regOrMem[0] * 100 + regOrMem[1] * 10 + regOrMem[2];
}

static void SetVal(Value_t* regOrMem, Value_t value)
{
    regOrMem[2] = value % 10;
    value /= 10;
    regOrMem[1] = value % 10;
    regOrMem[0] = value / 10;
}

static Addr_t Execute(Addr_t addr, Value_t memory[][BIT_CNT], Value_t regs[][BIT_CNT])
{
    OP op(memory[addr]);

    switch (op.opType)
    {
    case 0: // 0ds, if s != 0, then jump to mem[d.value]
        if (GetVal(regs[op.data2]))
            return GetVal(regs[op.data1]);
        break;
    case 1: // 100 Halt
        return -1;
    case 2: // 2dn, d.value = n
        SetVal(regs[op.data1], op.data2);
        break;
    case 3: // 3dn, d.value += n
        SetVal(regs[op.data1], ADD(GetVal(regs[op.data1]), op.data2));
        break;
    case 4: // 4dn, d.value *= n
        SetVal(regs[op.data1], MULT(GetVal(regs[op.data1]), op.data2));
        break;
    case 5: // 5ds, d.value = s.value
        SetVal(regs[op.data1], GetVal(regs[op.data2]));
        break;
    case 6: // 6ds, d.value += s.value
        SetVal(regs[op.data1], ADD(GetVal(regs[op.data1]), GetVal(regs[op.data2])));
        break;
    case 7: // 7ds, d.value *= s.value
        SetVal(regs[op.data1], MULT(GetVal(regs[op.data1]), GetVal(regs[op.data2])));
        break;
    case 8: // 8da, d.value = mem[a.value]
        SetVal(regs[op.data1], GetVal(memory[GetVal(regs[op.data2])]));
        break;
    case 9: // 9sa, mem[a.value] = d.value
        SetVal(memory[GetVal(regs[op.data2])], GetVal(regs[op.data1]));
        break;
    default:
        break;
    }

    return ((addr + 1) % 1000);
}

static void ClearEnv(Value_t memory[][BIT_CNT], Value_t regs[][BIT_CNT])
{
    for(int i = 0; i < BIT_CNT; ++i)
    {
        for(int j = 0; j < REG_CNT; ++j)
            regs[j][i] = 0;
        for(int j = 0; j < MEM_CNT; ++j)
            memory[j][i] = 0;
    }
}

#define MAX_BUF 100
static void InputTestCaseData(Value_t memory[][BIT_CNT])
{
    static char buf[MAX_BUF];
    int i = 0;
    while(true)
    {
        if ((!fgets(buf, MAX_BUF, stdin)) || (strlen(buf) < 3))
            return;

        memory[i][0] = buf[0] - '0';
        memory[i][1] = buf[1] - '0';
        memory[i][2] = buf[2] - '0';

        i = (i + 1) % 1000;
    }
}

static int GetTestCaseCnt()
{
    static char newline[2];
    int cnt;
    cin >> cnt; 
    fgets(newline, 2, stdin); // Consume the '\n' right after the test case count.
    fgets(newline, 2, stdin); // Consume the empty line after the test case.
    return cnt;
}

static int Run(Value_t memory[][BIT_CNT], Value_t regs[][BIT_CNT])
{
    Addr_t addr = 0;
    int sum = 0;
    while(addr >= 0)
    {
        addr = Execute(addr, memory, regs);
        ++sum;
    }

    return sum;
}

static void DisplayResult(vector<int>& result)
{
    int cnt = result.size();
    for (int i = 0; i < cnt; ++i)
    {
        cout << result[i] << endl;
        if (i != (cnt - 1))
            cout << endl;
    }
}

static void DoJob(Value_t memory[][BIT_CNT], Value_t regs[][BIT_CNT], vector<int>& result)
{
    int cnt = GetTestCaseCnt();

    for (int i = 0; i < cnt; ++i)
    {
        ClearEnv(memory, regs);
        InputTestCaseData(memory);
        result.push_back(Run(memory, regs));
    }

    DisplayResult(result);
}

int main(int argc, char* argv[])
{
    Value_t regs[REG_CNT][BIT_CNT], memory[MEM_CNT][BIT_CNT];
    vector<int> result;
    DoJob(memory, regs, result);
    return 0;
}