day 16 part 1 (with tons of debug printf)

2021/day16/aoc-c.c

@@ -0,0 +1,194 @@
+/* aoc-c.c: Advent of Code 2021, day 16 parts 1 & 2
+ *
+ * Copyright (C) 2021 Bruno Raoult ("br")
+ * Licensed under the GNU General Public License v3.0 or later.
+ * Some rights reserved. See COPYING.
+ *
+ * You should have received a copy of the GNU General Public License along with this
+ * program. If not, see <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <malloc.h>
+#include <ctype.h>
+#include <stdint.h>
+
+#include "debug.h"
+#include "pool.h"
+#include "bits.h"
+#include "list.h"
+
+#define MAX_SUBPACKETS 1024
+
+#define TYPE_VAL 4
+
+struct packet {
+    u8 version;
+    u8 type;
+    u64 value;
+};
+
+static u64 totversions;
+
+static u64 bitval(char *p, int length)
+{
+    u64 val = 0;
+    for (; length; length--, p++) {
+        u8 b = *p -'0';
+        val += b << (length - 1);
+        //printf("%c -> %d, %lu\n", *p, b, val);
+    }
+    //printf("%lu\n", val);
+    return val;
+}
+
+static u64 decode_value(char *bits, char **end)
+{
+    u64 val = 0;
+
+    for (u64 tmp = 16; tmp & 16; bits += 5) {
+        tmp = bitval(bits, 5);
+        val = val << 4 | (tmp & 15);
+        //printf("bits =%5s  tmp=%lu xor=%lu val=%lu\n", bits, tmp, tmp & 15, val);
+    }
+    *end = bits;
+    return val;
+}
+
+int weight[] =  {
+    ['B'] = 0, ['C'] = 1, ['F'] =  2,
+    ['H'] =  3, ['K'] =  4, ['N'] =  5, ['O'] =  6,
+    ['P'] =  7, ['S'] =  8, ['V'] =  9
+};
+
+static struct packet decode(char *start, char **end)
+{
+    struct packet packet;
+    char *cur;
+    s64 count;
+
+    //printf("decode(%.4s...)\n", start);
+    packet.version = bitval(start, 3);
+    totversions += packet.version;
+    packet.type = bitval(start + 3, 3);
+    log_f(3, "[%.6s...] version=%d type=%d\n", start, packet.version, packet.type);
+    cur = start + 6;
+    switch (packet.type) {
+        case TYPE_VAL:
+            packet.value = decode_value(cur, end);
+            printf("val = %lu len=%lu\n", packet.value, *end - cur);
+            break;
+        default:
+            switch (*cur++) {
+                case '0':
+                    count = bitval(cur, 15);
+                    cur += 15;
+                    *end = cur;
+                    printf("nbits = %lu\n", count);
+                    while ((*end - cur) < count) {
+                        decode(*end, end);
+                        printf("  end - cur = %lu\n", *end - cur);
+                    }
+                    break;
+                case '1':
+                    count = bitval(cur, 11);
+                    cur += 11;
+                    *end = cur;
+                    printf("npackets = %ld\n", count);
+                    while (count--) {
+                        decode(*end, end);
+                        printf("  count = %ld\n", count);
+                    }
+
+            }
+
+    }
+    //log_f(3, "bin=[%s] version=%d type=%d\n", bits, version, type);
+    //log_f(3, "[%s] version=%d type=%d\n", start, packet.version, packet.type);
+    return packet;
+}
+
+/* read BITS data
+ */
+static char *read_input()
+{
+    size_t alloc = 0;
+    char *buf, *bits = NULL, *p, *q, decode[2] = { 0 };
+    ssize_t buflen, bits_len;
+
+    if ((buflen = getline(&buf, &alloc, stdin)) > 0) {
+        buf[--buflen] = 0;
+
+        bits_len = buflen * 4 + 1;
+        if (!(bits = malloc(bits_len)))
+            goto free;
+        for (p = buf, q = bits; *p; ++p, q += 4) {
+            decode[0] = *p;
+            int val = strtol(decode, NULL, 16);
+            sprintf(q, "%c%c%c%c", val & 8? '1': '0', val & 4? '1': '0',
+                    val & 2? '1': '0', val & 1? '1': '0');
+        }
+    }
+free:
+    free(buf);
+    return bits;
+}
+
+/*
+static u32 doit()
+{
+    return 1;
+}
+
+
+static u32 part1()
+{
+    return doit();
+}
+
+static u32 part2()
+{
+    return doit();
+}
+*/
+
+static int usage(char *prg)
+{
+    fprintf(stderr, "Usage: %s [-d debug_level] [-p part]\n", prg);
+    return 1;
+}
+
+int main(int ac, char **av)
+{
+    int opt, part = 1;
+    char *buf, *end=NULL;
+
+    while ((opt = getopt(ac, av, "d:p:")) != -1) {
+        switch (opt) {
+            case 'd':
+                debug_level_set(atoi(optarg));
+                break;
+            case 'p':                             /* 1 or 2 */
+                part = atoi(optarg);
+                if (part < 1 || part > 2)
+                    return usage(*av);
+                break;
+            default:
+                return usage(*av);
+        }
+    }
+    if (optind < ac)
+        return usage(*av);
+
+
+    buf = read_input();
+    decode(buf, &end);
+    printf("END: end=%lu sum_versions=%lu\n", end - buf, totversions);
+    //printf("%s : res=%u\n", *av, part == 1? part1(): part2());
+    exit (0);
+}