advent2021

puzzle.c (5426B)

---

 #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 <stdbool.h>
 #include <math.h>
 #include <unistd.h>
 
 #include "util.h"
 
 #define STR_LEN 1024
 
 struct cmd_t {
 	enum ins_t {INP, ADD, MUL, DIV, MOD, EQL} instruction;
 	int reg1;
 	int reg2;
 	int op2;
 };
 
 struct input_t {
 	int digits[14];
 	int current;
 };
 
 void parse_command(struct array_t *commands, char *str);
 int get_register(char name);
 int exec_cmd(struct cmd_t *cmd, int (*registers)[5], struct input_t *input);
 
 int exec_inp(struct cmd_t *cmd, int (*registers)[5], struct input_t *input);
 int exec_add(struct cmd_t *cmd, int (*registers)[5]);
 int exec_mul(struct cmd_t *cmd, int (*registers)[5]);
 int exec_div(struct cmd_t *cmd, int (*registers)[5]);
 int exec_mod(struct cmd_t *cmd, int (*registers)[5]);
 int exec_eql(struct cmd_t *cmd, int (*registers)[5]);
 
 int read_input(struct input_t *input);
 struct input_t make_input(uint64_t number);
 bool valid_input(struct input_t *input);
 bool validate_number(struct array_t *commands, uint64_t num);
 
 void puzzle(const char *filename, long long *result1, long long *result2) {
 	FILE *infile = fopen(filename, "r");
 	if (infile == NULL) {
 		fprintf(stderr, "fopen() error: %s\n", strerror(errno));
 		return;
 	}
 
 	char buf[STR_LEN] = {0};
 	struct array_t commands = { .data = NULL };
 	array_init(&commands, sizeof(struct cmd_t), 10);
 
 	while (fgets(buf, STR_LEN, infile) != NULL) {
 		parse_command(&commands, buf);
 		bzero(buf, STR_LEN);
 	}
 
 	uint64_t max_num = 94992992796199;
 	uint64_t min_num = 11931881141161;
 
 	if (validate_number(&commands, max_num)) {
 		*result1 = max_num;
 	}
 
 	if (validate_number(&commands, min_num)) {
 		*result2 = min_num;
 	}
 
 	// mutiny! ignoring feof/ferror.
 	fclose(infile);
 }
 
 bool validate_number(struct array_t *commands, uint64_t num) {
 	struct input_t input = make_input(num);
 	if (valid_input(&input)) {
 		int registers[5] = {0};
 		for (size_t k = 0; k < commands->count; ++k) {
 			struct cmd_t *cmd = &((struct cmd_t *)commands->data)[k];
 			exec_cmd(cmd, &registers, &input);
 		}
 		return registers[4] == 0;
 	}
 	return false;
 }
 
 void parse_command(struct array_t *commands, char *str) {
 	assert(commands != NULL);
 	assert(str != NULL);
 	int len = strlen(str);
 	assert(len >= 5);
 	if (commands->count >= commands->cap) array_expand(commands);
 
 	struct cmd_t *cmd = &((struct cmd_t *)commands->data)[commands->count++];
 	if (strncmp(str, "inp", 3) == 0) {
 		cmd->instruction = INP;
 	} else if (strncmp(str, "add", 3) == 0) {
 		cmd->instruction = ADD;
 	} else if (strncmp(str, "mul", 3) == 0) {
 		cmd->instruction = MUL;
 	} else if (strncmp(str, "div", 3) == 0) {
 		cmd->instruction = DIV;
 	} else if (strncmp(str, "mod", 3) == 0) {
 		cmd->instruction = MOD;
 	} else if (strncmp(str, "eql", 3) == 0) {
 		cmd->instruction = EQL;
 	} else {
 		printf("invalid instruction %s", str);
 		exit(1);
 	}
 
 	cmd->reg1 = get_register(str[4]);
 	assert(cmd->reg1 != 0);
 
 	if (len < 7) {
 		return;
 	}
 
 	if (str[6] >= 'a' && str[6] <= 'z') {
 		cmd->reg2 = get_register(str[6]);
 	} else {
 		cmd->op2 = atoi(str+6);
 	}
 }
 
 int get_register(char name) {
 	switch (name) {
 		case 'w': return 1;
 		case 'x': return 2;
 		case 'y': return 3;
 		case 'z': return 4;
 		default:  return 0;
 	}
 }
 
 int read_input(struct input_t *input) {
 	return input->digits[input->current++];
 }
 
 struct input_t make_input(uint64_t num) {
 	struct input_t input = {0};
 	for (int i = 0; i < 14; ++i) {
 		uint64_t mod = num % 10;
 		num /= 10;
 		input.digits[13-i] = mod;
 	}
 	return input;
 }
 
 bool valid_input(struct input_t *input) {
 	for (int i = 0; i < 14; ++i) {
 		if (input->digits[i] == 0) {
 			return false;
 		}
 	}
 	return true;
 }
 
 int exec_cmd(struct cmd_t *cmd, int (*registers)[5], struct input_t *input) {
 	assert(cmd != NULL);
 	assert(registers != NULL);
 
 	switch (cmd->instruction) {
 		case INP: return exec_inp(cmd, registers, input);
 		case ADD: return exec_add(cmd, registers);
 		case MUL: return exec_mul(cmd, registers);
 		case DIV: return exec_div(cmd, registers);
 		case MOD: return exec_mod(cmd, registers);
 		case EQL: return exec_eql(cmd, registers);
 	}
 }
 
 int exec_inp(struct cmd_t *cmd, int (*registers)[5], struct input_t *input) {
 	assert(cmd != NULL);
 	(*registers)[cmd->reg1] = read_input(input);
 	return (*registers)[cmd->reg1];
 }
 
 int exec_add(struct cmd_t *cmd, int (*registers)[5]) {
 	assert(cmd != NULL);
 	int r = cmd->reg2 > 0 ? (*registers)[cmd->reg2] : cmd->op2;
 	(*registers)[cmd->reg1] += r;
 	return (*registers)[cmd->reg1];
 }
 
 int exec_mul(struct cmd_t *cmd, int (*registers)[5]) {
 	assert(cmd != NULL);
 	int r = cmd->reg2 > 0 ? (*registers)[cmd->reg2] : cmd->op2;
 	(*registers)[cmd->reg1] *= r;
 	return (*registers)[cmd->reg1];
 }
 
 int exec_div(struct cmd_t *cmd, int (*registers)[5]) {
 	assert(cmd != NULL);
 	int r = cmd->reg2 > 0 ? (*registers)[cmd->reg2] : cmd->op2;
 	(*registers)[cmd->reg1] /= r;
 	return (*registers)[cmd->reg1];
 }
 
 int exec_mod(struct cmd_t *cmd, int (*registers)[5]) {
 	assert(cmd != NULL);
 	int r = cmd->reg2 > 0 ? (*registers)[cmd->reg2] : cmd->op2;
 	(*registers)[cmd->reg1] %= r;
 	return (*registers)[cmd->reg1];
 
 }
 
 int exec_eql(struct cmd_t *cmd, int (*registers)[5]) {
 	assert(cmd != NULL);
 	int r = cmd->reg2 > 0 ? (*registers)[cmd->reg2] : cmd->op2;
 	(*registers)[cmd->reg1] = ((*registers)[cmd->reg1] == r) ? 1 : 0;
 	return (*registers)[cmd->reg1];
 }