AdventOfCode C 2024 day 8

#include <stdio.h>
#include <stdbool.h>
#define WIDTH 50
#define SIZE 250


struct point_t {
    int x;
    int y;
};

typedef struct point_t Point;

struct antenna_t {
    Point point;
    char type;
};
typedef struct antenna_t Antenna;

Point distance(Point point1, Point point2) {
    int x = point1.x - point2.x;
    int y = point1.y - point2.y;
    Point res = { x,y };
    return res;
}

Point add(Point point1, Point point2) {
    int x = point1.x + point2.x;
    int y = point1.y + point2.y;
    Point res = { x,y };
    return res;
}

bool in_range(Point point) {
    return point.x >= 0 && point.x < WIDTH && point.y >= 0 && point.y < WIDTH;
}

/**
 * @brief Parse input
 * @note
 * @param  file: The file to parse
 * @param  antennas: The array to put the antennas in
 * @retval How many antennas were found
 */
int parse(FILE* file, Antenna* antennas) {
    int index = 0;
    int y = 0;
    int x = 0;
    char val;
    while ((val = fgetc(file)) != EOF) {
        if (val == '\n') {
            // End of this string of values
            y++;
            x = -1;
        }
        else if (val != '.' && val != '#') {
            Antenna temp = { x, y, val };
            printf("Antenna found at %d, %d: %c\n", x, y, val);
            antennas[index] = temp;
            index++;
        }
        x++;
    }
    return index;
}

void print_map(Antenna* antennas, int antenna_size, Point* points, int point_size) {
    char items[WIDTH + 1][WIDTH];
    for (size_t i = 0; i < WIDTH; i++) {
        for (size_t j = 0; j < WIDTH; j++) {
            items[i][j] = '.';
        }
        items[i][WIDTH] = '\n';
    }
    for (size_t i = 0; i < point_size; i++) {
        Point point = *(points + i);
        items[point.y][point.x] = '#';
    }
    for (size_t i = 0; i < antenna_size; i++) {
        Antenna antenna = *(antennas + i);
        items[antenna.point.y][antenna.point.x] = antenna.type;
    }
    for (size_t i = 0; i < WIDTH; i++) {
        for (size_t j = 0; j < WIDTH; j++) {
            printf("%c", items[i][j]);
            /* code */
        }
        printf("\n");
    }
}

/**
 * @brief  Get the antinodes for these antenna, according to part 1
 * @note
 * @param  antenna1: The first antenna
 * @param  antenna2: The second antenna
 * @param  save_place: The location to put the point(s)
 * @retval How many hotspots were found in range
 */
int get_hotspots_p1(Antenna* antenna1, Antenna* antenna2, Point* save_place) {
    printf("Hotspots between %d,%d and %d, %d: ", antenna1->point.x, antenna1->point.y, antenna2->point.x, antenna2->point.y);
    if (antenna1->type != antenna2->type) {
        printf("0\n");
        return 0;
    }
    int index = 0;
    Point dist = distance(antenna1->point, antenna2->point);
    Point hotspot_1 = add(antenna1->point, dist);
    if (in_range(hotspot_1)) {
        printf(" (%d,%d)", hotspot_1.x, hotspot_1.y);
        *save_place = hotspot_1;
        index++;
    }
    Point neg_dist = { -dist.x, -dist.y };
    Point hotspot_2 = add(antenna2->point, neg_dist);
    if (in_range(hotspot_2)) {
        printf(" (%d,%d)", hotspot_2.x, hotspot_2.y);
        *(save_place + index) = hotspot_2;
        index++;
    }
    printf("\n");
    return index;
}

int part_one(Antenna* antennas, int size) {
    Point points[SIZE * 2];
    int index = 0;
    // Compare all,
    for (size_t i = 0; i < size; i++) {
        Antenna* antenna1 = antennas + i;
        int same = 0;
        int found = 0;
        for (size_t j = 0; j < size; j++) {
            if (i == j) {
                continue;
            }
            Antenna* antenna2 = antennas + j;
            if (antenna1->type != antenna2->type) {
                continue;
            }
            same++;
            if (j <= i) {
                continue;
            }
            int addition = get_hotspots_p1(antenna1, antenna2, points + index);
            index += addition;
            found += addition;
        }
        if (same == 0) {
            printf("%c only has 1 antenna on the map\n", antenna1->type);
            // It's the only one of it's type. That means a antinode is at it's point.
            points[index] = antenna1->point;
            index++;
        }
        printf("%c (%d,%d) has %d resonance spots\n", antenna1->type, antenna1->point.x, antenna1->point.y, found);
    }
    // Filter them into unique points;
    Point uniques[SIZE * 2];
    int unique_index = 0;
    for (size_t i = 0; i < index; i++) {
        Point known = *(points + i);
        bool found = false;
        for (size_t j = 0; j < unique_index; j++) {
            Point unique = *(uniques + j);
            if (known.x == unique.x && known.y == unique.y) {
                found = true;
                break;
            }
        }
        if (!found) {
            uniques[unique_index] = known;
            unique_index++;
        }
    }
    print_map(antennas, size, uniques, unique_index);
    return unique_index;
}

/**
 * @brief  Get the antinodes for these antenna, according to part 1
 * @note
 * @param  antenna1: The first antenna
 * @param  antenna2: The second antenna
 * @param  save_place: The location to put the point(s)
 * @retval How many hotspots were found in range
 */
int get_hotspots_p2(Antenna* antenna1, Antenna* antenna2, Point* save_place) {
    printf("Hotspots between %d,%d and %d, %d:", antenna1->point.x, antenna1->point.y, antenna2->point.x, antenna2->point.y);
    if (antenna1->type != antenna2->type) {
        printf("0\n");
        return 0;
    }
    int index = 0;
    Point dist = distance(antenna1->point, antenna2->point);
    Point neg_dist = { -dist.x, -dist.y };

    Point hotspot_1 = add(antenna1->point, dist);
    while (in_range(hotspot_1)) {
        // Go to the first extreme edge
        hotspot_1 = add(hotspot_1, dist);
    };
    hotspot_1 = add(hotspot_1, neg_dist);
    printf(" start %d,%d", hotspot_1.x, hotspot_1.y);
    while (in_range(hotspot_1)) {
        printf(" (%d,%d)", hotspot_1.x, hotspot_1.y);
        *(save_place + index) = hotspot_1;
        index++;
        hotspot_1 = add(hotspot_1, neg_dist);
    };

    printf("\n");
    return index;
}

int part_two(Antenna* antennas, int size) {
    Point points[SIZE * 10];
    int index = 0;
    // Compare all,
    for (size_t i = 0; i < size; i++) {
        Antenna* antenna1 = antennas + i;
        int same = 0;
        int found = 0;
        for (size_t j = 0; j < size; j++) {
            if (i == j) {
                continue;
            }
            Antenna* antenna2 = antennas + j;
            if (antenna1->type != antenna2->type) {
                continue;
            }
            same++;
            if (j <= i) {
                continue;
            }
            int addition = get_hotspots_p2(antenna1, antenna2, points + index);
            index += addition;
            found += addition;
        }
        if (same == 0) {
            printf("%c only has 1 antenna on the map\n", antenna1->type);
            // It's the only one of it's type. That means a antinode is at it's point.
            points[index] = antenna1->point;
            index++;
        }
        printf("%c (%d,%d) has %d resonance spots\n", antenna1->type, antenna1->point.x, antenna1->point.y, found);
    }
    // Filter them into unique points;
    Point uniques[SIZE * 10];
    int unique_index = 0;
    for (size_t i = 0; i < index; i++) {
        Point known = *(points + i);
        bool found = false;
        for (size_t j = 0; j < unique_index; j++) {
            Point unique = *(uniques + j);
            if (known.x == unique.x && known.y == unique.y) {
                found = true;
                break;
            }
        }
        if (!found) {
            uniques[unique_index] = known;
            unique_index++;
        }
    }
    print_map(antennas, size, uniques, unique_index);
    return unique_index;
}

int main() {
    FILE* ptr = fopen("2024-8.txt", "r");
    Antenna antennas[SIZE];
    int size = parse(ptr, antennas);
    printf("%d antennas found!\n", size);
    printf("Part one: %d\n", part_one(antennas, size));
    printf("Part two: %d\n", part_two(antennas, size));
}

//1085: too low