From 33ae1b1751a2e080e443a5cf2913b85191f0ef0e Mon Sep 17 00:00:00 2001 From: Bruno Raoult Date: Wed, 15 Dec 2021 20:32:21 +0100 Subject: [PATCH] day 14 part 1 (stupid algorithm) + init part 2 --- 2021/day13/Makefile | 2 +- 2021/day14/README.txt | 11 +++ 2021/day14/aoc-c.c | 196 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 208 insertions(+), 1 deletion(-) create mode 100644 2021/day14/aoc-c.c diff --git a/2021/day13/Makefile b/2021/day13/Makefile index 44a0866..d90d573 100644 --- a/2021/day13/Makefile +++ b/2021/day13/Makefile @@ -24,7 +24,7 @@ LDLIB := -l$(LIB) export LD_LIBRARY_PATH = $(LIBDIR) CFLAGS += -std=gnu99 -#CFLAGS += -O2 +CFLAGS += -O2 CFLAGS += -g CFLAGS += -Wall CFLAGS += -Wextra diff --git a/2021/day14/README.txt b/2021/day14/README.txt index cc2f0a2..bc272be 100644 --- a/2021/day14/README.txt +++ b/2021/day14/README.txt @@ -50,3 +50,14 @@ After step 4: NBBNBNBBCCNBCNCCNBBNBBNBBBNBBNBBCBHCBHHNHCBBCBHCB This polymer grows quickly. After step 5, it has length 97; After step 10, it has length 3073. After step 10, B occurs 1749 times, C occurs 298 times, H occurs 161 times, and N occurs 865 times; taking the quantity of the most common element (B, 1749) and subtracting the quantity of the least common element (H, 161) produces 1749 - 161 = 1588. Apply 10 steps of pair insertion to the polymer template and find the most and least common elements in the result. What do you get if you take the quantity of the most common element and subtract the quantity of the least common element? + +Your puzzle answer was 2712. + +The first half of this puzzle is complete! It provides one gold star: * +--- Part Two --- + +The resulting polymer isn't nearly strong enough to reinforce the submarine. You'll need to run more steps of the pair insertion process; a total of 40 steps should do it. + +In the above example, the most common element is B (occurring 2192039569602 times) and the least common element is H (occurring 3849876073 times); subtracting these produces 2188189693529. + +Apply 40 steps of pair insertion to the polymer template and find the most and least common elements in the result. What do you get if you take the quantity of the most common element and subtract the quantity of the least common element? diff --git a/2021/day14/aoc-c.c b/2021/day14/aoc-c.c new file mode 100644 index 0000000..ba548c6 --- /dev/null +++ b/2021/day14/aoc-c.c @@ -0,0 +1,196 @@ +/* aoc-c.c: Advent of Code 2021, day 14 parts 1 & 2 + * + * Copyright (C) 2021 Bruno Raoult ("br") + * Licensed under the GNU General Public License v3.0 or later. + * Some rights reserved. See COPYING. + * + * You should have received a copy of the GNU General Public License along with this + * program. If not, see . + * + * SPDX-License-Identifier: GPL-3.0-or-later + */ + +#include +#include +#include +#include +#include + +#include "debug.h" +#include "bits.h" +//#include "list.h" + +/* possible 10 letters: B, C, F, H, K, N, O, P, S, V */ +int weight[] = { ['B'] = 0, ['C'] = 1, ['F'] = 2, + ['H'] = 3, ['K'] = 4, ['N'] = 5, ['O'] = 6, + ['P'] = 7, ['S'] = 8, ['V'] = 9 + }; + +int count[26]; +/*struct weigth { + char key; + int val; +} weight1[] = { + { 'A', -1 }, + { 'B', 0 }, + { 'C', 1 }, + { 'D', -1 }, + { 'E', -1 }, + { 'F', 2 }, + { 'G', -1 }, + { 'H', 3 }, + { 'I', -1 }, + { 'J', -1 }, + { 'K', 4 }, + { 'L', -1 }, + { 'M', -1 }, + { 'N', 5 }, + { 'O', 6 }, + { 'P', 7 }, + { 'Q', -1 }, + { 'R', -1 }, + { 'S', 8 }, + { 'T', -1 }, + { 'U', -1 }, + { 'V', 9 }, + { 'W', -1 }, + { 'X', -1 }, + { 'Y', -1 }, + { 'Z', -1 } +}; +*/ +#define MAX_RUN 10 +#define MAX_SIZE 1024 * 10 * 2 /* max resulting string size */ + +char seq[MAX_SIZE], seq2[MAX_SIZE]; +int nseq; + +int rules[10 * 10]; +int nrules; + +/* read data and create graph. + */ +static int read_input() +{ + ssize_t len; + size_t alloc = 0; + char *buf; + char val[10] = { 0 }; + int pos;//, ins; + + nseq = getline(&buf, &alloc, stdin) - 1; + buf[nseq] = 0; + strcpy(seq, buf); + printf("str = %d [%s]\n", nseq, seq); + printf("empt = %ld\n", getline(&buf, &alloc, stdin)); + + /* get rules */ + while ((len = getline(&buf, &alloc, stdin)) > 1) { + //log(3, "len = %d [%s]\n", len, buf); + sscanf(buf, "%c%c -> %c", val, val+1, val+2); + //*val -= 'A'; + //*(val + 1) -= 'A'; + //*(val + 2) -= 'A'; + + pos = weight[(int)*val] * 10 + weight[(int)*(val + 1)]; + //ins = weight[(int)*(val + 2)]; + rules[pos] = *(val + 2); + //log(3, val); + //log(3, "%s : %c %d %c %d %d %d pos=%d\n", val, *val, (int) *val - 'A', val[1], val[1] - 'A', + // weight[(int)*val] * 10, weight[(int)*(val + 1)], pos); + log(3, "%.2s : array[%d]=%c\n", val, pos, rules[pos]); + nrules++; + } + free(buf); + return nrules; +} + +static int part1() +{ + char *src, *dst; + int key;//, last; + unsigned int count[26] = {0}; + unsigned min, max; + + read_input(); + for (int i = 0; i < 10; ++i) { + int j, k; + + src = i % 2? seq2: seq; + dst = i % 2? seq: seq2; + //savedst = dst; + //savesrc = dst; + //last = strlen(src) - 1; + for (j = 0, k = 0; src[j+1]; ++j, k += 2) { + key = weight[(int) src[j]] * 10 + weight[(int) src[j+1]]; + //(*src - 'A') * 10 + *(src+1) -'A'; + //log(3, "%d/%d: src=%s dst=%s s1=%c s2=%c key=%d\n", i, j, src, dst, *src, *(src + 1), key); + dst[k] = src[j]; + dst[k+1] = rules[key]; + dst[k+2] = src[j+1]; + //src++; + //dst += 3; + //log_i(3, "j=%d k=%d dst=%s\n", j, k, dst); + } + log(3, "i = %d len=%d dst = %s\n", i, strlen(dst), dst); + //log(3, "%d: src=%p dst=%p seq=%p seq2=%p\n", src, dst, seq, seq2); + } + for (int i=0; dst[i]; ++i) + count[dst[i] - 'A']++; + min = ~0; + max = 0; + for (unsigned i = 0; i < sizeof(count)/sizeof(*count); ++i) + printf("count[%c]=%d\n", i + 'A', count[i]); + for (unsigned i = 0; i < sizeof(count)/sizeof(*count); ++i) { + if (count[i]) { + if (count[i] < min) + min = count[i]; + if (count[i] > max) + max = count[i]; + } + } + printf("min = %i max=%u\n", min, max); + return max - min; +} + +static int part2() +{ + return 2; +} + +static int doit(int part) +{ + //read_input(); + return part == 1? part1(): part2(); +} + +static int usage(char *prg) +{ + fprintf(stderr, "Usage: %s [-d debug_level] [-p part]\n", prg); + return 1; +} + +int main(int ac, char **av) +{ + int opt, part = 1; + + while ((opt = getopt(ac, av, "d:p:")) != -1) { + switch (opt) { + case 'd': + debug_level_set(atoi(optarg)); + break; + case 'p': /* 1 or 2 */ + part = atoi(optarg); + if (part < 1 || part > 2) + return usage(*av); + break; + default: + return usage(*av); + } + } + if (optind < ac) + return usage(*av); + + printf("%s : res=%d\n", *av, doit(part)); + exit (0); +}