Adding some unfinished days

day12/index.js

@@ -0,0 +1,71 @@
+const fs = require("node:fs");
+
+let data;
+try {
+  data = fs.readFileSync("test.txt", "utf8");
+} catch (err) {
+  return
+}
+
+const lines = data.trim().split("\n");
+var part1 = 0;
+var part2 = 0;
+
+lines.forEach((l) => {
+  const parts = l.split(" ");
+  const map = parts[0];
+  const damaged = parts[1].split(",").map(Number);
+  // const all = allArrangements(map)
+  // const valid = all.filter((m) => isValid(m, damaged));
+  // part1 += valid.length;
+
+  const map2 = [map, map, map, map, map].join("?");
+  const damaged2 = [damaged, damaged, damaged, damaged, damaged].flat();
+  // console.log(damaged2);
+  const all2 = allValidArrangements(map2, damaged2);
+  console.log("all2", all2);
+  part2 += all2.length;
+});
+
+// console.log("part1", part1);
+console.log("part2", part1);
+
+function allValidArrangements(map, damaged, index = 0) {
+  const i = map.substring(index).indexOf("?");
+  if (i === -1) {
+    return map;
+  }
+
+  const one = allValidArrangements(replaceAt(map, i + index, "#"), damaged, index + 1);
+  const two = allValidArrangements(replaceAt(map, i + index, "."), damaged, index + 1);
+  return [one, two].flat();
+}
+
+
+function allArrangements(map, index = 0) {
+  const i = map.substring(index).indexOf("?");
+  if (i === -1) {
+    return map;
+  }
+
+  const one = allArrangements(replaceAt(map, i + index, "#"), index + 1);
+  const two = allArrangements(replaceAt(map, i + index, "."), index + 1);
+  return [one, two].flat();
+}
+
+function replaceAt(str, index, replacement) {
+  return str.substring(0, index) + replacement + str.substring(index + replacement.length);
+}
+
+function isValid(map, damaged) {
+  const trimmed = map.replace(/^\.+/, "").replace(/\.+$/, "");
+  const parts = trimmed.split(/\.+/);
+  let isValid = parts.length === damaged.length;
+  damaged.forEach((d, i) => {
+    if (!parts[i] || parts[i].length !== d) {
+      isValid = false;
+    }
+  });
+
+  return isValid;
+}

day12/main.zig

@@ -0,0 +1,87 @@
+const std = @import("std");
+
+const Record = struct { map: []const u8, damaged: std.ArrayList(u8) };
+
+pub fn main() !void {
+    const content = @embedFile("test.txt");
+    var lines = std.mem.split(u8, content, "\n");
+
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    const allocator = gpa.allocator();
+
+    var records = std.ArrayList(Record).init(allocator);
+    defer records.deinit();
+
+    // parse lines
+    while (lines.next()) |line| {
+        if (line.len < 1) {
+            break;
+        }
+        var parts = std.mem.split(u8, line, " ");
+        const map = parts.next().?;
+        var damageIterator = std.mem.split(u8, parts.next().?, ",");
+        var damaged = std.ArrayList(u8).init(allocator);
+        while (damageIterator.next()) |d| {
+            const parsed = try std.fmt.parseInt(u8, d, 10);
+            try damaged.append(parsed);
+        }
+        try records.append(Record{ .map = map, .damaged = damaged });
+    }
+    std.debug.print("records: {any}\n", .{records.items});
+
+    var part1: u8 = 0;
+    for (records.items) |r| {
+        // var all = std.ArrayList(u8).init(allocator);
+        const all = allArrangements(r.map, r.damaged, 0);
+        std.debug.print("all arrangements: {any}\n", .{all});
+
+        // part1 += numValid(r);
+    }
+
+    std.debug.print("Part1: {d}\n", .{part1});
+}
+
+// replaces ?s with every possible combination of . or #
+// fn allArrangements(r: Record, i: u8) []const u8 {
+fn allArrangements(map: []const u8, damaged: std.ArrayList(u8), start: u8) []const u8 {
+    std.debug.print("allArrangements. map: {any} damage: {any} start: {any}\n", .{ map, damaged, start });
+    // find the first ?
+    const idx = std.mem.indexOf(u8, map, "?");
+    if (idx == null) {
+        return map;
+    }
+
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    const allocator = gpa.allocator();
+
+    var records = std.ArrayList(Record).init(allocator);
+    defer records.deinit();
+
+    var one: [map.len]u8 = undefined;
+    @memcpy(one, map);
+    std.debug.print("? idx: {?d}\n", .{idx});
+    return &[_]u8{1};
+}
+
+fn numValid(r: Record) u8 {
+    // var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    // const allocator = gpa.allocator();
+    //
+    // // generate all possible arrangements
+    // var all = std.ArrayList(u8).init(allocator);
+    // defer all.deinit();
+
+    const num = numQuestionMarks(r.map);
+    std.debug.print("num ?: {d}\n", .{num});
+    return num;
+}
+
+fn numQuestionMarks(str: []const u8) u8 {
+    var i: u8 = 0;
+    for (str) |char| {
+        if (char == '?') {
+            i += 1;
+        }
+    }
+    return i;
+}