152 lines
4.4 KiB
Zig
152 lines
4.4 KiB
Zig
const std = @import("std");
|
|
|
|
const CharDev = std.ArrayList(i32);
|
|
const CharDevLimit = 32;
|
|
|
|
pub fn loadFromStream(alloc: *std.mem.Allocator, stream: *std.fs.File.InStream.Stream) anyerror![]i32 {
|
|
var program = try alloc.alloc(i32, 1024);
|
|
|
|
var buf = [_]u8{0} ** 255;
|
|
var i: u32 = 0;
|
|
|
|
while (try stream.readUntilDelimiterOrEof(&buf, ',')) |num| {
|
|
var trimmed = std.mem.trimRight(u8, num, "\r\n");
|
|
program[i] = try std.fmt.parseInt(i32, trimmed, 10);
|
|
|
|
std.debug.warn("{},", program[i]);
|
|
|
|
i += 1;
|
|
}
|
|
|
|
std.debug.warn("\n");
|
|
|
|
return program[0..program.len];
|
|
}
|
|
|
|
pub fn loadFromStdIn(alloc: *std.mem.Allocator) anyerror![]i32 {
|
|
const file = std.io.getStdIn();
|
|
const stream = &file.inStream().stream;
|
|
|
|
return loadFromStream(alloc, stream);
|
|
}
|
|
|
|
pub const Machine = struct {
|
|
memory: []i32,
|
|
|
|
ip: usize = 0,
|
|
|
|
input: CharDev,
|
|
output: CharDev,
|
|
|
|
pub fn Run(alloc: *std.mem.Allocator, program: []i32) anyerror!Machine {
|
|
var machine = try init(alloc, program);
|
|
|
|
try machine.run();
|
|
|
|
return machine;
|
|
}
|
|
|
|
pub fn init(alloc: *std.mem.Allocator, program: []i32) anyerror!Machine {
|
|
return Machine{
|
|
.memory = program,
|
|
.input = try CharDev.initCapacity(alloc, CharDevLimit),
|
|
.output = try CharDev.initCapacity(alloc, CharDevLimit),
|
|
};
|
|
}
|
|
|
|
pub fn run(self: *Machine) anyerror!void {
|
|
while (try self.step()) {}
|
|
}
|
|
|
|
pub fn step(self: *Machine) anyerror!bool {
|
|
var program = self.memory;
|
|
|
|
const opcode = switch (program[self.ip]) {
|
|
1 => {
|
|
var a = program[@intCast(usize, program[self.ip + 1])];
|
|
var b = program[@intCast(usize, program[self.ip + 2])];
|
|
var dest = program[self.ip + 3];
|
|
var result = a + b;
|
|
|
|
program[@intCast(usize, dest)] = result;
|
|
self.ip += 4;
|
|
},
|
|
2 => {
|
|
var a = program[@intCast(usize, program[self.ip + 1])];
|
|
var b = program[@intCast(usize, program[self.ip + 2])];
|
|
var dest = program[self.ip + 3];
|
|
var result = a * b;
|
|
|
|
program[@intCast(usize, dest)] = result;
|
|
self.ip += 4;
|
|
},
|
|
99 => {
|
|
self.ip += 1;
|
|
return false;
|
|
},
|
|
else => {
|
|
std.debug.warn("Unknown opcode at IP {}: {}\n", self.ip, program[self.ip]);
|
|
return false;
|
|
},
|
|
};
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
const assert = std.debug.assert;
|
|
const test_allocator = std.heap.page_allocator;
|
|
|
|
test "day 2 example 1" {
|
|
var before: [12]i32 = .{ 1, 9, 10, 3, 2, 3, 11, 0, 99, 30, 40, 50 };
|
|
var after: [12]i32 = .{ 3500, 9, 10, 70, 2, 3, 11, 0, 99, 30, 40, 50 };
|
|
var machine = try Machine.Run(test_allocator, before[0..before.len]);
|
|
|
|
assert(std.mem.eql(i32, before[0..before.len], after[0..after.len]));
|
|
}
|
|
|
|
test "day 2 example 2" {
|
|
var before: [5]i32 = .{ 1, 0, 0, 0, 99 };
|
|
var after: [5]i32 = .{ 2, 0, 0, 0, 99 };
|
|
var machine = try Machine.Run(test_allocator, before[0..before.len]);
|
|
|
|
assert(std.mem.eql(i32, before[0..before.len], after[0..after.len]));
|
|
}
|
|
|
|
test "day 2 example 3" {
|
|
var before: [5]i32 = .{ 2, 3, 0, 3, 99 };
|
|
var after: [5]i32 = .{ 2, 3, 0, 6, 99 };
|
|
var machine = try Machine.Run(test_allocator, before[0..before.len]);
|
|
|
|
assert(std.mem.eql(i32, before[0..before.len], after[0..after.len]));
|
|
}
|
|
|
|
test "day 2 example 4" {
|
|
var before: [6]i32 = .{ 2, 4, 4, 5, 99, 0 };
|
|
var after: [6]i32 = .{ 2, 4, 4, 5, 99, 9801 };
|
|
var machine = try Machine.Run(test_allocator, before[0..before.len]);
|
|
|
|
assert(std.mem.eql(i32, before[0..before.len], after[0..after.len]));
|
|
}
|
|
|
|
test "day 2 example 5" {
|
|
var before: [9]i32 = .{ 1, 1, 1, 4, 99, 5, 6, 0, 99 };
|
|
var after: [9]i32 = .{ 30, 1, 1, 4, 2, 5, 6, 0, 99 };
|
|
var machine = try Machine.Run(test_allocator, before[0..before.len]);
|
|
|
|
assert(std.mem.eql(i32, before[0..before.len], after[0..after.len]));
|
|
}
|
|
|
|
test "day 5 example 1" {
|
|
var before: [5]i32 = .{ 3, 0, 4, 0, 99 };
|
|
var after = before;
|
|
var machine = try Machine.init(test_allocator, before[0..before.len]);
|
|
|
|
try machine.input.append(666);
|
|
try machine.run();
|
|
|
|
assert(std.mem.eql(i32, before[0..before.len], after[0..after.len]));
|
|
assert(machine.output.len == 1);
|
|
assert(machine.output.at(0) == 666);
|
|
}
|