solve up to day 7

8 files changed, 673 insertions, 0 deletions

diff --git a/src/day01.zig b/src/day01.zig
new file mode 100644
index 0000000..2010816
--- /dev/null
+++ b/src/day01.zig
@@ -0,0 +1,72 @@
+const std = @import("std");
+const print = std.debug.print;
+
+pub fn solve(part: []u8, reader: *std.Io.Reader, _: std.mem.Allocator) !void {
+    if (std.mem.eql(u8, part, "1")) {
+        try part1(reader);
+    } else {
+        try part2(reader);
+    }
+}
+
+fn part1(reader: *std.Io.Reader) !void {
+    var pos: i32 = 50;
+    var zero: usize = 0;
+    while (reader.takeDelimiterInclusive('\n')) |line| {
+        if (line.len == 0){
+            break;
+        }
+
+        const numSlice = std.mem.trimRight(u8, line[1..], &[_]u8{'\n'});
+        const rotations = try std.fmt.parseInt(i32, numSlice, 10);
+        if (line[0] == 'R') {
+            pos += rotations;
+        } else if (line[0] == 'L'){
+            pos -= rotations;
+        }
+
+        pos = @mod(pos, 100);
+
+        if (pos == 0) {
+            zero += 1;
+        }
+
+    } else |_| {
+    }
+
+    print("{d}\n", .{zero});
+}
+
+fn part2(reader: *std.Io.Reader) !void {
+    var pos: i32 = 50;
+    var zero: i32 = 0;
+    while (reader.takeDelimiterInclusive('\n')) |line| {
+        if (line.len == 0){
+            break;
+        }
+
+        const numSlice = std.mem.trimRight(u8, line[1..], &[_]u8{'\n'});
+        var rotations = try std.fmt.parseInt(i32, numSlice, 10);
+
+        zero += @divFloor(rotations, 100);
+        rotations = @rem(rotations, 100);
+        
+        if (line[0] == 'L'){
+            rotations *= -1;
+        }
+
+        const with_rotations: i32 = pos + rotations;
+        const new: i32 = @mod(with_rotations, 100);
+
+
+        if ((new != with_rotations and pos != 0) or new == 0){
+            zero += 1;
+        }
+
+        pos = new;
+
+
+    } else |_| {}
+
+    print("{d}\n", .{zero});
+}
diff --git a/src/day02.zig b/src/day02.zig
new file mode 100644
index 0000000..f764589
--- /dev/null
+++ b/src/day02.zig
@@ -0,0 +1,78 @@
+const std = @import("std");
+const print = std.debug.print;
+
+pub fn solve(part: []u8, reader: *std.Io.Reader, _: std.mem.Allocator) !void {
+    if (std.mem.eql(u8, part, "1")) {
+        try part1(reader);
+    } else {
+        try part2(reader);
+    }
+}
+
+fn digits(number: usize) usize {
+    var value = number;
+    var n: usize = 0;
+    while (value != 0) : (value /= 10) {
+        n += 1;
+    }
+    return n;
+}
+
+fn part1(reader: *std.Io.Reader) !void {
+    var output: usize = 0;
+    while (reader.takeDelimiter(',')) |line| {
+        const trimmed = std.mem.trimRight(u8, line.?, &[_]u8{'\n'});
+        if (trimmed.len == 0) break;
+        var split = std.mem.splitScalar(u8, trimmed, '-');
+        var start = try std.fmt.parseInt(usize, split.next().?, 10);
+        const end = try std.fmt.parseInt(usize, split.next().?, 10);
+        while (start <= end): (start += 1) {
+            const n = digits(start);
+            if (n % 2 == 0 and start % std.math.pow(usize, 10,n/2) == start / std.math.pow(usize, 10,n/2)) {
+                output += start;
+                start += std.math.pow(usize, 2,n/2);
+            }
+        }
+
+    } else |_| {
+    }
+    print("{d}\n", .{output});
+}
+
+fn part2(reader: *std.Io.Reader) !void {
+    var output: usize = 0;
+    while (reader.takeDelimiter(',')) |line| {
+        const trimmed = std.mem.trimRight(u8, line.?, &[_]u8{'\n'});
+        if (trimmed.len == 0) break;
+        var split = std.mem.splitScalar(u8, trimmed, '-');
+        var start = try std.fmt.parseInt(usize, split.next().?, 10);
+        const end = try std.fmt.parseInt(usize, split.next().?, 10);
+        while (start <= end): (start += 1) {
+            const n = digits(start);
+            for (1..n) |i| {
+                if (n % i == 0) {
+                    const p: usize = std.math.pow(usize, 10,i);
+                    if (start % p != 0) {
+                        const div = start / (start % p);
+                        var c: usize = 0;
+
+                        for (0..n/i - 1) |_| {
+                            c *= p;
+                            c += p;
+                        }
+                        c += 1;
+
+                        if (div == c){
+                            output += start;
+                            start += std.math.pow(usize, 2, n/2);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+    } else |_| {
+    }
+    print("{d}\n", .{output});
+}
diff --git a/src/day03.zig b/src/day03.zig
new file mode 100644
index 0000000..c91e60a
--- /dev/null
+++ b/src/day03.zig
@@ -0,0 +1,83 @@
+const std = @import("std");
+const print = std.debug.print;
+
+pub fn solve(part: []u8, reader: *std.Io.Reader, _: std.mem.Allocator) !void {
+    if (std.mem.eql(u8, part, "1")) {
+        try part1(reader);
+    } else {
+        try part2(reader);
+    }
+}
+
+
+fn part1(reader: *std.Io.Reader) !void {
+    var output: usize = 0;
+    while (reader.takeDelimiter('\n')) |line| {
+        if (line.?.len == 0){
+            break;
+        }
+
+        var max1: usize = 0;
+        var in1: usize = 0;
+        var max2: usize = 0;
+
+        for (line.?, 0..) |b, index| {
+            const value: u8 = b - '0';
+            if (value > max1) {
+                max2 = max1;
+                max1 = value;
+                in1 = index;
+            } else if (value > max2) {
+                max2 = value;
+            }
+        }
+
+        if (in1 < line.?.len - 1){
+            max2 = 0;
+            for (line.?[in1 + 1..]) |b| {
+                const value: u8 = b - '0';
+                if (value > max2) {
+                    max2 = value;
+                }
+            }
+            output += max1 * 10 + max2;
+        } else {
+            output += max2 * 10 + max1;
+        }
+
+    } else |_| {
+    }
+    print("{d}\n", .{output});
+}
+
+fn part2(reader: *std.Io.Reader) !void {
+    var output: usize = 0;
+    while (reader.takeDelimiter('\n')) |line| {
+        var joltage: usize = 0;
+        if (line.?.len == 0){
+            break;
+        }
+
+
+        var last_index: usize = 0;
+        for (0..12) |i| {
+            var max: usize = 0;
+            var max_index: usize = 0;
+            for (line.?[last_index .. line.?.len - 11 + i], 0..) |b, index| {
+                const value: u8 = b - '0';
+                if (value > max) {
+                    max = value;
+                    max_index = index;
+                }
+            }
+
+            last_index += max_index + 1;
+            joltage *= 10;
+            joltage += max;
+        }
+        output += joltage;
+
+    } else |_| {
+    }
+    print("{d}\n", .{output});
+}
diff --git a/src/day04.zig b/src/day04.zig
new file mode 100644
index 0000000..5d7b455
--- /dev/null
+++ b/src/day04.zig
@@ -0,0 +1,99 @@
+const std = @import("std");
+const print = std.debug.print;
+
+pub fn solve(part: []u8, reader: *std.Io.Reader, allocator: std.mem.Allocator) !void {
+    if (std.mem.eql(u8, part, "1")) {
+        try part1(reader, allocator);
+    } else {
+        try part2(reader, allocator);
+    }
+}
+
+
+fn part1(reader: *std.Io.Reader, allocator: std.mem.Allocator) !void {
+    var output: usize = 0;
+    var list = try std.ArrayList([]u8).initCapacity(allocator, 0);
+    defer list.deinit(allocator);
+
+    while (reader.takeDelimiter('\n')) |line| {
+        if (line == null){
+            break;
+        }
+
+        try list.append(allocator, line.?);
+    } else |_| {
+
+    }
+
+
+    for (list.items,0..) |row, y| {
+        for (row,0..) |item,x| {
+            if (item != '@'){
+                continue;
+            }
+
+            var adjacent: usize = 0;
+            if (y > 0 and x > 0 and list.items[y - 1][x - 1] == '@') adjacent += 1;
+            if (y > 0 and list.items[y - 1][x] == '@') adjacent += 1;
+            if (y > 0 and x < row.len - 1 and list.items[y - 1][x + 1] == '@') adjacent += 1;
+            if (x > 0 and list.items[y][x - 1] == '@') adjacent += 1;
+            if (x < row.len - 1 and list.items[y][x + 1] == '@') adjacent += 1;
+            if (y < list.items.len - 1 and x > 0 and list.items[y + 1][x - 1] == '@') adjacent += 1;
+            if (y < list.items.len - 1 and list.items[y + 1][x] == '@') adjacent += 1;
+            if (y < list.items.len - 1 and x < row.len - 1 and list.items[y + 1][x + 1] == '@') adjacent += 1;
+
+            if (adjacent < 4){
+
+                output += 1;
+            }
+        }
+    }
+
+    print("{d}\n", .{output});
+}
+
+fn part2(reader: *std.Io.Reader, allocator: std.mem.Allocator) !void {
+    var output: usize = 0;
+    var list = try std.ArrayList([]u8).initCapacity(allocator, 0);
+    defer list.deinit(allocator);
+
+    while (reader.takeDelimiter('\n')) |line| {
+        if (line == null){
+            break;
+        }
+
+        try list.append(allocator, line.?);
+    } else |_| {
+
+    }
+
+
+    var previous_output: usize = 1;
+    while (output != previous_output) {
+        previous_output = output;
+        for (list.items,0..) |row, y| {
+            for (row,0..) |item,x| {
+                if (item != '@'){
+                    continue;
+                }
+
+                var adjacent: usize = 0;
+                if (y > 0 and x > 0 and list.items[y - 1][x - 1] == '@') adjacent += 1;
+                if (y > 0 and list.items[y - 1][x] == '@') adjacent += 1;
+                if (y > 0 and x < row.len - 1 and list.items[y - 1][x + 1] == '@') adjacent += 1;
+                if (x > 0 and list.items[y][x - 1] == '@') adjacent += 1;
+                if (x < row.len - 1 and list.items[y][x + 1] == '@') adjacent += 1;
+                if (y < list.items.len - 1 and x > 0 and list.items[y + 1][x - 1] == '@') adjacent += 1;
+                if (y < list.items.len - 1 and list.items[y + 1][x] == '@') adjacent += 1;
+                if (y < list.items.len - 1 and x < row.len - 1 and list.items[y + 1][x + 1] == '@') adjacent += 1;
+
+                if (adjacent < 4){
+                    list.items[y][x] = '.';
+                    output += 1;
+                }
+            }
+        }
+    }
+
+    print("{d}\n", .{output});
+}
diff --git a/src/day05.zig b/src/day05.zig
new file mode 100644
index 0000000..2f971f9
--- /dev/null
+++ b/src/day05.zig
@@ -0,0 +1,107 @@
+const std = @import("std");
+const print = std.debug.print;
+
+pub fn solve(part: []u8, reader: *std.Io.Reader, allocator: std.mem.Allocator) !void {
+    if (std.mem.eql(u8, part, "1")) {
+        try part1(reader, allocator);
+    } else {
+        try part2(reader, allocator);
+    }
+}
+
+const Range = struct { start: usize, end: usize };
+
+fn part1(reader: *std.Io.Reader, allocator: std.mem.Allocator) !void {
+    var output: usize = 0;
+
+    var ranges = try std.ArrayList(Range).initCapacity(allocator, 0);
+    defer ranges.deinit(allocator);
+
+    while (reader.takeDelimiter('\n')) |line| {
+        if (line == null or line.?.len == 0){
+            break;
+        }
+
+        var split = std.mem.splitScalar(u8, line.?, '-');
+        const start = try std.fmt.parseInt(usize, split.next().?, 10);
+        const end = try std.fmt.parseInt(usize, split.next().?, 10);
+
+        try ranges.append(allocator, Range{ .start=start, .end=end});
+
+    } else |_| {}
+
+    while (reader.takeDelimiter('\n')) |line| {
+        if (line == null) {
+            break;
+        }
+
+        const id = try std.fmt.parseInt(usize, line.?, 10);
+
+        for(ranges.items) |range| {
+            if (id >= range.start and id <= range.end) {
+                output += 1;
+                break;
+            }
+        }
+
+    } else |_| {}
+
+    print("{d}\n", .{output});
+}
+
+fn cmp(_: void, a: Range, b: Range) bool {
+        return a.start < b.start;
+}
+
+fn part2(reader: *std.Io.Reader, allocator: std.mem.Allocator) !void {
+    var output: usize = 0;
+
+    var ranges = try std.ArrayList(Range).initCapacity(allocator, 0);
+    defer ranges.deinit(allocator);
+
+    while (reader.takeDelimiter('\n')) |line| {
+        if (line == null or line.?.len == 0){
+            break;
+        }
+
+        var split = std.mem.splitScalar(u8, line.?, '-');
+        const start = try std.fmt.parseInt(usize, split.next().?, 10);
+        const end = try std.fmt.parseInt(usize, split.next().?, 10);
+
+        try ranges.append(allocator, Range{ .start=start, .end=end});
+
+    } else |_| {}
+
+
+    std.mem.sort(Range,ranges.items, {}, cmp);
+
+    var more = try std.ArrayList(Range).initCapacity(allocator, 0);
+    defer more.deinit(allocator);
+
+    outer: for (ranges.items) |r| {
+
+        const start = r.start;
+        const end = r.end;
+
+        for (more.items) |*range| {
+            if (start >= range.start and start <= range.end) {
+                if (end > range.end){
+                    range.end = end;
+                }
+                continue :outer;
+            } else if (start < range.start and end >= range.start) {
+                range.start = start;
+                continue :outer;
+            }
+        }
+
+        try more.append(allocator, Range{ .start=start, .end=end});
+
+    }
+
+    for (more.items) |range| {
+        output += range.end - range.start + 1;
+    }
+
+    print("{d}\n", .{output});
+}
diff --git a/src/day06.zig b/src/day06.zig
new file mode 100644
index 0000000..4105800
--- /dev/null
+++ b/src/day06.zig
@@ -0,0 +1,100 @@
+const std = @import("std");
+const print = std.debug.print;
+
+pub fn solve(part: []u8, reader: *std.Io.Reader, allocator: std.mem.Allocator) !void {
+    if (std.mem.eql(u8, part, "1")) {
+        try part1(reader, allocator);
+    } else {
+        try part2(reader, allocator);
+    }
+}
+
+fn part1(reader: *std.Io.Reader, allocator: std.mem.Allocator) !void {
+    var output: usize = 0;
+    var problems = try std.ArrayList(std.ArrayList(usize)).initCapacity(allocator, 0);
+    defer problems.deinit(allocator);
+
+    while (reader.takeDelimiter('\n')) |line| {
+        if (line == null) {
+            break;
+        }
+
+        var split = std.mem.splitScalar(u8, line.?, ' ');
+        var n: usize = 0;
+        while(split.next()) |part| {
+            if (part.len > 0){
+
+                if (part[0] == '+') {
+                    for(problems.items[n].items) |number| {
+                        output += number;
+                    }
+                    problems.items[n].deinit(allocator);
+                } else if (part[0] == '*') {
+                    var tmp: usize = 1;
+                    for(problems.items[n].items) |number| {
+                        tmp *= number;
+                    }
+                    output += tmp;
+                    problems.items[n].deinit(allocator);
+                } else {
+                    const number = try std.fmt.parseInt(usize, part, 10);
+
+                    if (n >= problems.items.len) {
+                        try  problems.append(allocator, try std.ArrayList(usize).initCapacity(allocator, 0));
+                    }
+
+                    try problems.items[n].append(allocator, number);
+                }
+
+                n += 1;
+            }
+        }
+
+    } else |_| {}
+
+    print("{d}\n", .{output});
+}
+
+
+fn part2(reader: *std.Io.Reader, allocator: std.mem.Allocator) !void {
+    var output: usize = 0;
+    var problems = try std.ArrayList([]u8).initCapacity(allocator, 0);
+    defer problems.deinit(allocator);
+
+    while (reader.takeDelimiter('\n')) |line| {
+        if (line == null) {
+            break;
+        }
+
+        try problems.append(allocator, line.?);
+    } else |_| {}
+
+
+    var n: usize = 0;
+    var accum: usize = 1;
+    var operator = problems.items[problems.items.len - 1][0];
+    while(n < problems.items[0].len) {
+        var number: usize = 0;
+        for (0..problems.items.len - 1) |i| {
+            if (problems.items[i][n] != ' ') {
+                number *= 10;
+                number += problems.items[i][n] - '0';
+            }
+        }
+
+        n += 1;
+        if (number == 0) {
+            if (operator == '*') {
+                output += accum;
+            }
+            operator = problems.items[problems.items.len - 1][n];
+            accum = 1;
+        } else if (operator == '+') {
+            output += number;
+        } else {
+            accum *= number;
+        }
+    }
+
+    print("{d}\n", .{output});
+}
diff --git a/src/day07.zig b/src/day07.zig
new file mode 100644
index 0000000..620aaa3
--- /dev/null
+++ b/src/day07.zig
@@ -0,0 +1,88 @@
+const std = @import("std");
+const print = std.debug.print;
+
+pub fn solve(part: []u8, reader: *std.Io.Reader, allocator: std.mem.Allocator) !void {
+    if (std.mem.eql(u8, part, "1")) {
+        try part1(reader, allocator);
+    } else {
+        try part2(reader, allocator);
+    }
+}
+
+fn part1(reader: *std.Io.Reader, allocator: std.mem.Allocator) !void {
+    var output: usize = 0;
+
+    const first = try reader.takeDelimiter('\n');
+
+    var space = try allocator.alloc(bool, first.?.len);
+    defer allocator.free(space);
+
+    for (space) |*b| b.* = false;
+
+    space[(first.?.len - 1) / 2] = true;
+
+    while (reader.takeDelimiter('\n')) |line| {
+        if (line == null) {
+            break;
+        }
+
+        for (line.?,0..) |e, i| {
+            if (e == '^' and space[i]) {
+                space[i] = false;
+                space[i-1] = true;
+                space[i+1] = true;
+                output += 1;
+            }
+        }
+
+    } else |_| {}
+
+    print("{d}\n", .{output});
+}
+
+fn quantum(space: [][]u8, pos: usize, y: usize, output: *usize) void {
+
+    if (space.len == y){
+        return;
+    }
+
+    if (space[y][pos] == '^') {
+        quantum(space, pos - 1, y + 1, output);
+        output.* += 1;
+        quantum(space, pos + 1, y + 1, output);
+    } else {
+        quantum(space, pos, y + 1, output);
+    }
+}
+
+
+fn part2(reader: *std.Io.Reader, allocator: std.mem.Allocator) !void {
+    var output: usize = 1;
+
+    const first = try reader.takeDelimiter('\n');
+
+    var space = try allocator.alloc(usize, first.?.len);
+    defer allocator.free(space);
+
+    for (space) |*b| b.* = 0;
+
+    space[(first.?.len - 1) / 2] = 1;
+
+    while (reader.takeDelimiter('\n')) |line| {
+        if (line == null) {
+            break;
+        }
+
+        for (line.?,0..) |e, i| {
+            if (e == '^' and space[i] > 0) {
+                space[i-1] += space[i];
+                space[i+1] += space[i];
+                output += space[i];
+                space[i] = 0;
+            }
+        }
+
+    } else |_| {}
+
+    print("{d}\n", .{output});
+}
diff --git a/src/main.zig b/src/main.zig
new file mode 100644
index 0000000..79979e4
--- /dev/null
+++ b/src/main.zig
@@ -0,0 +1,46 @@
+const std = @import("std");
+const print = std.debug.print;
+
+const day01 = @import("day01.zig");
+const day02 = @import("day02.zig");
+const day03 = @import("day03.zig");
+const day04 = @import("day04.zig");
+const day05 = @import("day05.zig");
+const day06 = @import("day06.zig");
+const day07 = @import("day07.zig");
+
+pub fn main() !void {
+    if (std.os.argv.len != 3) {
+        print("Usage: {s} <day> <part> < <input> \n", .{std.os.argv[0]});
+        return;
+    }
+
+    var stdin_buf: [1024 * 1024]u8 = undefined;
+    var reader = std.fs.File.stdin().reader(&stdin_buf);
+    const stdin: *std.Io.Reader = &reader.interface;
+
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    const allocator = gpa.allocator();
+    defer {
+        _ = gpa.deinit();
+    }
+
+    const args = try std.process.argsAlloc(allocator);
+    defer std.process.argsFree(allocator, args);
+
+    const day = std.fmt.parseInt(usize, args[1], 10) catch {
+        print("Not valid day format\n: {s}", .{args[1]});
+        return;
+    };
+
+    try switch (day) {
+        1 => day01.solve(args[2], stdin, allocator),
+        2 => day02.solve(args[2], stdin, allocator),
+        3 => day03.solve(args[2], stdin, allocator),
+        4 => day04.solve(args[2], stdin, allocator),
+        5 => day05.solve(args[2], stdin, allocator),
+        6 => day06.solve(args[2], stdin, allocator),
+        7 => day07.solve(args[2], stdin, allocator),
+        else => print("Day not yet implemented", .{}),
+    };
+}