advent2021

puzzle12.c (4047B)

---

 #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 "util.h"
 
 #define STR_LEN 16384
 #define BOARD_SIZE 5
 
 struct board_t {
 	int tiles[BOARD_SIZE][BOARD_SIZE]; // 0-99 base, -1 marks drawn tiles
 	int rows_sig[BOARD_SIZE]; // sum of numbers that works as a "signature"
 	int cols_sig[BOARD_SIZE]; // once it goes down to -5 it means r/k are done
 	int sum;
 	bool won;
 };
 
 void fill_board(struct board_t *board, int row, const char *str);
 int check_board(struct board_t *board, int num);
 void print_boards(const struct array_t *boards);
 
 /* ****************************************************************** */
 
 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;
 
 	struct array_t numbers = { .data = NULL };
 	struct array_t boards = { .data = NULL };
 
 	array_init(&numbers, sizeof(int), 100);
 	array_init(&boards, sizeof(struct board_t), 10);
 
 	struct board_t *current_board = NULL;
 	int current_row = -1;
 
 	while (fgets(buf, STR_LEN, infile) != NULL) {
 		// first line is always random numbers sequence
 		if (line_num == 0) {
 			parse_numbers_array(&numbers, buf, ",");
 
 		} else if (strlen(buf) == 1) { // line sized 1 is a separator before boards
 			if (boards.count >= boards.cap) {
 				array_expand(&boards);
 			}
 
 			struct board_t *data = (struct board_t *)boards.data;
 			current_board = &data[boards.count++];
 			current_row = 0;
 
 		} else { // filling the board
 			assert(current_board != NULL);
 			assert(current_row != -1);
 			fill_board(current_board, current_row++, buf);
 		}
 
 		++line_num;
 		bzero(buf, STR_LEN);
 	}
 
 	size_t active_boards = boards.count;
 
 	//print_boards(&boards);
 
 	// rolling
 	for (size_t i = 0; i < numbers.count; ++i) {
 		int num = ((int *)numbers.data)[i];
 
 		for (size_t j = 0; j < boards.count; ++j) {
 			struct board_t *board = &((struct board_t *)boards.data)[j];
 			if (board->won) continue;
 
 			int result = check_board(board, num);
 			if (result > 0) {
 				if (active_boards == boards.count) {
 					*result1 = result; // first winning board
 				} else {
 					*result2 = result; // last winning board
 				}
 				--active_boards;
 			}
 		}
 	}
 
 	//print_boards(&boards);
 
 	// mutiny! ignoring feof/ferror.
 	free(numbers.data);
 	free(boards.data);
 	fclose(infile);
 }
 
 /* ************************* BOILERPLATE ************************* */
 
 int check_board(struct board_t *board, int num) {
 	for (int r = 0; r < BOARD_SIZE; ++r) {
 		for (int k = 0; k < BOARD_SIZE; ++k) {
 			if (board->tiles[r][k] == num) {
 				board->tiles[r][k] = -1;
 				board->rows_sig[r] -= num + 1;
 				board->cols_sig[k] -= num + 1;
 				board->sum -= num;
 
 				if (board->rows_sig[r] == -BOARD_SIZE || board->cols_sig[k] == -BOARD_SIZE) {
 					board->won = true;
 					return board->sum * num;
 				}
 			}
 		}
 	}
 
 	return 0;
 }
 
 void print_boards(const struct array_t *boards) {
 	for (size_t i = 0; i < boards->count; ++i) {
 		const struct board_t *brd = (const struct board_t *)boards->data;
 		brd += i;
 		printf("\n----------- board %2zu ------------\n", i);
 		for (int r = 0; r < BOARD_SIZE; ++r) {
 			for (int k = 0; k < BOARD_SIZE; ++k) {
 				printf("[%3d]", brd->tiles[r][k]);
 			}
 			printf(" = [%3d]\n", brd->rows_sig[r]);
 		}
 		printf("=================================\n");
 		for (int k = 0; k < BOARD_SIZE; ++k) {
 			printf("[%3d]", brd->cols_sig[k]);
 		}
 		printf("\n");
 	}
 }
 
 void fill_board(struct board_t *board, int row, const char *str) {
 	char *tmp = strndup(str, STR_LEN);
 	assert(tmp != NULL);
 	char *token = NULL;
 	int col = 0;
 	while ((token = strsep(&tmp, " ")) != NULL) {
 		if (*token != '\0') { // WOWZA
 			int num = atoi(token);
 			board->tiles[row][col] = num;
 			board->rows_sig[row] += num;
 			board->cols_sig[col] += num;
 			board->sum += num;
 			++col;
 		}
 	}
 	assert(col == BOARD_SIZE);
 }