advent2021

puzzle.c (4907B)

---

 #define _DEFAULT_SOURCE
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <string.h>
 #include <strings.h>
 #include <assert.h>
 #include <ctype.h>
 #include <limits.h>
 #include <stdbool.h>
 
 #include "util.h"
 
 #define STR_LEN 128
 
 struct point_t {
 	int x;
 	int y;
 };
 
 struct fold_t {
 	int x;
 	int y;
 };
 
 void parse_point(struct array_t *points, const char *str);
 void parse_fold(struct array_t *folds, const char *str);
 void print_points(struct array_t *points);
 struct point_t flip_point(const struct point_t point, const struct point_t fold);
 void add_point(struct array_t *points, struct point_t point);
 void draw_points(const struct array_t *points);
 
 void puzzle(const char *filename) {
 	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;
 
 	struct array_t points = { .data = NULL };
 	array_init(&points, sizeof(struct point_t), 10);
 	struct array_t folds = { .data = NULL };
 	array_init(&folds, sizeof(struct fold_t), 10);
 
 	bool folds_started = false;
 	while (fgets(buf, STR_LEN, infile) != NULL) {
 		if (strlen(buf) == 1) {
 			folds_started = true;
 			continue;
 		}
 
 		if (folds_started) {
 			parse_fold(&folds, buf);
 		} else {
 			parse_point(&points, buf);
 		}
 
 		++line_num;
 		bzero(buf, STR_LEN);
 	}
 
 	for (size_t f = 0; f < folds.count; ++f) {
 		struct array_t points_folded = { .data = NULL };
 		array_init(&points_folded, sizeof(struct point_t), 10);
 
 		struct point_t fold = ((struct point_t *)folds.data)[f];
 
 		for (size_t i = 0; i < points.count; ++i) {
 			const struct point_t *data = points.data;
 			add_point(&points_folded, flip_point(data[i], fold));
 		}
 
 		if (f == 0) {
 			printf("Puzzle #1: %zu\n", points_folded.count);
 		}
 
 		// copy folded points over old ones
 		free(points.data);
 		points.data = points_folded.data;
 		points.cap = points_folded.cap;
 		points.count = points_folded.count;
 	}
 
 	printf("Puzzle #2:\n");
 	draw_points(&points);
 
 	// mutiny! ignoring feof/ferror.
 	fclose(infile);
 }
 
 struct point_t flip_point(const struct point_t point, const struct point_t fold) {
 	struct point_t p1 = point;
 	if (fold.x > 0 && point.x > fold.x) {
 		p1.x = 2 * fold.x - point.x;
 	} else if (fold.y > 0 && point.y > fold.y) {
 		p1.y = 2 * fold.y - point.y;
 	}
 	return p1;
 }
 
 void add_point(struct array_t *points, struct point_t point) {
 	assert(points != NULL);
 	struct point_t *data = points->data;
 	for (size_t i = 0; i < points->count; ++i) {
 		if (data[i].x == point.x && data[i].y == point.y) {
 			return;
 		}
 	}
 
 	if (points->count >= points->cap) {
 		array_expand(points);
 	}
 	data = points->data;
 	data[points->count++] = point;
 }
 
 void parse_point(struct array_t *points, const char *str) {
 	assert(points != NULL);
 	assert(str != NULL);
 	char *tmp = strndup(str, STR_LEN);
 	assert(tmp != NULL);
 	char *token = NULL;
 
 	int numbers[2] = {0};
 	int i = 0;
 	while ((token = strsep(&tmp, ",\n")) != NULL) {
 		if (*token != '\0') {
 			assert(i < 2);
 			numbers[i] = atoi(token);
 			++i;
 		}
 	}
 
 	if (points->count >= points->cap) {
 		array_expand(points);
 	}
 
 	struct point_t *data = points->data;
 	data[points->count++] = (struct point_t){ .x=numbers[0], .y=numbers[1] };
 }
 
 void parse_fold(struct array_t *folds, const char *str) {
 	assert(folds != NULL);
 	assert(str != NULL);
 	char *tmp = strndup(str, STR_LEN);
 	assert(tmp != NULL);
 	char *token = NULL;
 
 	int i = 0;
 	int is_x = -1; // 0 is y, 1 is x
 	struct point_t fold = {0};
 	while ((token = strsep(&tmp, "=\n")) != NULL) {
 		if (*token != '\0') {
 			assert(i < 2);
 			if (is_x == -1) {
 				size_t len = strlen(token);
 				// we're just taking last character and checking if it is 'x'
 				is_x = token[len-1] == 'x';
 			} else if (is_x == 0) {
 				fold.y = atoi(token);
 			} else if (is_x == 1) {
 				fold.x = atoi(token);
 			} else {
 				assert(0 == 1);
 			}
 			++i;
 		}
 	}
 
 	if (folds->count >= folds->cap) {
 		array_expand(folds);
 	}
 
 	struct point_t *data = folds->data;
 	data[folds->count++] = fold;
 }
 
 void print_points(struct array_t *points) {
 	assert(points != NULL);
 	struct point_t *data = points->data;
 	for (size_t i = 0; i < points->count; ++i) {
 		printf("x: %2d, y: %2d\n", data[i].x, data[i].y);
 	}
 }
 
 void draw_points(const struct array_t *points) {
 	assert(points != NULL);
 	const struct point_t *data = points->data;
 	int x_max = 0;
 	int y_max = 0;
 	for (size_t i = 0; i < points->count; ++i) {
 		x_max = data[i].x > x_max ? data[i].x : x_max;
 		y_max = data[i].y > y_max ? data[i].y : y_max;
 	}
 	x_max += 1;
 	y_max += 1;
 
 	char *buffer = malloc(x_max * y_max);
 	memset(buffer, ' ', x_max * y_max);
 
 	for (size_t i = 0; i < points->count; ++i) {
 		buffer[data[i].y * x_max + data[i].x] = '#';
 	}
 
 	for (int y = 0; y < y_max; ++y) {
 		for (int x = 0; x < x_max; ++x) {
 			printf("%c", buffer[y*x_max + x]);
 		}
 		printf("\n");
 	}
 
 	free(buffer);
 }