Finish day 17
This commit is contained in:
parent
dcc4dfce6a
commit
b28fd56a8a
|
|
@ -0,0 +1,27 @@
|
||||||
|
const Builder = @import("std").build.Builder;
|
||||||
|
|
||||||
|
pub fn build(b: *Builder) void {
|
||||||
|
// Standard target options allows the person running `zig build` to choose
|
||||||
|
// what target to build for. Here we do not override the defaults, which
|
||||||
|
// means any target is allowed, and the default is native. Other options
|
||||||
|
// for restricting supported target set are available.
|
||||||
|
const target = b.standardTargetOptions(.{});
|
||||||
|
|
||||||
|
// Standard release options allow the person running `zig build` to select
|
||||||
|
// between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
|
||||||
|
const mode = b.standardReleaseOptions();
|
||||||
|
|
||||||
|
const exe = b.addExecutable("day17", "src/main.zig");
|
||||||
|
exe.setTarget(target);
|
||||||
|
exe.setBuildMode(mode);
|
||||||
|
exe.install();
|
||||||
|
|
||||||
|
const run_cmd = exe.run();
|
||||||
|
run_cmd.step.dependOn(b.getInstallStep());
|
||||||
|
if (b.args) |args| {
|
||||||
|
run_cmd.addArgs(args);
|
||||||
|
}
|
||||||
|
|
||||||
|
const run_step = b.step("run", "Run the app");
|
||||||
|
run_step.dependOn(&run_cmd.step);
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,8 @@
|
||||||
|
####...#
|
||||||
|
......#.
|
||||||
|
#..#.##.
|
||||||
|
.#...#.#
|
||||||
|
..###.#.
|
||||||
|
##.###..
|
||||||
|
.#...###
|
||||||
|
.##....#
|
||||||
|
|
@ -0,0 +1,633 @@
|
||||||
|
const std = @import("std");
|
||||||
|
|
||||||
|
pub fn main() anyerror!void {
|
||||||
|
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
|
||||||
|
defer arena.deinit();
|
||||||
|
var gpa = &arena.allocator;
|
||||||
|
|
||||||
|
var f = try std.fs.cwd().openFile("input", .{});
|
||||||
|
var contents = try f.readToEndAlloc(gpa, std.math.maxInt(u64));
|
||||||
|
defer gpa.free(contents);
|
||||||
|
|
||||||
|
var sim = try Simulation.init(gpa);
|
||||||
|
defer sim.deinit();
|
||||||
|
|
||||||
|
var sim4d = try Simulation4D.init(gpa);
|
||||||
|
defer sim4d.deinit();
|
||||||
|
|
||||||
|
var it = std.mem.tokenize(contents, "\n");
|
||||||
|
var y : i64 = 0;
|
||||||
|
while (it.next()) |line| {
|
||||||
|
for (line) |c, k| {
|
||||||
|
var state : CubeState = .inactive;
|
||||||
|
if (c == '#') {
|
||||||
|
state = .active;
|
||||||
|
}
|
||||||
|
try sim.add_cube([_]i64 {@intCast(i64, k), y, 0}, state);
|
||||||
|
try sim4d.add_cube([_]i64 {@intCast(i64, k), y, 0, 0}, state);
|
||||||
|
}
|
||||||
|
y += 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Run 6 rounds
|
||||||
|
try sim.do_round(); // 1
|
||||||
|
try sim.do_round(); // 2
|
||||||
|
try sim.do_round(); // 3
|
||||||
|
try sim.do_round(); // 4
|
||||||
|
try sim.do_round(); // 5
|
||||||
|
try sim.do_round(); // 6
|
||||||
|
|
||||||
|
std.log.info("After 6 rounds, there are {} active cubes",
|
||||||
|
.{sim.count_active_cubes()});
|
||||||
|
|
||||||
|
// Part 2
|
||||||
|
try sim4d.do_round(); // 1
|
||||||
|
try sim4d.do_round(); // 2
|
||||||
|
try sim4d.do_round(); // 3
|
||||||
|
try sim4d.do_round(); // 4
|
||||||
|
try sim4d.do_round(); // 5
|
||||||
|
try sim4d.do_round(); // 6
|
||||||
|
|
||||||
|
std.log.info("After 6 rounds, there are {} active cubes",
|
||||||
|
.{sim4d.count_active_cubes()});
|
||||||
|
}
|
||||||
|
|
||||||
|
const CubeState = enum {
|
||||||
|
inactive,
|
||||||
|
active
|
||||||
|
};
|
||||||
|
|
||||||
|
const Cube = struct {
|
||||||
|
pos: [3]i64,
|
||||||
|
state: CubeState = .inactive,
|
||||||
|
next_state: ?CubeState = null,
|
||||||
|
neighbours: u64 = 0,
|
||||||
|
|
||||||
|
pub fn get_neighbour_positions(self: *Cube) [26][3]i64 {
|
||||||
|
return [_][3]i64 {
|
||||||
|
// z-1
|
||||||
|
[_]i64 {self.pos[0], self.pos[1], self.pos[2]-1},
|
||||||
|
[_]i64 {self.pos[0], self.pos[1]+1, self.pos[2]-1},
|
||||||
|
[_]i64 {self.pos[0], self.pos[1]-1, self.pos[2]-1},
|
||||||
|
[_]i64 {self.pos[0]-1, self.pos[1], self.pos[2]-1},
|
||||||
|
[_]i64 {self.pos[0]-1, self.pos[1]+1, self.pos[2]-1},
|
||||||
|
[_]i64 {self.pos[0]-1, self.pos[1]-1, self.pos[2]-1},
|
||||||
|
[_]i64 {self.pos[0]+1, self.pos[1], self.pos[2]-1},
|
||||||
|
[_]i64 {self.pos[0]+1, self.pos[1]+1, self.pos[2]-1},
|
||||||
|
[_]i64 {self.pos[0]+1, self.pos[1]-1, self.pos[2]-1},
|
||||||
|
// z+0
|
||||||
|
[_]i64 {self.pos[0], self.pos[1]+1, self.pos[2]},
|
||||||
|
[_]i64 {self.pos[0], self.pos[1]-1, self.pos[2]},
|
||||||
|
[_]i64 {self.pos[0]-1, self.pos[1], self.pos[2]},
|
||||||
|
[_]i64 {self.pos[0]-1, self.pos[1]+1, self.pos[2]},
|
||||||
|
[_]i64 {self.pos[0]-1, self.pos[1]-1, self.pos[2]},
|
||||||
|
[_]i64 {self.pos[0]+1, self.pos[1], self.pos[2]},
|
||||||
|
[_]i64 {self.pos[0]+1, self.pos[1]+1, self.pos[2]},
|
||||||
|
[_]i64 {self.pos[0]+1, self.pos[1]-1, self.pos[2]},
|
||||||
|
// z+1
|
||||||
|
[_]i64 {self.pos[0], self.pos[1], self.pos[2]+1},
|
||||||
|
[_]i64 {self.pos[0], self.pos[1]+1, self.pos[2]+1},
|
||||||
|
[_]i64 {self.pos[0], self.pos[1]-1, self.pos[2]+1},
|
||||||
|
[_]i64 {self.pos[0]-1, self.pos[1], self.pos[2]+1},
|
||||||
|
[_]i64 {self.pos[0]-1, self.pos[1]+1, self.pos[2]+1},
|
||||||
|
[_]i64 {self.pos[0]-1, self.pos[1]-1, self.pos[2]+1},
|
||||||
|
[_]i64 {self.pos[0]+1, self.pos[1], self.pos[2]+1},
|
||||||
|
[_]i64 {self.pos[0]+1, self.pos[1]+1, self.pos[2]+1},
|
||||||
|
[_]i64 {self.pos[0]+1, self.pos[1]-1, self.pos[2]+1},
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn print_state(self: *Cube) !void {
|
||||||
|
var stdout = std.io.getStdOut().writer();
|
||||||
|
var c : u8 = '.';
|
||||||
|
if (self.state == .active) {
|
||||||
|
c = '#';
|
||||||
|
}
|
||||||
|
try stdout.print("({}x, {}y, {}z) {c}\n", .{self.pos[0], self.pos[1], self.pos[2], c});
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
const Simulation = struct {
|
||||||
|
map: std.hash_map.AutoHashMap([3]i64, Cube),
|
||||||
|
allocator: *std.mem.Allocator,
|
||||||
|
|
||||||
|
pub fn init(allocator: *std.mem.Allocator) !*Simulation {
|
||||||
|
var self = try allocator.create(Simulation);
|
||||||
|
errdefer allocator.destroy(self);
|
||||||
|
|
||||||
|
self.* = Simulation {
|
||||||
|
.map = std.hash_map.AutoHashMap([3]i64, Cube).init(allocator),
|
||||||
|
.allocator = allocator,
|
||||||
|
};
|
||||||
|
return self;
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn deinit(self: *Simulation) void {
|
||||||
|
self.map.deinit();
|
||||||
|
self.allocator.destroy(self);
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn add_cube(self: *Simulation, pos: [3]i64, state: CubeState) !void {
|
||||||
|
try self.map.put(pos, Cube {.pos = pos, .state = state});
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn print_state(self: *Simulation) !void {
|
||||||
|
// @TODO Organize the output somehow
|
||||||
|
var stdout = std.io.getStdOut().writer();
|
||||||
|
var z_min : i64 = std.math.maxInt(i64);
|
||||||
|
var z_max : i64 = std.math.minInt(i64);
|
||||||
|
var y_min : i64 = std.math.maxInt(i64);
|
||||||
|
var y_max : i64 = std.math.minInt(i64);
|
||||||
|
var x_min : i64 = std.math.maxInt(i64);
|
||||||
|
var x_max : i64 = std.math.minInt(i64);
|
||||||
|
|
||||||
|
var it = self.map.iterator();
|
||||||
|
while (it.next()) |entry| {
|
||||||
|
//try entry.value.print_state();
|
||||||
|
x_max = std.math.max(x_max, entry.value.pos[0]);
|
||||||
|
x_min = std.math.min(x_min, entry.value.pos[0]);
|
||||||
|
y_max = std.math.max(y_max, entry.value.pos[1]);
|
||||||
|
y_min = std.math.min(y_min, entry.value.pos[1]);
|
||||||
|
z_max = std.math.max(z_max, entry.value.pos[2]);
|
||||||
|
z_min = std.math.min(z_min, entry.value.pos[2]);
|
||||||
|
}
|
||||||
|
|
||||||
|
// For from lowest to highest then
|
||||||
|
var z_pos = z_min;
|
||||||
|
while (z_pos <= z_max) : (z_pos += 1) {
|
||||||
|
try stdout.print("z={} x=[{}..{}],y=[{}..{}]\n", .{z_pos, x_min, x_max, y_min, y_max});
|
||||||
|
var y_pos = y_min;
|
||||||
|
while (y_pos <= y_max) : (y_pos += 1) {
|
||||||
|
var x_pos = x_min;
|
||||||
|
while (x_pos <= x_max) : (x_pos += 1) {
|
||||||
|
//try stdout.print("({}, {}, {})\n", .{x_pos, y_pos, z_pos});
|
||||||
|
var c : u8 = '.';
|
||||||
|
if (self.map.get([_]i64{x_pos, y_pos, z_pos})) |cube| {
|
||||||
|
if (cube.state == .active) {
|
||||||
|
c = '#';
|
||||||
|
}
|
||||||
|
}
|
||||||
|
try stdout.print("{c}", .{c});
|
||||||
|
}
|
||||||
|
_ = try stdout.write("\n");
|
||||||
|
}
|
||||||
|
_ = try stdout.write("\n");
|
||||||
|
}
|
||||||
|
_ = try stdout.write("\n");
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn print_state_neighbour_count (self: *Simulation) !void {
|
||||||
|
// @TODO Organize the output somehow
|
||||||
|
var stdout = std.io.getStdOut().writer();
|
||||||
|
var z_min : i64 = std.math.maxInt(i64);
|
||||||
|
var z_max : i64 = std.math.minInt(i64);
|
||||||
|
var y_min : i64 = std.math.maxInt(i64);
|
||||||
|
var y_max : i64 = std.math.minInt(i64);
|
||||||
|
var x_min : i64 = std.math.maxInt(i64);
|
||||||
|
var x_max : i64 = std.math.minInt(i64);
|
||||||
|
|
||||||
|
var it = self.map.iterator();
|
||||||
|
while (it.next()) |entry| {
|
||||||
|
//try entry.value.print_state();
|
||||||
|
x_max = std.math.max(x_max, entry.value.pos[0]);
|
||||||
|
x_min = std.math.min(x_min, entry.value.pos[0]);
|
||||||
|
y_max = std.math.max(y_max, entry.value.pos[1]);
|
||||||
|
y_min = std.math.min(y_min, entry.value.pos[1]);
|
||||||
|
z_max = std.math.max(z_max, entry.value.pos[2]);
|
||||||
|
z_min = std.math.min(z_min, entry.value.pos[2]);
|
||||||
|
}
|
||||||
|
|
||||||
|
// For from lowest to highest then
|
||||||
|
var z_pos = z_min;
|
||||||
|
while (z_pos <= z_max) : (z_pos += 1) {
|
||||||
|
try stdout.print("z={} x=[{}..{}],y=[{}..{}]\n", .{z_pos, x_min, x_max, y_min, y_max});
|
||||||
|
var y_pos = y_min;
|
||||||
|
while (y_pos <= y_max) : (y_pos += 1) {
|
||||||
|
var x_pos = x_min;
|
||||||
|
while (x_pos <= x_max) : (x_pos += 1) {
|
||||||
|
//try stdout.print("({}, {}, {})\n", .{x_pos, y_pos, z_pos});
|
||||||
|
var c : u64 = 0;
|
||||||
|
if (self.map.get([_]i64{x_pos, y_pos, z_pos})) |cube| {
|
||||||
|
c = cube.neighbours;
|
||||||
|
}
|
||||||
|
try stdout.print("{:02}", .{c});
|
||||||
|
}
|
||||||
|
_ = try stdout.write("\n");
|
||||||
|
}
|
||||||
|
_ = try stdout.write("\n");
|
||||||
|
}
|
||||||
|
_ = try stdout.write("\n");
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn do_round(self: *Simulation) !void {
|
||||||
|
// For each cube, check all of it's neighbours
|
||||||
|
var it = self.map.iterator();
|
||||||
|
var neighbours_to_add = std.ArrayList([3]i64).init(self.allocator);
|
||||||
|
defer neighbours_to_add.deinit();
|
||||||
|
|
||||||
|
// Get the neighbours we need possibly create for this round
|
||||||
|
while (it.next()) |entry| {
|
||||||
|
var neighbours = entry.value.get_neighbour_positions();
|
||||||
|
var n_active : u64 = 0;
|
||||||
|
for (neighbours) |n_pos| {
|
||||||
|
if (self.map.get(n_pos)) |n| {
|
||||||
|
// Noop, we already have a cube
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
// The neighbour doesn't yet exist, we should create it
|
||||||
|
// but we don't want to do that while iterating over
|
||||||
|
// the current entries.
|
||||||
|
// We also want to make sure that we're not adding a
|
||||||
|
// value that's already in the list to be added.
|
||||||
|
// For the moment, we'll check that when iterating
|
||||||
|
// over neighbours_to_add.
|
||||||
|
try neighbours_to_add.append(n_pos);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// Add any new neighbours
|
||||||
|
for (neighbours_to_add.items) |new_pos| {
|
||||||
|
// Double-check we don't already have this neighbour
|
||||||
|
if (self.map.get(new_pos)) |v| {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
try self.map.putNoClobber(new_pos, Cube {.pos = new_pos, .state = .inactive});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
self.calculate_neighbour_states();
|
||||||
|
try self.print_state_neighbour_count();
|
||||||
|
|
||||||
|
// Now next state should be set, we go through again to swap
|
||||||
|
// @TODO Update state
|
||||||
|
it = self.map.iterator();
|
||||||
|
while (it.next()) |entry| {
|
||||||
|
if (entry.value.state == .active) {
|
||||||
|
if (entry.value.neighbours >= 2 and entry.value.neighbours <= 3) {
|
||||||
|
entry.value.state = .active;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
entry.value.state = .inactive;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
if (entry.value.neighbours == 3) {
|
||||||
|
entry.value.state = .active;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
entry.value.next_state = null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn calculate_neighbour_states(self: *Simulation) void {
|
||||||
|
var it = self.map.iterator();
|
||||||
|
while (it.next()) |entry| {
|
||||||
|
var neighbours = entry.value.get_neighbour_positions();
|
||||||
|
var n_active : u64 = 0;
|
||||||
|
std.log.warn("Checking neighbours for ({}, {}, {})",
|
||||||
|
.{entry.value.pos[0], entry.value.pos[1], entry.value.pos[2]});
|
||||||
|
for (neighbours) |n_pos| {
|
||||||
|
if (self.map.get(n_pos)) |n| {
|
||||||
|
if (n.state == .active) {
|
||||||
|
std.log.warn("Neighbour at ({}, {}, {}) is active",
|
||||||
|
.{n.pos[0], n.pos[1], n.pos[2]});
|
||||||
|
n_active += 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
// Noop, another function creates our neighbours, and it should
|
||||||
|
// be run before this one.
|
||||||
|
}
|
||||||
|
}
|
||||||
|
entry.value.neighbours = n_active;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn count_active_cubes(self: *Simulation) u64 {
|
||||||
|
var it = self.map.iterator();
|
||||||
|
var count : u64 = 0;
|
||||||
|
while (it.next()) |entry| {
|
||||||
|
if (entry.value.state == .active) {
|
||||||
|
count += 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return count;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
// Part 2, is just more tedious
|
||||||
|
const Cube4D = struct {
|
||||||
|
pos: [4]i64,
|
||||||
|
state: CubeState = .inactive,
|
||||||
|
neighbours: u64 = 0,
|
||||||
|
|
||||||
|
pub fn get_neighbour_positions(self: *Cube4D, a: *std.mem.Allocator) [80][4]i64 {
|
||||||
|
var neighbours : [80][4]i64 = undefined;
|
||||||
|
var x = self.pos[0]-1;
|
||||||
|
var idx : usize = 0;
|
||||||
|
while (x <= self.pos[0]+1) : (x += 1) {
|
||||||
|
var y = self.pos[1]-1;
|
||||||
|
while (y <= self.pos[1]+1) : (y +=1) {
|
||||||
|
var z = self.pos[2]-1;
|
||||||
|
while (z <= self.pos[2]+1) : (z +=1) {
|
||||||
|
var w = self.pos[3]-1;
|
||||||
|
while (w <= self.pos[3]+1) : (w+=1) {
|
||||||
|
if (x == self.pos[0] and y == self.pos[1] and z == self.pos[2]
|
||||||
|
and w == self.pos[3]) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
neighbours[idx] = [_]i64{x, y, z, w};
|
||||||
|
idx += 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return neighbours;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
const Simulation4D = struct {
|
||||||
|
map: std.hash_map.AutoHashMap([4]i64, Cube4D),
|
||||||
|
allocator: *std.mem.Allocator,
|
||||||
|
|
||||||
|
pub fn init(allocator: *std.mem.Allocator) !*Simulation4D {
|
||||||
|
var self = try allocator.create(Simulation4D);
|
||||||
|
errdefer allocator.destroy(self);
|
||||||
|
|
||||||
|
self.* = Simulation4D {
|
||||||
|
.map = std.hash_map.AutoHashMap([4]i64, Cube4D).init(allocator),
|
||||||
|
.allocator = allocator,
|
||||||
|
};
|
||||||
|
return self;
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn deinit(self: *Simulation4D) void {
|
||||||
|
self.map.deinit();
|
||||||
|
self.allocator.destroy(self);
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn add_cube(self: *Simulation4D, pos: [4]i64, state: CubeState) !void {
|
||||||
|
try self.map.put(pos, Cube4D {.pos = pos, .state = state});
|
||||||
|
}
|
||||||
|
|
||||||
|
// pub fn print_state(self: *Simulation) !void {
|
||||||
|
// // @TODO Organize the output somehow
|
||||||
|
// var stdout = std.io.getStdOut().writer();
|
||||||
|
// var z_min : i64 = std.math.maxInt(i64);
|
||||||
|
// var z_max : i64 = std.math.minInt(i64);
|
||||||
|
// var y_min : i64 = std.math.maxInt(i64);
|
||||||
|
// var y_max : i64 = std.math.minInt(i64);
|
||||||
|
// var x_min : i64 = std.math.maxInt(i64);
|
||||||
|
// var x_max : i64 = std.math.minInt(i64);
|
||||||
|
|
||||||
|
// var it = self.map.iterator();
|
||||||
|
// while (it.next()) |entry| {
|
||||||
|
// //try entry.value.print_state();
|
||||||
|
// x_max = std.math.max(x_max, entry.value.pos[0]);
|
||||||
|
// x_min = std.math.min(x_min, entry.value.pos[0]);
|
||||||
|
// y_max = std.math.max(y_max, entry.value.pos[1]);
|
||||||
|
// y_min = std.math.min(y_min, entry.value.pos[1]);
|
||||||
|
// z_max = std.math.max(z_max, entry.value.pos[2]);
|
||||||
|
// z_min = std.math.min(z_min, entry.value.pos[2]);
|
||||||
|
// }
|
||||||
|
|
||||||
|
// // For from lowest to highest then
|
||||||
|
// var z_pos = z_min;
|
||||||
|
// while (z_pos <= z_max) : (z_pos += 1) {
|
||||||
|
// try stdout.print("z={} x=[{}..{}],y=[{}..{}]\n", .{z_pos, x_min, x_max, y_min, y_max});
|
||||||
|
// var y_pos = y_min;
|
||||||
|
// while (y_pos <= y_max) : (y_pos += 1) {
|
||||||
|
// var x_pos = x_min;
|
||||||
|
// while (x_pos <= x_max) : (x_pos += 1) {
|
||||||
|
// //try stdout.print("({}, {}, {})\n", .{x_pos, y_pos, z_pos});
|
||||||
|
// var c : u8 = '.';
|
||||||
|
// if (self.map.get([_]i64{x_pos, y_pos, z_pos})) |cube| {
|
||||||
|
// if (cube.state == .active) {
|
||||||
|
// c = '#';
|
||||||
|
// }
|
||||||
|
// }
|
||||||
|
// try stdout.print("{c}", .{c});
|
||||||
|
// }
|
||||||
|
// _ = try stdout.write("\n");
|
||||||
|
// }
|
||||||
|
// _ = try stdout.write("\n");
|
||||||
|
// }
|
||||||
|
// _ = try stdout.write("\n");
|
||||||
|
|
||||||
|
// }
|
||||||
|
|
||||||
|
// pub fn print_state_neighbour_count (self: *Simulation) !void {
|
||||||
|
// // @TODO Organize the output somehow
|
||||||
|
// var stdout = std.io.getStdOut().writer();
|
||||||
|
// var z_min : i64 = std.math.maxInt(i64);
|
||||||
|
// var z_max : i64 = std.math.minInt(i64);
|
||||||
|
// var y_min : i64 = std.math.maxInt(i64);
|
||||||
|
// var y_max : i64 = std.math.minInt(i64);
|
||||||
|
// var x_min : i64 = std.math.maxInt(i64);
|
||||||
|
// var x_max : i64 = std.math.minInt(i64);
|
||||||
|
|
||||||
|
// var it = self.map.iterator();
|
||||||
|
// while (it.next()) |entry| {
|
||||||
|
// //try entry.value.print_state();
|
||||||
|
// x_max = std.math.max(x_max, entry.value.pos[0]);
|
||||||
|
// x_min = std.math.min(x_min, entry.value.pos[0]);
|
||||||
|
// y_max = std.math.max(y_max, entry.value.pos[1]);
|
||||||
|
// y_min = std.math.min(y_min, entry.value.pos[1]);
|
||||||
|
// z_max = std.math.max(z_max, entry.value.pos[2]);
|
||||||
|
// z_min = std.math.min(z_min, entry.value.pos[2]);
|
||||||
|
// }
|
||||||
|
|
||||||
|
// // For from lowest to highest then
|
||||||
|
// var z_pos = z_min;
|
||||||
|
// while (z_pos <= z_max) : (z_pos += 1) {
|
||||||
|
// try stdout.print("z={} x=[{}..{}],y=[{}..{}]\n", .{z_pos, x_min, x_max, y_min, y_max});
|
||||||
|
// var y_pos = y_min;
|
||||||
|
// while (y_pos <= y_max) : (y_pos += 1) {
|
||||||
|
// var x_pos = x_min;
|
||||||
|
// while (x_pos <= x_max) : (x_pos += 1) {
|
||||||
|
// //try stdout.print("({}, {}, {})\n", .{x_pos, y_pos, z_pos});
|
||||||
|
// var c : u64 = 0;
|
||||||
|
// if (self.map.get([_]i64{x_pos, y_pos, z_pos})) |cube| {
|
||||||
|
// c = cube.neighbours;
|
||||||
|
// }
|
||||||
|
// try stdout.print("{:02}", .{c});
|
||||||
|
// }
|
||||||
|
// _ = try stdout.write("\n");
|
||||||
|
// }
|
||||||
|
// _ = try stdout.write("\n");
|
||||||
|
// }
|
||||||
|
// _ = try stdout.write("\n");
|
||||||
|
|
||||||
|
// }
|
||||||
|
|
||||||
|
pub fn do_round(self: *Simulation4D) !void {
|
||||||
|
// For each cube, check all of it's neighbours
|
||||||
|
var it = self.map.iterator();
|
||||||
|
var neighbours_to_add = std.ArrayList([4]i64).init(self.allocator);
|
||||||
|
defer neighbours_to_add.deinit();
|
||||||
|
|
||||||
|
// Get the neighbours we need possibly create for this round
|
||||||
|
while (it.next()) |entry| {
|
||||||
|
var neighbours = entry.value.get_neighbour_positions(self.allocator);
|
||||||
|
//defer self.allocator.free(neighbours);
|
||||||
|
var n_active : u64 = 0;
|
||||||
|
for (neighbours) |n_pos| {
|
||||||
|
if (self.map.get(n_pos)) |n| {
|
||||||
|
// Noop, we already have a cube
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
// The neighbour doesn't yet exist, we should create it
|
||||||
|
// but we don't want to do that while iterating over
|
||||||
|
// the current entries.
|
||||||
|
// We also want to make sure that we're not adding a
|
||||||
|
// value that's already in the list to be added.
|
||||||
|
// For the moment, we'll check that when iterating
|
||||||
|
// over neighbours_to_add.
|
||||||
|
try neighbours_to_add.append(n_pos);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// Add any new neighbours
|
||||||
|
for (neighbours_to_add.items) |new_pos| {
|
||||||
|
// Double-check we don't already have this neighbour
|
||||||
|
if (self.map.get(new_pos)) |v| {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
try self.map.putNoClobber(new_pos, Cube4D {.pos = new_pos, .state = .inactive});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
self.calculate_neighbour_states();
|
||||||
|
|
||||||
|
// Now next state should be set, we go through again to swap
|
||||||
|
// @TODO Update state
|
||||||
|
it = self.map.iterator();
|
||||||
|
while (it.next()) |entry| {
|
||||||
|
if (entry.value.state == .active) {
|
||||||
|
if (entry.value.neighbours >= 2 and entry.value.neighbours <= 3) {
|
||||||
|
entry.value.state = .active;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
entry.value.state = .inactive;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
if (entry.value.neighbours == 3) {
|
||||||
|
entry.value.state = .active;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn calculate_neighbour_states(self: *Simulation4D) void {
|
||||||
|
var it = self.map.iterator();
|
||||||
|
while (it.next()) |entry| {
|
||||||
|
var neighbours = entry.value.get_neighbour_positions(self.allocator);
|
||||||
|
//defer self.allocator.free(neighbours);
|
||||||
|
var n_active : u64 = 0;
|
||||||
|
//std.log.warn("Checking neighbours for ({}, {}, {})",
|
||||||
|
// .{entry.value.pos[0], entry.value.pos[1], entry.value.pos[2]});
|
||||||
|
for (neighbours) |n_pos| {
|
||||||
|
if (self.map.get(n_pos)) |n| {
|
||||||
|
if (n.state == .active) {
|
||||||
|
//std.log.warn("Neighbour at ({}, {}, {}) is active",
|
||||||
|
// .{n.pos[0], n.pos[1], n.pos[2]});
|
||||||
|
n_active += 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
// Noop, another function creates our neighbours, and it should
|
||||||
|
// be run before this one.
|
||||||
|
}
|
||||||
|
}
|
||||||
|
entry.value.neighbours = n_active;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn count_active_cubes(self: *Simulation4D) u64 {
|
||||||
|
var it = self.map.iterator();
|
||||||
|
var count : u64 = 0;
|
||||||
|
while (it.next()) |entry| {
|
||||||
|
if (entry.value.state == .active) {
|
||||||
|
count += 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return count;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
test "get_neighbour_positions" {
|
||||||
|
var cube = Cube{
|
||||||
|
.pos = [_]i64{0, 0, 0},
|
||||||
|
};
|
||||||
|
var neighbours = cube.get_neighbour_positions();
|
||||||
|
for (neighbours) |n| {
|
||||||
|
std.log.warn("({}, {}, {})", .{n[0], n[1], n[2]});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
test "small_cubeway" {
|
||||||
|
var sim = try Simulation.init(std.testing.allocator);
|
||||||
|
defer sim.deinit();
|
||||||
|
try sim.add_cube([_]i64 {0, 0, 0}, .inactive);
|
||||||
|
try sim.add_cube([_]i64 {1, 0, 0}, .active);
|
||||||
|
try sim.add_cube([_]i64 {2, 0, 0}, .inactive);
|
||||||
|
|
||||||
|
try sim.add_cube([_]i64 {0, 1, 0}, .inactive);
|
||||||
|
try sim.add_cube([_]i64 {1, 1, 0}, .inactive);
|
||||||
|
try sim.add_cube([_]i64 {2, 1, 0}, .active);
|
||||||
|
|
||||||
|
try sim.add_cube([_]i64 {0, 2, 0}, .active);
|
||||||
|
try sim.add_cube([_]i64 {1, 2, 0}, .active);
|
||||||
|
try sim.add_cube([_]i64 {2, 2, 0}, .active);
|
||||||
|
|
||||||
|
try sim.print_state();
|
||||||
|
sim.calculate_neighbour_states();
|
||||||
|
try sim.print_state_neighbour_count();
|
||||||
|
std.testing.expectEqual(@as(u64, 5), sim.count_active_cubes());
|
||||||
|
|
||||||
|
std.log.warn("\n\n --- First round --- \n", .{});
|
||||||
|
try sim.do_round(); // 1
|
||||||
|
try sim.print_state();
|
||||||
|
std.testing.expectEqual(@as(u64, 11), sim.count_active_cubes());
|
||||||
|
|
||||||
|
try sim.do_round(); // 2
|
||||||
|
try sim.do_round(); // 3
|
||||||
|
try sim.do_round(); // 4
|
||||||
|
try sim.do_round(); // 5
|
||||||
|
try sim.do_round(); // 6
|
||||||
|
|
||||||
|
var active = sim.count_active_cubes();
|
||||||
|
std.testing.expectEqual(@as(u64, 112), active);
|
||||||
|
}
|
||||||
|
|
||||||
|
test "4d_cubeway" {
|
||||||
|
var sim = try Simulation4D.init(std.testing.allocator);
|
||||||
|
defer sim.deinit();
|
||||||
|
try sim.add_cube([_]i64 {0, 0, 0, 0}, .inactive);
|
||||||
|
try sim.add_cube([_]i64 {1, 0, 0, 0}, .active);
|
||||||
|
try sim.add_cube([_]i64 {2, 0, 0, 0}, .inactive);
|
||||||
|
|
||||||
|
try sim.add_cube([_]i64 {0, 1, 0, 0}, .inactive);
|
||||||
|
try sim.add_cube([_]i64 {1, 1, 0, 0}, .inactive);
|
||||||
|
try sim.add_cube([_]i64 {2, 1, 0, 0}, .active);
|
||||||
|
|
||||||
|
try sim.add_cube([_]i64 {0, 2, 0, 0}, .active);
|
||||||
|
try sim.add_cube([_]i64 {1, 2, 0, 0}, .active);
|
||||||
|
try sim.add_cube([_]i64 {2, 2, 0, 0}, .active);
|
||||||
|
|
||||||
|
try sim.do_round(); // 1
|
||||||
|
try sim.do_round(); // 2
|
||||||
|
try sim.do_round(); // 3
|
||||||
|
try sim.do_round(); // 4
|
||||||
|
try sim.do_round(); // 5
|
||||||
|
try sim.do_round(); // 6
|
||||||
|
|
||||||
|
var active = sim.count_active_cubes();
|
||||||
|
std.testing.expectEqual(@as(u64, 848), active);
|
||||||
|
}
|
||||||
Reference in New Issue