2018 day 13

Author: dannyvankooten

2015-c/02-i-was-told-there-would-be-no-math/main.c

@@ -14,7 +14,7 @@ static inline char *parse(int *dst, char *s) {
   return s;
 }
 
-int compare_ints(const void *ptr_a, const void *ptr_b) {
+static int compare_ints(const void *ptr_a, const void *ptr_b) {
   const int a = *(const int *)ptr_a;
   const int b = *(const int *)ptr_b;
   return (a > b) - (a < b);

2015-c/03-perfectly-spherical-houses-in-a-vacuum/main.c

@@ -9,7 +9,7 @@ typedef struct {
   int8_t y;
 } pos_t;
 
-int solve(const char *s, uint8_t nworkers) {
+static int solve(const char *s, const uint8_t nworkers) {
   int8_t dx, dy;
   uint16_t tally[256 * 256] = {0};
   uint8_t w = 0;

2015-c/17-no-such-thing-as-too-much/main.c

@@ -41,16 +41,10 @@ unsigned int permute(unsigned int sizes[],unsigned int flags, unsigned int i, un
          permute(sizes, flags | 1 << (n - i), i + 1, n);
 }
 
-int qsort_compare_int_desc(const void *ptra, const void *ptrb) {
-  unsigned int a = *(unsigned int *)ptra;
-  unsigned int b = *(unsigned int *)ptrb;
-  if (b < a) {
-    return -1;
-  }
-  if (b > a) {
-    return 1;
-  }
-  return 0;
+static int qsort_compare_int_desc(const void *ptra, const void *ptrb) {
+  const unsigned int a = *(unsigned int *)ptra;
+  const unsigned int b = *(unsigned int *)ptrb;
+  return (b > a) - (b < a);
 }
 
 unsigned int parse(const char *s,unsigned int *dest) {

2015-c/24-it-hangs-in-the-balance/main.c

@@ -15,8 +15,8 @@ static unsigned int parse(const char *s, int weights[]) {
 
 // qsort callback
 static int cmp_ints(const void *p1, const void *p2) {
-  int a = *(int *)p1;
-  int b = *(int *)p2;
+  const int a = *(int *)p1;
+  const int b = *(int *)p2;
   return (a > b) + (a < b);
 }
 

2017-c/02-corruption-checksum/main.c

@@ -4,15 +4,11 @@
 
 static int compare_ints(const void* a, const void* b)
 {
-    int arg1 = *(const int*)a;
-    int arg2 = *(const int*)b;
-
-    if (arg1 < arg2) return -1;
-    if (arg1 > arg2) return 1;
-    return 0;
+    const int ia = *(const int*)a;
+    const int ib = *(const int*)b;
+    return (ia > ib) - (ia < ib);
 }
 
-
 int main(void) {
     clock_t start_t, end_t;
     start_t = clock();

2017-c/04-high-entropy-passphrases/main.c

@@ -1,86 +1,90 @@
-#include <stdlib.h>
 #include <stdio.h>
-#include <time.h>
+#include <stdlib.h>
 #include <string.h>
+#include <time.h>
 
-void read_input_file(char *dest, char *file) {
-    FILE *fp = fopen(file, "r");
-    if (!fp) {
-        fprintf(stderr, "error reading input.txt");
-        exit(EXIT_FAILURE);
-    }
-    size_t nread = fread(dest, 1, 64*1024, fp);
-    dest[nread] = '\0';
-    fclose(fp);
+static void read_input_file(char *dest, const char *file) {
+  FILE *fp = fopen(file, "r");
+  if (!fp) {
+    fprintf(stderr, "error reading input.txt");
+    exit(EXIT_FAILURE);
+  }
+  size_t nread = fread(dest, 1, 64 * 1024, fp);
+  dest[nread] = '\0';
+  fclose(fp);
 }
 
-int validpw(char words[16][32], int nwords) {
-    for (int i = 0; i < nwords; i++) {
-        for (int j = i+1; j < nwords; j++) {
-            if (strcmp(words[i], words[j]) == 0) {
-                return 0;
-            }
-        }
+unsigned int validpw(char words[16][32], const unsigned int nwords) {
+  for (unsigned int i = 0; i < nwords; i++) {
+    for (unsigned int j = i + 1; j < nwords; j++) {
+      if (strcmp(words[i], words[j]) == 0) {
+        return 0;
+      }
     }
-    return 1;
+  }
+  return 1;
 }
 
-int compare_chars(const void* a, const void* b)
-{
-    int arg1 = *(const char*)a;
-    int arg2 = *(const char*)b;
-
-    if (arg1 < arg2) return -1;
-    if (arg1 > arg2) return 1;
-    return 0;
+static int compare_chars(const void *a, const void *b) {
+  const char ca = *(const char *)a;
+  const char cb = *(const char *)b;
+  return (ca > cb) - (ca < cb);
 }
 
-int solve(char *s) {
-    int count = 0;
-    int count_pt2 = 0;
-    char words[16][32];
+static unsigned int solve(const char *s) {
+  unsigned int count = 0;
+  unsigned int count_pt2 = 0;
+  char words[16][32];
 
-    while (*s != '\0') {
-        int nwords = 0;
+  // go over every line
+  while (*s != '\0') {
+    unsigned int nwords = 0;
 
-        while (*s != '\n' && *s != '\0') {
-            char *w = words[nwords++];
-            while (*s != ' ' && *s != '\n') {
-                *w++ = *s++;
-            }
-            *w = '\0';
-            if (*s == ' ') s++;
-        }
 
-        count += validpw(words, nwords);
+    // go over every word in line
+    while (*s != '\n' && *s != '\0' && nwords < 16) {
+      char *w = words[nwords++];
+      unsigned len = 0;
 
-        // for part 2, sort all words alphabetically
-        for (int i = 0; i < nwords; i++) {
-            qsort(words[i], strlen(words[i]), sizeof(char), compare_chars);
-        }
-        count_pt2 += validpw(words, nwords);
+      while (*s != ' ' && *s != '\n' && len < 32) {
+        w[len++] = *s++;
+      }
+      w[len] = '\0';
 
-        if (*s == '\n') s++;
+      if (*s == ' ') {
+        s++;
+      }
     }
 
-    // return both answers in a single 32-bit int
-    return (count_pt2 << 16 ) + count;
+    count += validpw(words, nwords);
+
+    // for part 2, sort all words alphabetically
+    for (unsigned int i = 0; i < nwords; i++) {
+      qsort(words[i], strlen(words[i]), sizeof(char), compare_chars);
+    }
+    count_pt2 += validpw(words, nwords);
+
+    s++;
+  }
+
+  // return both answers in a single 32-bit int
+  return (count_pt2 << 16) + count;
 }
 
-int main() {
-    clock_t start_t, end_t;
-    start_t = clock();
+int main(void) {
+  clock_t start_t, end_t;
+  start_t = clock();
 
-    char input[1024 * 64];
-    read_input_file(input, "input.txt");
+  char input[1024 * 64];
+  read_input_file(input, "input.txt");
 
-    int answers = solve(input);
-    printf("--- Day 4: High-Entropy Passphrases ---\n");
-    printf("Part 1: %d\n", answers & 0xFFFF);
-    printf("Part 2: %d\n", answers >> 16);
+  unsigned int answers = solve(input);
+  printf("--- Day 4: High-Entropy Passphrases ---\n");
+  printf("Part 1: %d\n", answers & 0xFFFF);
+  printf("Part 2: %d\n", answers >> 16);
 
-    end_t = clock();
-    double total_t = (double)(end_t - start_t) / CLOCKS_PER_SEC * 1000;
-    printf("Time: %.2fms\n", total_t);
-    return EXIT_SUCCESS;
+  end_t = clock();
+  double total_t = (double)(end_t - start_t) / CLOCKS_PER_SEC * 1000;
+  printf("Time: %.2fms\n", total_t);
+  return EXIT_SUCCESS;
 }

2018-c/.clangd

@@ -1,2 +1,2 @@
 CompileFlags:
-  Add: [-std=c11, -Wall, -Wextra, -Wpedantic, -Wundef, -Winline, -Wimplicit-fallthrough, -Wformat=2, -Wconversion ]
+  Add: [-std=c17, -Wall, -Wextra, -Wpedantic, -Wundef, -Winline, -Wimplicit-fallthrough, -Wformat=2, -Wconversion ]

2018-c/04.c

@@ -22,8 +22,8 @@ struct guard {
 };
 
 static int log_entry_compare(const void *p1, const void *p2) {
-  struct log_entry *a = (struct log_entry *)p1;
-  struct log_entry *b = (struct log_entry *)p2;
+  const struct log_entry *a = (struct log_entry *)p1;
+  const struct log_entry *b = (struct log_entry *)p2;
 
   if (a->year < b->year) {
     return -1;
@@ -54,7 +54,7 @@ static int log_entry_compare(const void *p1, const void *p2) {
   return 1;
 }
 
-int parse(struct log_entry *log_entries, char *s) {
+static int parse(struct log_entry *log_entries, const char *s) {
   int nentries = 0;
   while (*s != 0x0) {
     struct log_entry *e = &log_entries[nentries++];
@@ -88,7 +88,7 @@ int parse(struct log_entry *log_entries, char *s) {
   return nentries;
 }
 
-struct guard *guard_by_id(struct guard *guards, int nguards, int id) {
+static struct guard *guard_by_id(struct guard *guards, const int nguards, const int id) {
   for (int i = 0; i < nguards; i++) {
     if (guards[i].id == id) {
       return &guards[i];
@@ -98,8 +98,8 @@ struct guard *guard_by_id(struct guard *guards, int nguards, int id) {
   return NULL;
 }
 
-int log_entries_into_guards(struct guard *guards, struct log_entry *entries,
-                            int nentries) {
+static int log_entries_into_guards(struct guard *guards, struct log_entry *entries,
+                            const int nentries) {
   int nguards = 0;
   struct guard *guard = NULL;
 
@@ -129,7 +129,7 @@ int log_entries_into_guards(struct guard *guards, struct log_entry *entries,
   return nguards;
 }
 
-int solve_pt1(struct guard *guards, int nguards) {
+static int solve_pt1(struct guard *guards, const int nguards) {
   struct guard *guard = &guards[0];
 
   for (int i = 0; i < nguards; i++) {
@@ -149,7 +149,7 @@ int solve_pt1(struct guard *guards, int nguards) {
   return answer_pt1;
 }
 
-int solve_pt2(struct guard *guards, int nguards) {
+static int solve_pt2(struct guard *guards, const int nguards) {
   struct guard *guard = &guards[0];
   int max = 0;
 
@@ -170,8 +170,7 @@ int main(void) {
   char input[1024 * 64] = "";
   read_input_file(input, 1024 * 64, "04.txt");
 
-  struct log_entry *log_entries =
-      malloc_or_die(2048 * sizeof(struct log_entry));
+  struct log_entry *log_entries = malloc_or_die(2048 * sizeof(struct log_entry));
   int nentries = parse(log_entries, input);
 
   struct guard *guards = malloc_or_die(512 * sizeof(struct guard));

2018-c/07.c

@@ -49,16 +49,13 @@ static struct step *step_next(struct step **steps, size_t nsteps) {
   return NULL;
 }
 
-int step_compare(const void *p1, const void *p2) {
-  struct step *a = *(struct step **)p1;
-  struct step *b = *(struct step **)p2;
-  if (a->name == b->name) {
-    return 0;
-  }
-  return a->name < b->name ? -1 : 1;
+static int step_compare(const void *p1, const void *p2) {
+  const struct step *a = *(struct step **)p1;
+  const struct step *b = *(struct step **)p2;
+  return (a->name > b->name) - (a->name < b->name);
 }
 
-void pt1(char *buf, struct step **steps, size_t nsteps) {
+static void pt1(char *buf, struct step **steps, const size_t nsteps) {
   char *o = buf;
   while (1) {
     struct step *cur = step_next(steps, nsteps);
@@ -74,8 +71,8 @@ void pt1(char *buf, struct step **steps, size_t nsteps) {
     steps[i]->done = 0;
 }
 
-int pt2(struct step **steps, size_t nsteps) {
-  size_t nworkers = 5;
+static int pt2(struct step **steps, const size_t nsteps) {
+  const size_t nworkers = 5;
   int delay_s = 60;
   int worker_finish_times[nworkers];
   struct step *worker_tasks[nworkers];