2019 day 5 init (with day 2 code)

2022-09-21 09:43:50 +02:00
parent 696273367a
commit f2b32f236d
6 changed files with 350 additions and 0 deletions
--- a/2019/day05/aoc-c.c
+++ b/2019/day05/aoc-c.c
@@ -0,0 +1,150 @@
+/* aoc-c.c: Advent of Code 2019, day 5 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 "debug.h"
+
+typedef enum {
+    ADD = 1,
+    MUL = 2,
+    RET = 99
+} opcode_t;
+
+#define MAXOPS 1024
+struct program {
+    int length;                                   /* total program length */
+    int cur;                                      /* current position */
+    int ops[MAXOPS];                              /* should really be dynamic */
+};
+
+#define OP(p) ((p)->ops + (p)->cur)
+
+#define A1(p) ((p)->ops + *((p)->ops + (p)->cur + 1))
+#define A2(p) ((p)->ops + *((p)->ops + (p)->cur + 2))
+#define A3(p) ((p)->ops + *((p)->ops + (p)->cur + 3))
+
+static int run(struct program *prog)
+{
+    while (1) {
+        opcode_t opcode = *OP(prog);
+        switch (opcode) {
+            case ADD:
+                *A3(prog) = *A1(prog) + *A2(prog);
+                break;
+            case MUL:
+                *A3(prog) = *A1(prog) * *A2(prog);
+                break;
+            case RET:
+                return prog->ops[0];
+            default:
+                fprintf(stderr, "wrong opcode %d at %d.\n", opcode, prog->cur);
+                exit (1);
+        }
+        prog->cur += 4;
+    }
+    return -1;
+}
+
+static struct program *parse()
+{
+    size_t alloc = 0;
+    ssize_t buflen;
+    char *buf = NULL, *token;
+    int input;
+    struct program *prog = NULL;
+
+    if ((buflen = getline(&buf, &alloc, stdin)) <= 0) {
+        fprintf(stderr, "error reading file.\n");
+        goto end;
+    }
+
+    if (!(prog = calloc(1, sizeof(struct program)))) {
+        fprintf(stderr, "cannot allocate program.\n");
+        goto freebuf;
+    }
+    for (token = strtok(buf, ","); token; token = strtok(NULL, ",")) {
+        if (prog->length >= MAXOPS - 1) {
+            fprintf(stderr, "overflow !\n");
+            free(prog);
+            prog = NULL;
+            goto freebuf;
+        }
+        input=atoi(token);
+        prog->ops[prog->length++] = input;
+    }
+freebuf:
+    free(buf);
+end:
+    return prog;
+}
+
+static int part1(struct program *p)
+{
+    p->ops[1] = 12;
+    p->ops[2] = 2;
+
+    return run(p);
+}
+
+static int part2(struct program *p)
+{
+    struct program work;
+
+    for (int noun = 0; noun < 100; ++noun) {
+        for (int verb = 0; verb < 100; ++verb) {
+            work = *p;
+            work.ops[1] = noun;
+            work.ops[2] = verb;
+            if (run(&work) == 19690720)
+                return noun * 100 + verb;
+        }
+    }
+    return -1;
+}
+
+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;
+    struct program *p;
+
+    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);
+    p = parse();
+    printf("%s : res=%d\n", *av, part == 1? part1(p): part2(p));
+    free(p);
+    exit (0);
+}