Day13 C

day13/c/day13.c

@@ -0,0 +1,171 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define LINE_MAX_LENGTH 256
+#define MAX_PATTERNS 256
+#define min(a,b) ((a) < (b) ? (a) : (b))
+
+typedef enum tile {
+    ASH,
+    ROCK,
+} tile_t;
+
+typedef struct pattern {
+    tile_t map[LINE_MAX_LENGTH][LINE_MAX_LENGTH];
+    int x;
+    int y;
+} pattern_t;
+
+int symmetric(pattern_t *patterns, int patterns_num);
+
+int main() {
+    char *p, *buf, c;
+
+    buf = (char *)malloc(LINE_MAX_LENGTH);
+    memset(buf, 0, LINE_MAX_LENGTH);
+    p = buf;
+
+    pattern_t *patterns;
+    patterns = (pattern_t*)malloc(MAX_PATTERNS * sizeof(pattern_t));
+    memset(patterns, 0, MAX_PATTERNS * sizeof(pattern_t));
+    int x = 0, y = 0, patterns_num = 0;
+
+    while ((c = getchar()) != EOF) {
+        *p++ = c;
+        if (c == '\n') {
+            p = buf;
+
+            if (*p == '\n') {
+                patterns[patterns_num].x = x;
+                patterns[patterns_num].y = y;
+                patterns_num++;
+                y = 0;
+                memset(buf, 0, LINE_MAX_LENGTH);
+                continue;
+            }
+
+            x = 0;
+            while (*p != '\n') {
+                switch (*p) {
+                    case '.':
+                        patterns[patterns_num].map[x][y] = ASH;
+                        break;
+                    case '#':
+                        patterns[patterns_num].map[x][y] = ROCK;
+                        break;
+                }
+                x++;
+                p++;
+            }
+            y++;
+            memset(buf, 0, LINE_MAX_LENGTH);
+            p = buf;
+        }
+    }
+
+    int part1 = symmetric(patterns, patterns_num);
+    printf("%i\n", part1);
+
+    int part2 = 0;
+    int symmetric_offset = 0;
+    for (int i = 0; i < patterns_num; i++) {
+        for (int j = 1; j < patterns[i].x; j++) {
+            int mind = min(j, patterns[i].x - j);
+            symmetric_offset = 0;
+            for (int k = 0; k < mind; k++) {
+                for (int l = 0; l < patterns[i].y; l++) {
+                    if (patterns[i].map[j - k - 1][l] != patterns[i].map[j + k][l]) {
+                        symmetric_offset++;
+                    }
+                }
+            }
+
+            if (symmetric_offset == 1) {
+                part2 += j;
+                break;
+            }
+        }
+
+        if (symmetric_offset == 1) {
+            continue;
+        }
+
+        for (int j = 1; j < patterns[i].y; j++) {
+            int mind = min(j, patterns[i].y - j);
+            symmetric_offset = 0;
+            for (int k = 0; k < mind; k++) {
+                for (int l = 0; l < patterns[i].x; l++) {
+                    if (patterns[i].map[l][j - k - 1] != patterns[i].map[l][j + k]) {
+                        symmetric_offset++;
+                    }
+                }
+            }
+
+            if (symmetric_offset == 1) {
+                part2 += 100 * j;
+                break;
+            }
+        }
+    }
+
+    printf("%i\n", part2);
+
+    free(buf);
+    free(patterns);
+}
+
+int symmetric(pattern_t *patterns, int patterns_num) {
+    int sum = 0;
+    int symmetric = 1;
+    for (int i = 0; i < patterns_num; i++) {
+        for (int j = 1; j < patterns[i].x; j++) {
+            int mind = min(j, patterns[i].x - j);
+            symmetric = 1;
+            for (int k = 0; k < mind; k++) {
+                for (int l = 0; l < patterns[i].y; l++) {
+                    if (patterns[i].map[j - k - 1][l] != patterns[i].map[j + k][l]) {
+                        symmetric = 0;
+                        break;
+                    }
+                }
+                if (!symmetric) {
+                    break;
+                }
+            }
+
+            if (symmetric) {
+                sum += j;
+                break;
+            }
+        }
+
+        if (symmetric) {
+            continue;
+        }
+
+        for (int j = 1; j < patterns[i].y; j++) {
+            int mind = min(j, patterns[i].y - j);
+            symmetric = 1;
+
+            for (int k = 0; k < mind; k++) {
+                for (int l = 0; l < patterns[i].x; l++) {
+                    if (patterns[i].map[l][j - k - 1] != patterns[i].map[l][j + k]) {
+                        symmetric = 0;
+                        break;
+                    }
+                }
+                if (!symmetric) {
+                    break;
+                }
+            }
+
+            if (symmetric) {
+                sum += 100 * j;
+                break;
+            }
+        }
+    }
+
+    return sum;
+}

day13/sample.txt

@@ -0,0 +1,16 @@
+#.##..##.
+..#.##.#.
+##......#
+##......#
+..#.##.#.
+..##..##.
+#.#.##.#.
+
+#...##..#
+#....#..#
+..##..###
+#####.##.
+#####.##.
+..##..###
+#....#..#
+