1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
#include <iostream>
#include <string>
#include <algorithm>
#include <variant>
#include <vector>
#include <deque>
#include <memory>
using namespace std;
int part;
int p1 = 0;
int p2 = 0;
struct cpu;
struct insn {
virtual void run(cpu &) = 0;
virtual bool stalled(cpu &) { return false; }
};
struct cpu {
int64_t reg[256];
const vector<unique_ptr<insn>> &insns;
vector<unique_ptr<insn>>::const_iterator ip;
deque<uint64_t> &sndq, &rcvq;
int id;
cpu(const vector<unique_ptr<insn>> &insns,
deque<uint64_t> &sq, deque<uint64_t> &rq, int id=0) :
reg{0}, insns{insns}, ip{cbegin(insns)}, sndq{sq}, rcvq{rq},
id{id}
{
reg[(uint8_t)'p'] = id;
}
void step() { (*ip++)->run(*this); }
bool done() { return ip == cend(insns); }
bool stalled() { return (*ip)->stalled(*this); }
};
struct arg {
virtual long operator()(cpu &) = 0;
};
struct const_arg : arg {
long l;
const_arg(long l) : l{l} {}
long operator()(cpu &) { return l; }
};
struct reg_arg : arg {
uint8_t r;
reg_arg(uint8_t r) : r{r} {}
long operator()(cpu &c) { return c.reg[r]; }
};
unique_ptr<arg>
parse(string s) {
if (islower(s[0]))
return make_unique<reg_arg>(uint8_t(s[0]));
else
return make_unique<const_arg>(stol(s));
}
struct binop : public insn {
public:
uint8_t r;
unique_ptr<arg> a;
binop(string &s) : r(s[4]), a{parse(&s[6])} {};
};
struct opset : public binop { using binop::binop;
void run(cpu &c) { c.reg[r] = (*a)(c); }
};
struct opadd : public binop { using binop::binop;
void run(cpu &c) { c.reg[r] += (*a)(c); }
};
struct opmul : public binop { using binop::binop;
void run(cpu &c) { c.reg[r] *= (*a)(c); }
};
struct opmod : public binop { using binop::binop;
void run(cpu &c) { c.reg[r] %= (*a)(c); }
};
struct opjgz : public insn {
unique_ptr<arg> a1, a2;
opjgz(string &s) : a1{parse(&s[4])}, a2{parse(&s[6])} {}
void run(cpu &c) { if ((*a1)(c) > 0) advance(c.ip, (*a2)(c) - 1); }
};
struct opsnd : public insn {
unique_ptr<arg> a;
opsnd(string &s) : a{parse(&s[4])} {}
void run(cpu &c) {
if (part == 1) {
p1 = (*a)(c);
} else {
if (c.id == 1)
p2++;
c.sndq.push_back((*a)(c));
}
}
};
struct oprcv : public insn {
uint8_t r;
oprcv(string &s) : r(s[4]) {}
void run(cpu &c) {
if (part == 2) {
if (empty(c.rcvq)) {
--c.ip;
} else {
c.reg[r] = c.rcvq.front();
c.rcvq.pop_front();
}
}
}
bool stalled(cpu &c) { return part == 1 ? c.reg[r] > 0 : empty(c.rcvq); }
};
int
main() {
string line;
vector<unique_ptr<insn>> code;
while (getline(cin, line)) {
auto is_op = [&](string p){
return equal(begin(p), end(p), begin(line));
};
insn* op;
if (is_op("set")) op = new opset{line};
else if (is_op("add")) op = new opadd{line};
else if (is_op("mul")) op = new opmul{line};
else if (is_op("mod")) op = new opmod{line};
else if (is_op("jgz")) op = new opjgz{line};
else if (is_op("snd")) op = new opsnd{line};
else if (is_op("rcv")) op = new oprcv{line};
code.emplace_back(op);
}
part = 1;
deque<uint64_t> _;
for (cpu c{code, _, _}; !c.done() && !c.stalled(); c.step())
;
part = 2;
deque<uint64_t> q01, q10;
for (cpu c0{code, q01, q10, 0},
c1{code, q10, q01, 1};
!c0.done() && !c1.done() && !(c0.stalled() && c1.stalled());
c0.step(), c1.step())
;
cout << p1 << endl << p2 << endl; // 3423 7493
}
|
