advent-of-code

commit f668110adab2976ee0ce6882d7d2d9b3b53b81da
parent 11d9e08d18be3896f1e865e5bf7c15647fb35cee
Author: Amin Mesbah <dev@aminmesbah.com>
Date:   Tue,  4 Dec 2018 23:16:46 -0800

Add solution for 05-1

Diffstat:
A
day_05_1.zig
 | 
120
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

1 file changed, 120 insertions(+), 0 deletions(-)
diff --git a/day_05_1.zig b/day_05_1.zig
@@ -0,0 +1,120 @@
+const std = @import("std");
+const debug = std.debug;
+const fmt = std.fmt;
+const mem = std.mem;
+
+const ascii_case_offset: i32 = 'a' - 'A';
+const destroyed_signifier: u8 = '*';
+
+pub fn main() !void {
+    var allocator = &std.heap.DirectAllocator.init().allocator;
+    var result = try react(allocator, input_polymer);
+    debug.warn("05-1 {}\n", result.len);
+}
+
+fn react(allocator: *mem.Allocator, polymer: []const u8) ![]const u8 {
+    var p = try allocator.alloc(u8, polymer.len);
+    mem.copy(u8, p, polymer);
+
+    var last_len: usize = p.len + 1;
+    while (p.len < last_len) {
+        //debug.warn("{}\n", p);
+        last_len = p.len;
+        for (p) |*unit, i| {
+            if (i + 1 < p.len) {
+                var next_unit = p[i + 1];
+                if (@intCast(i32, unit.*) - @intCast(i32, next_unit) == ascii_case_offset or
+                    @intCast(i32, unit.*) - @intCast(i32, next_unit) == -ascii_case_offset) {
+                    unit.* = destroyed_signifier;
+                    p[i + 1] = destroyed_signifier;
+                    p = try shrink(allocator, p);
+                    break;
+                }
+            }
+        }
+        if (p.len == 0) {
+            return p;
+        }
+    }
+    return p;
+}
+
+fn shrink(allocator: *mem.Allocator, reacted_polymer: []const u8) ![]u8 {
+    //debug.warn("{}\n", reacted_polymer);
+    var unit_count: usize = 0;
+    for (reacted_polymer) |unit| {
+        if (unit != destroyed_signifier) {
+            unit_count += 1;
+        }
+    }
+
+    if (unit_count == 0) {
+        return "";
+    }
+
+    var product = try allocator.alloc(u8, unit_count);
+    var product_i: usize = 0;
+    for (reacted_polymer) |unit| {
+        debug.assert(product_i < product.len);
+        if (unit != destroyed_signifier) {
+            product[product_i] = unit;
+            product_i += 1;
+        }
+    }
+    return product;
+}
+
+test "react" {
+    var allocator = &std.heap.DirectAllocator.init().allocator;
+    debug.assert(mem.eql(u8, "", try react(allocator, "aA")));
+    debug.assert(mem.eql(u8, "", try react(allocator, "abBA")));
+    debug.assert(mem.eql(u8, "abAB", try react(allocator, "abAB")));
+    debug.assert(mem.eql(u8, "aabAAB", try react(allocator, "aabAAB")));
+    debug.assert(mem.eql(u8, "dabCBAcaDA", try react(allocator, "dabAcCaCBAcCcaDA")));
+    debug.assert(mem.eql(u8, "dabCBAcaD", try react(allocator, "dabAcCaCBAcCcaD")));
+}
+
+pub fn join_strings(allocator: *mem.Allocator, string1: []const u8, string2: []const u8) ![]u8 {
+    var new_len: usize = string1.len + string2.len;
+    const buf = try allocator.alloc(u8, new_len);
+    errdefer allocator.free(buf);
+
+    var buf_index: usize = 0;
+    mem.copy(u8, buf[buf_index..], string1);
+    buf_index += string1.len;
+    mem.copy(u8, buf[buf_index..], string2);
+
+    return buf;
+}
+
+// Oww my stack!!!
+fn react_recursive(allocator: *mem.Allocator, polymer: []const u8) []const u8 {
+    debug.warn("{}\n", polymer);
+    for (polymer) |unit, i| {
+        if (i + 1 < polymer.len) {
+            var next_unit = polymer[i + 1];
+            //debug.warn("{c}>>{c}\n", unit, next_unit);
+            if (@intCast(i32, unit) - @intCast(i32, next_unit) == ascii_case_offset or @intCast(i32, unit) - @intCast(i32, next_unit) == -ascii_case_offset) {
+                //debug.warn("{c} *** {c}\n", unit, next_unit);
+                var result_polymer = join_strings(allocator, polymer[0..i], polymer[i + 2..]) catch unreachable;
+                //defer allocator.free(result_polymer);
+                var new_stack = allocator.alloc(u8, 100000) catch unreachable;
+                defer allocator.free(new_stack);
+                return @newStackCall(new_stack, react_recursive, allocator, result_polymer);
+            }
+        }
+    }
+    return polymer;
+}
+
+test "react recursive" {
+    var allocator = &std.heap.DirectAllocator.init().allocator;
+    debug.assert(mem.eql(u8, "", react_recursive(allocator, "aA")));
+    debug.assert(mem.eql(u8, "", react_recursive(allocator, "abBA")));
+    debug.assert(mem.eql(u8, "abAB", react_recursive(allocator, "abAB")));
+    debug.assert(mem.eql(u8, "aabAAB", react_recursive(allocator, "aabAAB")));
+    debug.assert(mem.eql(u8, "dabCBAcaDA", react_recursive(allocator, "dabAcCaCBAcCcaDA")));
+    debug.assert(mem.eql(u8, "dabCBAcaD", react_recursive(allocator, "dabAcCaCBAcCcaD")));
+}
+
+const input_polymer = "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";