advent2021

puzzle.c (4955B)

---

 #define _DEFAULT_SOURCE
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <string.h>
 #include <strings.h>
 #include <stdbool.h>
 #include <assert.h>
 #include <time.h>
 
 #include "util.h"
 
 #define STR_LEN 16384
 #define MAP_SIZE 1000
 
 // being tad lazy here - assume that the map sides are no larger than MAP_SIZE
 static short map1[MAP_SIZE][MAP_SIZE];
 static short map2[MAP_SIZE][MAP_SIZE];
 
 struct vec2_t {
 	int x;
 	int y;
 };
 
 struct vec2_pair_t {
 	struct vec2_t a;
 	struct vec2_t b;
 };
 
 // I'll try to push stack values back and forth to see how it impacts performance
 struct vec2_pair_t make_pair(const char *str);
 struct vec2_t make_vec2(const char *str);
 void swap_vec2(struct vec2_t *a, struct vec2_t *b); // swap a and b
 void print_pair(const struct vec2_pair_t *pair);
 bool is_pair_diagonal(const struct vec2_pair_t *pair);
 void normalize_pair(struct vec2_pair_t *pair); // ensure begin is always smaller number
 int mark_map1(const struct vec2_pair_t *pair);
 int mark_map2(const struct vec2_pair_t *pair);
 void print_map();
 
 /* ****************************************************************** */
 
 void puzzle(const char *filename, int *result1, int *result2) {
 	FILE *infile = fopen(filename, "r");
 	if (infile == NULL) {
 		fprintf(stderr, "fopen() error: %s\n", strerror(errno));
 		return;
 	}
 
 	char buf[STR_LEN] = {0};
 	unsigned int line_num = 0;
 
 	*result1 = 0;
 	*result2 = 0;
 
 	while (fgets(buf, STR_LEN, infile) != NULL) {
 		struct vec2_pair_t pair = make_pair(buf);
 		// only straight and 45deg diagonal lines
 		if (pair.a.x == pair.b.x || pair.a.y == pair.b.y || is_pair_diagonal(&pair)) {
 			normalize_pair(&pair);
 			*result1 += mark_map1(&pair);
 			*result2 += mark_map2(&pair);
 		}
 
 		++line_num;
 		bzero(buf, STR_LEN);
 	}
 
 	//print_map();
 
 	// mutiny! ignoring feof/ferror.
 	fclose(infile);
 }
 
 struct vec2_pair_t make_pair(const char *str) {
 	char *tmp = strndup(str, STR_LEN);
 	char *token = NULL;
 	struct vec2_pair_t pair = {0};
 	struct vec2_t *vectors[2] = { &pair.a, &pair.b };
 	int count = 0;
 
 	assert(tmp != NULL);
 
 	while ((token = strsep(&tmp, " ->\n")) != NULL) {
 		if (*token != '\0') {
 			assert(count < 2);
 			*vectors[count++] = make_vec2(token);
 		}
 	}
 
 	free(tmp);
 	return pair;
 }
 
 struct vec2_t make_vec2(const char *str) {
 	struct vec2_t vec2 = {0};
 	char *tmp = strndup(str, STR_LEN);
 	char *token = NULL;
 	assert(tmp != NULL);
 	int *coords[2] = { &vec2.x, &vec2.y };
 	int count = 0;
 
 	while ((token = strsep(&tmp, ",")) != NULL) {
 		if (*token != '\0') {
 			assert(count < 2);
 			int val = atoi(token);
 			assert(val < MAP_SIZE);
 			*coords[count++] = val;
 		}
 	}
 
 	return vec2;
 }
 
 void swap_vec2(struct vec2_t *a, struct vec2_t *b) {
 	struct vec2_t tmp = *a;
 	*a = *b;
 	*b = tmp;
 }
 
 void print_pair(const struct vec2_pair_t *pair) {
 	printf("%d,%d -> %d,%d\n", pair->a.x, pair->a.y, pair->b.x, pair->b.y);
 }
 
 void print_map() {
 	printf("\n--------MAP-----------\n");
 	for (int y = 0; y < MAP_SIZE; ++y) {
 		for (int x = 0; x < MAP_SIZE; ++x) {
 			if (map2[x][y] == 0) {
 				printf(".");
 			} else {
 				printf("%d", map2[x][y]);
 			}
 		}
 		printf("\n");
 	}
 	printf("\n-----------------------\n");
 }
 
 bool is_pair_diagonal(const struct vec2_pair_t *pair) {
 	return abs(pair->a.x - pair->b.x) == abs(pair->a.y - pair->b.y);
 }
 
 void normalize_pair(struct vec2_pair_t *pair) {
 	if (pair->a.x == pair->b.x && pair->a.y > pair->b.y) {
 		// straight verticals
 		swap_vec2(&pair->a, &pair->b);
 	} else if (pair->a.y == pair->b.y && pair->a.x > pair->b.x) {
 		// straight horizontals
 		swap_vec2(&pair->a, &pair->b);
 	} else if (is_pair_diagonal(pair) && pair->a.x > pair->b.x) {
 		// normalize diagonals only by x axis
 		swap_vec2(&pair->a, &pair->b);
 	}
 }
 
 int mark_map1(const struct vec2_pair_t *pair) {
 	int count = 0;
 
 	if (pair->a.x == pair->b.x) { // vertical lines
 		int x = pair->a.x;
 		for (int y = pair->a.y; y <= pair->b.y; ++y) {
 			if (++map1[x][y] == 2) {
 				++count;
 			}
 		}
 	} else if (pair->a.y == pair->b.y) { // horizontal lines
 		int y = pair->a.y;
 		for (int x = pair->a.x; x <= pair->b.x; ++x) {
 			if (++map1[x][y] == 2) {
 				++count;
 			}
 		}
 	}
 
 	return count;
 }
 
 int mark_map2(const struct vec2_pair_t *pair) {
 	int count = 0;
 
 	if (pair->a.x == pair->b.x) { // vertical lines
 		int x = pair->a.x;
 		for (int y = pair->a.y; y <= pair->b.y; ++y) {
 			if (++map2[x][y] == 2) {
 				++count;
 			}
 		}
 	} else if (pair->a.y == pair->b.y) { // horizontal lines
 		int y = pair->a.y;
 		for (int x = pair->a.x; x <= pair->b.x; ++x) {
 			if (++map2[x][y] == 2) {
 				++count;
 			}
 		}
 	} else if (is_pair_diagonal(pair)) { // diagonal lines
 		int x = pair->a.x;
 		int y = pair->a.y;
 		if (pair->a.y < pair->b.y) {
 			for (; x <= pair->b.x && y <= pair->b.y;) {
 				if (++map2[x][y] == 2) {
 					++count;
 				}
 				++x;
 				++y;
 			}
 		} else {
 			for (; x <= pair->b.x && y >= pair->b.y;) {
 				if (++map2[x][y] == 2) {
 					++count;
 				}
 				++x;
 				--y;
 			}
 		}
 	}
 
 	return count;
 }