Alchemical Reduction

September 10, 2019

Today’s exercise is from the 2018 Advent of Code, Day 5:

You’ve managed to sneak in to the prototype suit manufacturing lab. The Elves are making decent progress, but are still struggling with the suit’s size reduction capabilities.

While the very latest in 1518 alchemical technology might have solved their problem eventually, you can do better. You scan the chemical composition of the suit’s material and discover that it is formed by extremely long polymers (one of which is available as your puzzle input).

The polymer is formed by smaller units which, when triggered, react with each other such that two adjacent units of the same type and opposite polarity are destroyed. Units’ types are represented by letters; units’ polarity is represented by capitalization. For instance, r and R are units with the same type but opposite polarity, whereas r and s are entirely different types and do not react.

For example:

– In aA, a and A react, leaving nothing behind.

– In abBA, bB destroys itself, leaving aA. As above, this then destroys itself, leaving nothing.

– In abAB, no two adjacent units are of the same type, and so nothing happens.

– In aabAAB, even though aa and AA are of the same type, their polarities match, and so nothing happens.

Now, consider a larger example, dabAcCaCBAcCcaDA:

dabAcCaCBAcCcaDA  The first 'cC' is removed.
dabAaCBAcCcaDA    This creates 'Aa', which is removed.
dabCBAcCcaDA      Either 'cC' or 'Cc' are removed (the result is the same).
dabCBAcaDA        No further actions can be taken.

After all possible reactions, the resulting polymer contains 10 units.

How many units remain after fully reacting the polymer you scanned?

Your task is to write a program that solves the alchemical reduction. When you are finished, you are welcome to read or run a suggested solution, or to post your own solution or discuss the exercise in the comments below.

Advertisements

Pages: 1 2

6 Responses to “Alchemical Reduction”

  1. Zack said

    Nifty little exercise. Not sure if it qualifies as alchemy, but it’s definitely a nice challenge. Here is my take using Julia 1.1: https://pastebin.com/DE53t8nw
    Cheers!

  2. Zack said

    There was a bug in my previous attempt (a cool exercise in itself!) so here is the refined code: https://pastebin.com/5yddm5CJ
    Cheers!

  3. chaw said

    Here’s a simple solution in R7RS Scheme, focusing on clarity. The
    imports are all trivial.

    (import (scheme base)
            (scheme write)
            (only (scheme char)
                  char-ci=?))
    
    (define (alchemical-reduction str)
      (let loop ((unseen (string->list str))
                 (seen '()))
        (if (null? unseen)
            (apply string (reverse seen))
            (loop (cdr unseen)
                  (if (and (pair? seen)
                           (pair? unseen)
                           (and (char-ci=? (car seen)
                                           (car unseen))
                                (not (char=? (car seen)
                                             (car unseen)))))
                      (cdr seen)
                      (cons (car unseen) seen))))))
    
    (display (alchemical-reduction "dabAcCaCBAcCcaDA"))
    (newline)
    

    dabCBAcaDA
    

  4. Graham said

    My Haskell solution relies mostly on a single

    foldr

    :

    module Main where
    
    import Data.Char (isLetter, toLower)
    
    react :: String -> String
    react = foldr step ""
     where
      step x (y : ys) | x /= y && toLower x == toLower y = ys
      step x ys       = x : ys
    
    part1 :: String -> Int
    part1 = length . react
    
    part2 :: String -> Int
    part2 s = minimum $ fmap (length . react . remove) ['a' .. 'z']
      where remove c = filter ((/= c) . toLower) (react s) -- save recomputation
    
    main :: IO ()
    main = do
      input <- filter isLetter <$> readFile "input"
      print . part1 $ input
      print . part2 $ input
    

    Regarding blog posts, I really like the elegance of this one, which shows this is just an exercise in group theory.

  5. matthew said

    Here’s a little C++ solution, doing in-place modification of a 0-terminated char array.

    #include <stdio.h>
    #include <string.h>
    
    char *transform(char *s) {
      int n = strlen(s);
      for (int i = 1, j = 1; i <= n; i++) {
        if (j && (s[i]^s[j-1]) == 0x20) j--;
        else s[j++] = s[i];
      }
      return s;
    }
    
    int main(int argc, char *argv[]) {
      printf("%s\n", transform(argv[1]));
    }
    

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: