feat: day05 c (#8)

Author: martabal

.gitignore

@@ -3,4 +3,5 @@
 .vscode
 /build
 /perf
-Makefile
+Makefile
+.reponse

README.md

@@ -15,4 +15,4 @@ Ideally, the solution does not use external crates/dependencies.
 |   2   |   ✅    |   ✅    |   ✅    |   ✅    |   ✅    |   ✅    |
 |   3   |   ✅    |   ✅    |   ✅    |   ✅    |   ✅    |   ✅    |
 |   4   |   ✅    |   ✅    |   ✅    |   ✅    |   ✅    |   ✅    |
-|   5   |   ✅    |   ✅    |   ✅    |   ✅    |   ❌    |   ❌    |
+|   5   |   ✅    |   ✅    |   ✅    |   ✅    |   ✅    |   ✅    |

c/day03.c

@@ -80,7 +80,7 @@ static SizeVector create_size_vector(size_t initial_capacity) {
 
 static void push_back(SizeVector *vec, size_t value) {
   if (vec->size == vec->capacity) {
-    vec->capacity = (vec->capacity * 3) / 2; // 1.5x growth
+    vec->capacity = (vec->capacity * 3) / 2;
     vec->data = realloc(vec->data, vec->capacity * sizeof(size_t));
   }
   vec->data[vec->size++] = value;

c/day04.c

@@ -3,14 +3,12 @@
 #include <stdlib.h>
 #include <string.h>
 
-// Structure to hold the grid
 typedef struct {
   char **data;
   size_t rows;
   size_t cols;
 } Grid;
 
-// Function to read the file and return a Grid structure
 Grid read_file(const char *filename) {
   FILE *file = fopen(filename, "r");
   if (!file) {
@@ -23,14 +21,12 @@ Grid read_file(const char *filename) {
   size_t len = 0;
 
   while (getline(&line, &len, file) != -1) {
-    // Allocate memory for new row
     grid.data = realloc(grid.data, (grid.rows + 1) * sizeof(char *));
     grid.data[grid.rows] = strdup(line);
     grid.rows++;
 
-    // Update columns count if necessary
     if (grid.rows == 1) {
-      grid.cols = strlen(line) - 1; // Exclude newline
+      grid.cols = strlen(line) - 1;
     }
   }
 
@@ -40,16 +36,6 @@ Grid read_file(const char *filename) {
   return grid;
 }
 
-// Floored division implementation
-int floored_division(int a, int b) {
-  int quotient = a / b;
-  if ((a % b != 0) && ((a < 0) != (b < 0))) {
-    return quotient - 1;
-  }
-  return quotient;
-}
-
-// Count occurrences of a word in all directions in the grid
 size_t count_word(const Grid *grid, const char *word) {
   size_t count = 0;
   int word_len = strlen(word);
@@ -85,7 +71,6 @@ size_t count_word(const Grid *grid, const char *word) {
   return count;
 }
 
-// Count occurrences of an X-pattern in the grid
 size_t count_x_pattern(const Grid *grid, const char *word) {
   if (grid->rows == 0) {
     fprintf(stderr, "Grid must be a valid grid\n");
@@ -94,10 +79,9 @@ size_t count_x_pattern(const Grid *grid, const char *word) {
 
   size_t count = 0;
   int word_len = strlen(word);
-  int bounded = floored_division(word_len, 2);
+  int bounded = word_len / 2;
   char middle_char = word[bounded];
 
-  // Reverse the word
   char *reverse_word = strdup(word);
   for (int i = 0; i < word_len / 2; i++) {
     char temp = reverse_word[i];
@@ -174,11 +158,11 @@ void free_grid(Grid *grid) {
 int main() {
   Grid grid = read_file("crates/day04/input.txt");
 
-  // Part One
+  // --- Part One ---
   size_t count = count_word(&grid, "XMAS");
   printf("%zu\n", count);
 
-  // Part Two
+  // --- Part Two ---
   count = count_x_pattern(&grid, "MAS");
   printf("%zu\n", count);
 

c/day05.c

@@ -0,0 +1,264 @@
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct Rule {
+  int key;
+  int *values;
+  int value_count;
+};
+
+struct PrintQueueChecker {
+  struct Rule *rules;
+  int rule_count;
+  int **page_numbers;
+  int *page_numbers_sizes;
+  int page_numbers_count;
+};
+
+static struct Rule *find_rule(struct PrintQueueChecker *checker, int key) {
+  for (int i = 0; i < checker->rule_count; i++) {
+    if (checker->rules[i].key == key) {
+      return &checker->rules[i];
+    }
+  }
+  return NULL;
+}
+
+static bool find_value_in_array(const int *arr, int size, int start_idx,
+                                int value) {
+  for (int i = start_idx; i < size; i++) {
+    if (arr[i] == value) {
+      return true;
+    }
+  }
+  return false;
+}
+
+static bool check_valid(const struct PrintQueueChecker *checker,
+                        const int *order, int order_size) {
+  for (int idx = 0; idx < order_size; idx++) {
+    struct Rule *rule =
+        find_rule((struct PrintQueueChecker *)checker, order[idx]);
+    if (rule == NULL)
+      continue;
+
+    for (int j = 0; j < rule->value_count; j++) {
+      if (find_value_in_array(order, order_size, idx, rule->values[j])) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+static void parse_puzzle(struct PrintQueueChecker *checker,
+                         const char *puzzle) {
+  checker->rule_count = 0;
+  checker->page_numbers_count = 0;
+
+  checker->rules = (struct Rule *)malloc(sizeof(struct Rule) * 2000);
+  for (int i = 0; i < 2000; i++) {
+    checker->rules[i].values = (int *)malloc(sizeof(int) * 500);
+  }
+
+  checker->page_numbers = (int **)malloc(sizeof(int *) * 500);
+  checker->page_numbers_sizes = (int *)malloc(sizeof(int) * 500);
+
+  char line[2048];
+  const char *puzzle_ptr = puzzle;
+  int line_start = 0;
+  int line_end = 0;
+
+  while (puzzle_ptr[line_end] != '\0') {
+    if (puzzle_ptr[line_end] == '\n' || puzzle_ptr[line_end] == '\0') {
+      if (line_end - line_start == 0) {
+        puzzle_ptr += line_end - line_start + 1;
+        line_start = 0;
+        line_end = 0;
+        break;
+      }
+
+      strncpy(line, puzzle_ptr + line_start, line_end - line_start);
+      line[line_end - line_start] = '\0';
+
+      char *delimiter = strchr(line, '|');
+      if (delimiter != NULL) {
+        *delimiter = '\0';
+        int left = atoi(line);
+        int right = atoi(delimiter + 1);
+
+        struct Rule *rule = find_rule(checker, right);
+        if (rule == NULL) {
+          rule = &checker->rules[checker->rule_count++];
+          rule->key = right;
+          rule->value_count = 0;
+        }
+        rule->values[rule->value_count++] = left;
+      }
+
+      puzzle_ptr += line_end - line_start + 1;
+      line_start = 0;
+      line_end = 0;
+      continue;
+    }
+    line_end++;
+  }
+
+  while (*puzzle_ptr != '\0') {
+    while (*puzzle_ptr == '\n')
+      puzzle_ptr++;
+    if (*puzzle_ptr == '\0')
+      break;
+
+    int *current_order = (int *)malloc(sizeof(int) * 100);
+    int current_size = 0;
+
+    while (*puzzle_ptr != '\n' && *puzzle_ptr != '\0') {
+      char number_str[20] = {0};
+      int i = 0;
+
+      while (*puzzle_ptr != ',' && *puzzle_ptr != '\n' && *puzzle_ptr != '\0') {
+        number_str[i++] = *puzzle_ptr++;
+      }
+
+      current_order[current_size++] = atoi(number_str);
+
+      if (*puzzle_ptr == ',')
+        puzzle_ptr++;
+    }
+
+    checker->page_numbers[checker->page_numbers_count] = current_order;
+    checker->page_numbers_sizes[checker->page_numbers_count] = current_size;
+    checker->page_numbers_count++;
+
+    if (*puzzle_ptr == '\n')
+      puzzle_ptr++;
+  }
+}
+
+static int check_page_order(const struct PrintQueueChecker *checker) {
+  int sum = 0;
+  for (int i = 0; i < checker->page_numbers_count; i++) {
+    if (check_valid(checker, checker->page_numbers[i],
+                    checker->page_numbers_sizes[i])) {
+      sum += checker->page_numbers[i][checker->page_numbers_sizes[i] / 2];
+    }
+  }
+  return sum;
+}
+
+static void clone_array(const int *source, int *dest, int size) {
+  memcpy(dest, source, size * sizeof(int));
+}
+
+static int check_and_sort_page_order(const struct PrintQueueChecker *checker) {
+  int sum = 0;
+  int *order_clone = (int *)malloc(sizeof(int) * 100);
+
+  for (int i = 0; i < checker->page_numbers_count; i++) {
+    const int *order = checker->page_numbers[i];
+    int order_size = checker->page_numbers_sizes[i];
+
+    if (!check_valid(checker, order, order_size)) {
+      clone_array(order, order_clone, order_size);
+
+      while (!check_valid(checker, order_clone, order_size)) {
+        bool found_rule_break = false;
+        int old_idx = 0;
+        int new_idx = 0;
+        int replace_val = 0;
+
+        for (int idx = 0; idx < order_size && !found_rule_break; idx++) {
+          struct Rule *rule =
+              find_rule((struct PrintQueueChecker *)checker, order_clone[idx]);
+          if (rule == NULL)
+            continue;
+
+          for (int check_idx = order_size - 1; check_idx >= idx; check_idx--) {
+            for (int rule_idx = 0; rule_idx < rule->value_count; rule_idx++) {
+              if (order_clone[check_idx] == rule->values[rule_idx]) {
+                new_idx = check_idx;
+                found_rule_break = true;
+                old_idx = idx;
+                replace_val = order_clone[idx];
+                break;
+              }
+            }
+            if (found_rule_break)
+              break;
+          }
+        }
+
+        if (found_rule_break) {
+          for (int j = old_idx; j < order_size - 1; j++) {
+            order_clone[j] = order_clone[j + 1];
+          }
+          for (int j = order_size - 1; j > new_idx; j--) {
+            order_clone[j] = order_clone[j - 1];
+          }
+          order_clone[new_idx] = replace_val;
+        }
+      }
+      sum += order_clone[order_size / 2];
+    }
+  }
+
+  free(order_clone);
+  return sum;
+}
+
+static char *read_file(const char *filename) {
+  FILE *file = fopen(filename, "r");
+  if (file == NULL) {
+    fprintf(stderr, "Unable to open file: %s\n", filename);
+    exit(1);
+  }
+
+  fseek(file, 0, SEEK_END);
+  long file_size = ftell(file);
+  rewind(file);
+
+  char *buffer = (char *)malloc(file_size + 1);
+  if (buffer == NULL) {
+    fclose(file);
+    fprintf(stderr, "Memory allocation failed\n");
+    exit(1);
+  }
+
+  size_t read_size = fread(buffer, 1, file_size, file);
+  buffer[read_size] = '\0';
+
+  fclose(file);
+  return buffer;
+}
+
+static void free_print_queue_checker(struct PrintQueueChecker *checker) {
+  for (int i = 0; i < checker->rule_count; i++) {
+    free(checker->rules[i].values);
+  }
+  free(checker->rules);
+  for (int i = 0; i < checker->page_numbers_count; i++) {
+    free(checker->page_numbers[i]);
+  }
+  free(checker->page_numbers);
+  free(checker->page_numbers_sizes);
+}
+
+int main() {
+  char *message = read_file("crates/day05/input.txt");
+  struct PrintQueueChecker checker = {0};
+
+  parse_puzzle(&checker, message);
+
+  // --- Part One ---
+  printf("Part One solution: %d\n", check_page_order(&checker));
+
+  // --- Part Two ---
+  printf("Part Two solution: %d\n", check_and_sort_page_order(&checker));
+
+  free_print_queue_checker(&checker);
+  free(message);
+  return 0;
+}