aocc23

Advent of Code 2023
git clone git://www.tkruger.se/aocc23.git
Log | Files | Refs | README

common.c (2363B)

      1 #include "common.h"
      2 #include "reading.h"
      3 
      4 void print_dict(dict_t *d) {
      5   size_t i, j;
      6 
      7   for (i = 0; i < d->nalloc; i++) {
      8     for (j = 0; j < (d->keys[i]).nmemb; j++) {
      9       printf("%s: ", (d->keys[i]).data[j].data);
     10       size_t x = *((size_t *)(d->values[i]).data[j]);
     11       printf("%llu\n", x);
     12     }
     13   }
     14 }
     15 
     16 static inline size_t cadd(dict_t *d, char *name) {
     17   sd sdname;
     18   sd_init_str(&sdname, name);
     19   void *p = dict_lookup(d, sdname);
     20 
     21   if (p == NULL) {
     22     size_t r = d->nelts;
     23     size_t *v = malloc(sizeof(*v));
     24     *v = r;
     25 
     26     dict_insert(d, sdname, v);
     27 
     28     return r;
     29   }
     30 
     31   return *((size_t *)p);
     32 }
     33 
     34 static inline void parseconds(cond_t *cds, dict_t *d, char *conds, size_t row) {
     35   size_t ncds = 0;
     36   char *ss = strtok(conds, ",");
     37   while (ss != NULL) {
     38     if (strstr(ss, ":")) {
     39       int64_t x;
     40       char *cp = sread_next_i64(&x, ss) + 1;
     41       size_t i = cadd(d, cp);
     42 
     43       cds[ncds].from = row;
     44       cds[ncds].to = i;
     45       switch (ss[0]) {
     46       case 'x':
     47         cds[ncds].entry = 0;
     48         break;
     49       case 'm':
     50         cds[ncds].entry = 1;
     51         break;
     52       case 'a':
     53         cds[ncds].entry = 2;
     54         break;
     55       default:
     56         cds[ncds].entry = 3;
     57       }
     58       cds[ncds].cond = ss[1];
     59       cds[ncds].bound = x;
     60       ncds++;
     61     } else {
     62       cds[ncds].from = row;
     63       cds[ncds].cond = '!';
     64       cds[ncds].bound = -1;
     65       cds[ncds].to = cadd(d, ss);
     66       ncds++;
     67     }
     68     ss = strtok(NULL, ",");
     69   }
     70 }
     71 
     72 stack_u64 *parse(dict_t *d, size_t *nconds, cond_t **r, char **lines,
     73                  size_t nlines) {
     74   size_t i;
     75   for (i = 0; i < nlines; i++) {
     76     if (strlen(lines[i]) < 2)
     77       break;
     78     char *sa = strtok(lines[i], "{}");
     79     size_t row = cadd(d, sa);
     80     char *ss = sa;
     81     while (ss != NULL) {
     82       ss = strtok(NULL, "{}");
     83       parseconds(r[i], d, ss, row);
     84     }
     85   }
     86 
     87   *nconds = i;
     88 
     89   stack_u64 *values = malloc(4 * sizeof(*values));
     90   for (i = 0; i < 4; i++)
     91     stack_u64_init(&values[i]);
     92 
     93   for (i = *nconds + 1; i < nlines; i++) {
     94     char *cp = lines[i];
     95     uint64_t tmp;
     96     cp = sread_next_u64(&tmp, cp);
     97     stack_u64_push(&values[0], tmp);
     98     cp = sread_next_u64(&tmp, cp);
     99     stack_u64_push(&values[1], tmp);
    100     cp = sread_next_u64(&tmp, cp);
    101     stack_u64_push(&values[2], tmp);
    102     cp = sread_next_u64(&tmp, cp);
    103     stack_u64_push(&values[3], tmp);
    104   }
    105 
    106   return values;
    107 }