adventofcode2023/day13/c/day13.c

#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;
}