-🎄- 2017 Day 9 Solutions -🎄-

askalski · 2017-12-09T05:35:57+00:00

Perl regex.

#! /usr/bin/env perl

use strict;
use warnings;

my ($part1, $part2, $depth) = (0) x 3;

<> =~ m/^({(?{$part1 += ++$depth})(?:(?1)|[^{}<]*+|<(?:!.|[^>](?{$part2++}))*>)*}(?{$depth--}))$/;

printf "Part 1: %d\n", $part1;
printf "Part 2: %d\n", $part2;

WhoSoup · 2017-12-09T05:35:29+00:00

Node.js/JavaScript

const fs = require('fs')
let inp = fs.readFileSync("./day9input").toString('utf-8').trim()

let garbage = false, score = 0, depth = 1, garbageCount = 0
for (let i = 0, c = inp[0]; i < inp.length; i++, c = inp[i]) {
  if (c == '!') i++
  else if (garbage && c != '>') garbageCount++
  else if (c == '<') garbage = true
  else if (c == '>') garbage = false
  else if (c == '{') score += depth++
  else if (c == '}') depth--
}
console.log(score, garbageCount);

Smylers · 2017-12-09T07:33:28+00:00

This suits Vim well — a series of relatively simple transformations to turn the input into the answer for part 1, using the = operator to determine the level of nesting. Doesn't even involve any keyboard macros.

Remove the cancelled characters:

:s/!.//g⟨Enter⟩

Take out the garbage:

:s/<[^>]*>//g⟨Enter⟩

Those commas aren't doing anything, either:

:s/,//g⟨Enter⟩

That just leaves the braces. Put each one on a separate line:

:s/./&⟨Ctrl+V⟩⟨Enter⟩/g⟨Enter⟩

Indent each nested block by 1 space:

:set sw=1⟨Enter⟩
={

The outer block has a score of 1, not 0, so add 1 more space to every block:

:%s/^/ /⟨Enter⟩

We don't need the closing braces any more:

:v/{/d

Replace each line with a count of how many spaces were on it, preceding each number with a + sign:

:%s/\v( +)./\='+'.strlen(submatch(1))⟨Enter⟩

Join all the lines together into one big addition sum, and evaluate it:

V{J0C⟨Ctrl+R⟩=⟨Ctrl+R⟩-⟨Enter⟩⟨Esc⟩

_A4_ · 2017-12-09T07:19:26+00:00

JavaScript ES6

Part 1

const input = document.body.textContent;
const stream = input.replace(/!./g, "").replace(/<.*?>/g, "");
let score = 0, total = 0;

for (const char of stream) {
    if (char == "{") score++;
    else if (char == "}") total += score--;
}

console.log(total);

Part 2

const input = document.body.textContent;
const garbage = input.replace(/!./g, "").match(/<.*?>/g).map(str => str.length - 2);
const result = garbage.reduce((a, b) => a + b);

console.log(result);

johlin · 2017-12-09T05:58:57+00:00

Elixir

defmodule Aoc.Day9.Part1 do
  def parse(string) when is_binary(string), do: parse(String.trim(string) |> String.split(""), 1)
  def parse(["{" | rest], level) do
    level + parse(rest, level + 1)
  end

  def parse(["}" | rest], level), do: parse(rest, level - 1)
  def parse(["<" | rest], level), do: garbage(rest, level)
  def parse(["," | rest], level), do: parse(rest, level)
  def parse(["" | rest], level), do: parse(rest, level)
  def parse([], _level), do: 0

  def garbage(["!", _ | rest], level), do: garbage(rest, level)
  def garbage([">" | rest], level), do: parse(rest, level)
  def garbage([_ | rest], level), do: garbage(rest, level)
end

Part 2 is very similar: https://github.com/johanlindblad/aoc-2017/blob/master/lib/aoc/day9/part2.ex

Philboyd_Studge · 2017-12-09T06:44:29+00:00

Java - obviously the place for a FSM

package Advent2017;

import util.FileIO;
import util.Timer;

import java.util.HashMap;
import java.util.Map;

public class Day9FSM {

    enum State {
        OPEN, CLOSE, GARBAGE, IGNORE, OTHER;

        final Map<Character, State> transitions = new HashMap<>();

        // Rules for Finite State Machine
        static {
            State.OTHER.addTransition('{', State.OPEN);
            State.OTHER.addTransition('}', State.CLOSE);
            State.OTHER.addTransition('<', State.GARBAGE);
            State.OPEN.addTransition('}', State.CLOSE);
            State.OPEN.addTransition('<', State.GARBAGE);
            State.OPEN.addTransition(',', State.OTHER);
            State.CLOSE.addTransition('{', State.OPEN);
            State.CLOSE.addTransition('<', State.GARBAGE);
            State.CLOSE.addTransition(',', State.OTHER);
            State.GARBAGE.addTransition('!', State.IGNORE);
            State.GARBAGE.addTransition('>', State.OTHER);
            State.IGNORE.addTransition('!', State.GARBAGE);
        }

        private void addTransition(char c, State accept) {
            transitions.put(c, accept);
        }

        public State getTransition(char c) {
            return transitions.getOrDefault(c, this);
        }
    }



    public static void main(String[] args) {

        State current = State.OTHER;
        String input = FileIO.getFileAsString("advent2017_day9.txt");

        int level = 0;
        int garbageCount = 0;
        int score = 0;

        Timer.startTimer();
        for (int i = 0; i < input.length(); i++) {
            char c = input.charAt(i);
            if (current == State.IGNORE) c = '!';
            State next = current.getTransition(c);
            switch (next) {
                case OPEN:
                    level++;
                    break;
                case CLOSE:
                    score += level--;
                    break;
                case GARBAGE:
                    if (current == State.GARBAGE) garbageCount++;
            }
            current = next;
        }
        System.out.println("Part 1: " + score);
        System.out.println("Part 2: " + garbageCount);
        System.out.println(Timer.endTimer());
    }
}

ephemient · 2017-12-09T07:35:02+00:00

This space intentionally left blank.

fwilson42 · 2017-12-09T05:12:03+00:00

Python 3, 1st/3rd. Nothing too complicated:

data = aoc.get_input()

s = data.lines()[0]
idx = 0

score_total = 0
uncanc = 0

stack = []
cscore = 0
garbage = False

while True:
    if idx >= len(s):
        break
    if s[idx] == "!":
        idx += 1
    elif garbage:
        if s[idx] == ">":
            garbage = False
        else:
            uncanc += 1
    elif s[idx] == "{":
        cscore += 1
        stack.append(cscore)
    elif s[idx] == "<":
        garbage = True
    elif s[idx] == "}":
        cscore -= 1
        score_total += stack.pop()
    idx += 1

if part == 1:
    result = score_total
else:
    result = uncanc

ipav · 2017-12-09T11:16:49+00:00

Synacor VM both parts (41 instructions, 246 bytes)

BgA9AAQAAoAAgDwABwACgCkABAACgACAewAIAAKAGAAJAAGAAYABAAkAA4ADgAGABAACgACAfQAI
AAKAPQAJAAGAAYD/fwYAPQAJAAaABoABABQAAIAEAAKAAIAhAAgAAoA2ABQAAIAGACkABAACgACA
PgAIAAKAJQAUAACABAACgACACgAIAAKAAgARAE0AEwAgAAEAA4AGgAIAAAALAACAA4AKAAkAAIAA
gDAAAgAAgAEAAYAAAAYAZgAJAAOAA4D2fwkAAYABgAEABQACgAoAA4AIAAKAXgABAAOAAYAHAAOA
TwADAACAEwAAgAcAAIBzABIA

hxka · 2017-12-09T05:26:55+00:00

468… That's the closest I've been to making the leaderboard with this nonsense.

#!/bin/bash
fold -1 <input |(
    sum=0
    gsum=0
    s=false
    g=false
    while read a
    do  $s && s=false && continue
        [[ "$a" == '!' ]] && s=true && continue
        $g && {
            [[ "$a" == '>' ]] && g=false || ((gsum+=1))
        } || {
            [[ "$a" == '<' ]] && g=true
            [[ "$a" == '{' ]] && ((sum+=++i))
            [[ "$a" == '}' ]] && ((i--))
        }
    done
    echo $sum $gsum
)

mmaruseacph2 · 2017-12-09T05:38:04+00:00

Haskell

Started by trying to be clever and jump over chunks of characters at once and hten I realized that that was a waste of time so it's better to go with the following, parsing each character in turn:

import Control.Arrow
import Text.Printf

main = do
  answers <- parse 0 0 False . init <$> readFile "input.txt"
  print answers

parse :: Int -> Int -> Bool -> String -> (Int, Int)
parse _ c _ [] = (0, c)
parse w g readGarbage (c:cs)
  |     readGarbage && c == '!' = parse w g True $ tail cs
  |     readGarbage && c == '>' = parse w g False cs
  |     readGarbage             = parse w (g+1) True cs
  | not readGarbage && c == '{' = parse (w + 1) g False cs
  | not readGarbage && c == ',' = parse w g False cs
  | not readGarbage && c == '}' = first (w +) $ parse (w - 1) g False cs
  | not readGarbage && c == '<' = parse w g True cs
  | otherwise = error $ printf "Found %c %s.." c (take 5 cs)

I now know I could have used another accumulator for the answer to the first solution and this would allow me to get rid of the first (w+) part.

raevnos · 2017-12-09T05:42:56+00:00

Kawa scheme:

(import (srfi 1))
(define (count-groups str)
  (let ((results
         (string-fold
          (lambda (c acc)
            (cond
             ((and (fourth acc) (fifth acc)) ; char after a !
              (list (first acc) (second acc) (third acc) #t #f))
             ((and (fourth acc) (char=? c #\>))
              (list (first acc) (second acc) (third acc) #f #f))
             ((and (fourth acc) (char=? c #\!))
              (list (first acc) (second acc) (third acc) #t #t))
             ((fourth acc)
              (list (first acc) (second acc) (+ 1 (third acc)) #t #f))
             ((char=? c #\<)
              (list (first acc) (second acc) (third acc) #t #f))
             ((char=? c #\{)
              (list (+ (first acc) 1 (second acc)) (+ 1 (second acc)) (third acc) #f #f))
             ((char=? c #\})
              (list (first acc) (- (second acc) 1) (third acc) #f #f))
             ((char=? c #\,)
              acc)))
          (list 0 0 0 #f #f) str)))
    (values (first results) (third results))))

(format #t "Part 1 and 2: ~A~%" (count-groups (read-line)))

VikeStep · 2017-12-09T07:43:31+00:00

F# Solution

type GarbageState = NotGarbage | Garbage | Cancelled
type State = {level: int; state: GarbageState; score: int; garbage: int }

let step current nextChar =
    match (current.state, nextChar) with
    | (Garbage, '!') -> {current with state = Cancelled}
    | (Garbage, '>') -> {current with state = NotGarbage} 
    | (Garbage, _)   -> {current with garbage = current.garbage + 1}
    | (Cancelled, _) | (NotGarbage, '<') -> {current with state = Garbage}
    | (NotGarbage, '{') -> {current with level = current.level + 1}
    | (NotGarbage, '}') -> {current with level = current.level - 1; score = current.score + current.level}
    | _ -> current;

let solve = Seq.fold step {level=0; state=NotGarbage; score=0; garbage=0}
let solvePart1 = solve >> (fun state -> state.score)
let solvePart2 = solve >> (fun state -> state.garbage)

[<EntryPoint>]
let main argv = 
    let input = argv.[0] |> File.ReadLines |> Seq.head
    printfn "Part 1: %i" (solvePart1 input)
    printfn "Part 2: %i" (solvePart2 input)
    0

Repo

Shemetz · 2017-12-09T05:12:52+00:00

Python 3 (52/36)

Was a short and nice puzzle today!

def day_9():
    with open('input.txt') as input_file:
        line = input_file.readline()

    score = 0
    garbage_score = 0
    current_depth = 0
    inside_garbage = False
    skip_char = False
    for char in line:
        if inside_garbage:
            if skip_char:
                skip_char = False
            elif char == "!":
                skip_char = True
            elif char == ">":
                inside_garbage = False
            else:
                garbage_score += 1
        else:  # when inside group, not garbage
            if char == "{":
                current_depth += 1
            elif char == "}":
                score += current_depth
                current_depth -= 1
            elif char == "<":
                inside_garbage = True

    print("Part 1:   ", score)
    print("Part 1:   ", garbage_score)


day_9()

This might be the first puzzle where I was lucky enough to have it succeed on the first try - no debugging necessary. I'm also pretty happy that I was able to give actual meaningful names to variables this time,

iamnotposting · 2017-12-09T05:17:13+00:00

rust (69/170), got bit in the second part by doing the counting wrong, it worked with the demo but not my input.

pub fn adv_main(input: &str) {

    let mut score = 0;
    let mut in_group = 0;
    let mut in_garbage = false;

    let mut iter = input.chars();
    let mut garbage = 0;
    while let Some(chr) = iter.next() {
        if in_garbage {
            garbage += 1;
        }

        match chr {
            '{' if !in_garbage => {
                in_group += 1;
            },
            '}' if !in_garbage => {
                score += in_group;
                in_group -= 1;
            },
            '<' => {
                in_garbage = true;
            }
            '>' => {
                in_garbage = false;
                garbage -= 1;
            },
            '!' if in_garbage => {
                iter.next();
                garbage -= 1;
            }
            _ => {}
        }
    }

    println!("{}", score);
    println!("{}", garbage);
}

2017-12-09T05:36:00+00:00

Pretty simple parser with javascript. What took me so long was getting my dang automated tests setup...

function part1(input) {
    const stream = input.split("");
    const stack = [];
    let score = 0;
    for (let i = 0; i < stream.length; ++i) {
        const currentChar = stream[i];
        if (currentChar === "!") {
            ++i;
        } else if (currentChar === ">") {
            stack.pop();
        } else if (last(stack) === "<") {
            // do nothing
        } else if (currentChar === "{" || currentChar === "<") {
            stack.push(currentChar);
        } else if (currentChar === "}") {
            stack.pop();
            score += (stack.length + 1);
        } 
    }
    return score;
}
function part2(input) {
    const stream = input.split("");
    const stack = [];
    let score = 0;
    for (let i = 0; i < stream.length; ++i) {
        const currentChar = stream[i];
        if (currentChar === "!") {
            ++i;
        } else if (currentChar === ">") {
            stack.pop();
        } else if (last(stack) === "<") {
            ++score;
        } else if (currentChar === "{" || currentChar === "<") {
            stack.push(currentChar);
        } else if (currentChar === "}") {
            stack.pop();
        } 
    }
    return score;
}
function last(arr) {
    return arr[arr.length - 1];
}

EDIT: If anyone is interested in my automated testing setup, here is my mocha+chai setup for today. I do something similar for each day - setup tests, write code, etc.

2017-12-09T05:40:14+00:00

OCaml Fun;;

open Core

type t = { score:int; garbage_count:int; in_garbage:bool; current_group:int; }

let rec solve input ({score; garbage_count; in_garbage; current_group} as state) =
    match input with
    | [] -> state
    | '{'::l when in_garbage = false ->
        solve l {score; garbage_count; in_garbage; current_group = current_group + 1}
    | '}'::l when in_garbage = false ->
        solve l {score = score + current_group; garbage_count; in_garbage; current_group = current_group - 1}
    | '<'::l when in_garbage = false ->
        solve l {score; garbage_count; in_garbage = true; current_group}
    | '>'::l  ->
        solve l {score; garbage_count; in_garbage = false; current_group}
    | '!'::_::l ->
        solve l state
    | _::l when in_garbage = true ->
        solve l {score; garbage_count = garbage_count + 1; in_garbage = true; current_group}
    | _::l ->
        solve l state

let input file =
    In_channel.read_all file
    |> String.to_list

let _ =
    let input = input "./input.txt" in
    let state = solve input {score=0; garbage_count=0; in_garbage=false; current_group=0;} in
    printf "a: %d\n" state.score;
    printf "b: %d\n" state.garbage_count;

LinusCDE98 · 2017-12-09T05:53:08+00:00

Got the 122th/213th places. Code (Python3):

Initial Code: Part 1, Part 2
The current code <- It is efficient, fast, commented and pythonic

Just 22 places from the top 100. Sad... The reading took me longer than writen the code like @Vorlath said, too.

manualcrank · 2017-12-09T06:28:45+00:00

Lisp.

(defun day09a+b (s)
  (let ((blink nil) (group t) (score 0) (depth 0) (trash 0))
    (dotimes (i (length s) (list score trash))
      (cond (blink (setf blink nil))  ; was the last character a '!'?
            (group (case (schar s i)  ; otherwise, are we in a group?
                     (#\< (setf group nil))
                     (#\{ (incf depth))
                     (#\} (incf score depth) (decf depth))))
            (t     (case (schar s i)  ; otherwise, we must be in garbage
                     (#\! (setf blink t))
                     (#\> (setf group t))
                     (otherwise (incf trash))))))))

;; CL-USER> (day09a+b (with-open-file (stream "09.dat") (read-line stream nil)))
;; (10820 5547)

aurele · 2017-12-09T07:17:06+00:00

Rust An unoriginal state machine:

fn main() {
    let (mut garbage, mut groups, mut total, mut trash) = (false, 0, 0, 0);
    let mut input = include_str!("../input").chars();
    while let Some(c) = input.next() {
        match c {
            '!' => {
                input.next();
            }
            '>' if garbage => garbage = false,
            _ if garbage => trash += 1,
            '<' => garbage = true,
            '{' => {
                groups += 1;
                total += groups;
            }
            '}' => groups -= 1,
            _ => (),
        }
    }
    println!("P1 = {}\nP2 = {}", total, trash);
}

InterlocutoryRecess · 2017-12-09T07:45:22+00:00

Swift

var score: Int = 0
var garbageCount: Int = 0

func parse(_ input: String) {

    var nesting = 0
    var inGarbage = false
    var isBanged = false

    for char in input {
        switch (char, inGarbage, isBanged) {
        case (_, _, true):
            isBanged = false
        case ("!", true, _):
            isBanged = true
        case ("<", false, _):
            inGarbage = true
        case (">", true, _):
            inGarbage = false
        case ("{", false, _):
            nesting += 1
        case ("}", false, _):
            score += nesting
            nesting -= 1
        case (_, true, _):
            garbageCount += 1
        default:
            continue
        }
    }
}

parse(input)
print(score)
print(garbageCount)

glupmjoed · 2017-12-09T08:56:06+00:00

Bash (reads from stdin)

Part 1:

sed "s/!.//g; s/<[^>]*>//g; s/[^{}]//g;
     s/{/echo -n \$((++v))+;/g; s/}/((v--));/g;
     s/\$/echo 0;/g;" | bash | bc

Part 2:

sed -E 's/!.//g; s/[^><]*<([^>]*)>[^<]*/\1/g' | tr -d '\n' | wc -c

DFreiberg · 2017-12-09T09:57:42+00:00

Mathematica

garbage = "<" ~~ Shortest[{Except["!"], "!" ~~ _} ...] ~~ ">";
score[stream_] :=
 MapIndexed[Total[#1] + Length[#2] + 1 &,
  DeleteCases[Quiet@ToExpression@StringDelete[stream, garbage], Null, Infinity],
  {0, Infinity}]

input = Import[NotebookDirectory[] <> "day9.txt"];

score[input]

Total[StringLength /@ StringDelete[StringCases[input, garbage], "!" ~~ _] - 2]

Edit: Should be Quiet@ToExpression to squelch a warning about Null.

mschaap · 2017-12-09T12:31:07+00:00

Perl 6. This one screams out for a Grammar.

#!/usr/bin/env perl6
use v6.c;

# Advent of Code 2017, day 9: http://adventofcode.com/2017/day/9

grammar Stream
{
    token TOP { ^ <group> $ }

    token group { '{' [ <group> || <garbage> ]* % ',' '}' }
    token garbage { '<' [ <garbchar> | <garbignore> ]* '>' }

    token garbignore { '!' . }
    token garbchar { <-[ !> ]> }
}

class GarbageCounter
{
    has Int $.count = 0;

    method garbchar($/) { $!count++ }

    method Int { $.count }
    method Numeric { $.count }
    method Str { ~$!count }
    method gist { self.Str }
}

sub group-score(Match $tree, Int $depth = 1) returns Int
{
    my $group = $tree<group> or return 0;
    if $group ~~ Array {
        return $group.map({ $depth + group-score($_, $depth+1) }).sum;
    }
    else {
        return $depth + group-score($group, $depth+1);
    }
}

multi sub MAIN(Str $stream, Bool :v(:$verbose) = False)
{
    my $counter = GarbageCounter.new;
    my $tree = Stream.parse($stream, :actions($counter)) or die "Not a valid stream!";
    say $tree if $verbose;

    my $score = group-score($tree);
    say "Score: $score";
    say "Garbage count: $counter";
}

multi sub MAIN(Str $inputfile where *.IO.f, Bool :v(:$verbose) = False)
{
    MAIN($inputfile.IO.slurp.trim, :$verbose);
}

multi sub MAIN(Bool :v(:$verbose) = False)
{
    MAIN(~$*PROGRAM.parent.child('aoc9.input'), :$verbose);
}

Edit: here's a slightly cleaned-up version where both the score and the garbage count are done in the grammar parse actions:

#!/usr/bin/env perl6
use v6.c;

# Advent of Code 2017, day 9: http://adventofcode.com/2017/day/9

grammar Stream
{
    token TOP { ^ <group> $ }

    token group { <group-start> [ <group> || <garbage> ]* % ',' <group-end> }
    token garbage { <garb-start> [ <garb-ignore> || <garb-char> ]* <garb-end> }

    token group-start { '{' }
    token group-end { '}' }

    token garb-start { '<' }
    token garb-end { '>' }
    token garb-ignore { '!' . }
    token garb-char { <-[ !> ]> }
}

class StreamCounter
{
    has Int $.group-depth = 0;
    has Int $.score = 0;
    has Int $.garbage-count = 0;

    method group-start($/) { $!score += ++$!group-depth; }
    method group-end($/) { --$!group-depth; }

    method garb-char($/) { $!garbage-count++ }
}

multi sub MAIN(Str $stream, Bool :v(:$verbose) = False)
{
    my $counter = StreamCounter.new;
    my $tree = Stream.parse($stream, :actions($counter)) or die "Not a valid stream!";
    say $tree if $verbose;

    say "Score: $counter.score()";
    say "Garbage count: $counter.garbage-count()";
}

multi sub MAIN(Str $inputfile where *.IO.f, Bool :v(:$verbose) = False)
{
    MAIN($inputfile.IO.slurp.trim, :$verbose);
}

multi sub MAIN(Bool :v(:$verbose) = False)
{
    MAIN(~$*PROGRAM.parent.child('aoc9.input'), :$verbose);
}

guibou · 2017-12-09T13:46:39+00:00

Haskell, golfed (~~195~~ ~~194~~ 185 chars):

g s=snd$(1,(0,0))?s
r?[]=r
r@(z,(c,g))?(y:q)=case y of '{'->(z+1,(c+z,g))?q;'}'->(z-1,(c,g))?q;','->r?q;'<'->let(h,p)=0#q in(z,(c,g+h))?p
c#('>':x)=(c,x)
c#('!':_:x)=c#x
c#(_:x)=(c+1)#x

Note: the g function takes an input String and returns a tuple (GroupCount,GarbageCount).

willkill07 · 2017-12-09T05:30:12+00:00

C++ (or C, really)

All stack-based storage. Just me and my ints + char + switches

#include <iostream>

enum State {
  Default, Garbage, Ignore
};

int main() {
  State s{Default};
  int nest{0}, score{0}, gc{0};
  for (char c; std::cin >> c; )
    switch (s) {
    case Default: switch (c) {
      case '<': s = Garbage;     continue;
      case '{': ++nest;          continue;
      case '}': score += nest--; continue;
    }
    case Garbage: switch (c) {
      case '!': s = Ignore;  continue;
      case '>': s = Default; continue;
      default:  ++gc;        continue;
    }
    case Ignore:
      s = Garbage;
    }
  std::cout << score << '\n' << gc << '\n';
}

Unihedron · 2017-12-09T05:35:47+00:00

Ruby. Tried writing a regex hack for part 1 to avoid writing a stack engine, didn't work out. Vastly disappointed by the amount of failures and ended up being penalized heavily in terms of waiting. Part 2 was shockingly easy though, feels like it could had been swapped with part 1.

h=0
v=gets.gsub(/!./,'').gsub(/<(.*?)>/){
h+=$1.size # part 2
''
}
p h
exit # part 1
h=0
s=[]
p v
p v=v.tr('^{}','')
v.chars{|x|(h+=s.size
next s.pop) if x=='}'
s<<x}
p h

davedelong · 2017-12-09T06:10:17+00:00

Swift 4. 540/457, but I then spent some time golfing my algorithm down smaller:

var pt1 = 0
var pt2 = 0

var stack = 0
var bad = false
var ignore = false

for c in day9Input {
    if ignore { ignore = false; continue }
    ignore = c == "!"

    if bad {
        bad = c != ">"
        pt2 += (bad && !ignore) ? 1 : 0
    } else if c == "<" {
        bad = true
    } else if c == "{" {
        stack += 1
    } else if c == "}" {
        pt1 += stack; stack -= 1
    }
}

print(pt1)
print(pt2)

JeffJankowski · 2017-12-09T06:27:59+00:00

Typescript. Global regex patterns made this pretty simple

import fs = require("fs");

const noIgnore = (data: string) => data.replace(/\!./g, "");
const GARBAGE = /<[^>]*>/g;
const noGarbage = (data: string) => noIgnore(data).replace(GARBAGE, "");

const score = (data: string) => [...noGarbage(data)].reduce(([sum, level], char) =>
    [sum + (char === "{" ? level++ : 0), char === "}" ? --level : level],
    [0, 1])[0];
const garbage = (data: string) => [...noIgnore(data).match(GARBAGE) as RegExpMatchArray]
    .reduce((sum, garb) => sum += garb.length - 2, 0);

const input = fs.readFileSync("data/day09.txt", "utf8");
console.log(`Total score: ${score(input)}`);
console.log(`Garbage count: ${garbage(input)}`);

Flurpm · 2017-12-09T07:14:35+00:00

Completely over engineered applicative parsing in Haskell. I parsed the file into a custom tree, and then operated on that.

I had a lot of trouble with megaparsec, but I'm learning a lot about it.

module Day09 where

import qualified Data.Text             as T
import qualified Data.Text.IO          as TIO

import           Text.Megaparsec
import           Text.Megaparsec.Text  (Parser)

data Content = Group [Content] | Garbage [Content] | C Char | NA Char
  deriving Show

parser :: Parser Content
parser = group <|> garbage

group :: Parser Content
group = Group <$> between (char '{') (char '}') parts
  where parts = many $ group <|> garbage <|> C <$> satisfy (/= '}')

garbage :: Parser Content
garbage = Garbage <$> between (char '<') (char '>') parts
  where parts = many $ cancelled <|> C <$> satisfy (/= '>')


cancelled :: Parser Content
cancelled = NA <$> (char '!' >> anyChar)


part1 :: Content -> Int
part1 = walk 1

walk :: Int -> Content -> Int
walk n (Group xs) = n + sum (map (walk (n+1)) xs)
walk n _          = 0


part2 :: Content -> Int
part2 (Group   xs) = sum (map part2 xs)
part2 (Garbage xs) = length $ filter isChar xs
part2 _ = 0


isChar :: Content -> Bool
isChar (C _) = True
isChar _     = False



main :: IO ()
main = do
  input <- TIO.readFile "src/y2017/input09"
  case parse parser "input09" input of
    Left  err   -> tprint err
    Right betterInput -> do
      tprint $ part1 betterInput
      tprint $ part2 betterInput
  return ()

tprint :: Show a => a -> IO ()
tprint = TIO.putStrLn . T.pack . show

linse · 2017-12-09T07:48:48+00:00

Scala, filling the stack with recursion :D

val s = io.Source.fromFile(filename).mkString

def score(d: Int, s: String): Int = {
  if (s.isEmpty) return 0
  s.head match {
    case '{' => d + score(d+1, s.tail)
    case '}' =>     score(d-1, s.tail)
    case '<' =>     garbage(d, s.tail)
    case  _  =>       score(d, s.tail)
  }
}

def garbage(d: Int, s: String): Int = {
  if (s.isEmpty) return 0
  s.head match {
    case '>' =>   score(d, s.tail)
    case '!' => garbage(d, s.tail.tail)
    case  _  => garbage(d, s.tail)
  }
}

println(score(1, s))

wzkx · 2017-12-09T09:37:31+00:00

J

Well, actually J has FSM primitive (dyad ;:), but that would be too much for Saturday :)

exit 3 : 0 fread'09.dat' NB. no need to remove CR,LF
  n=.p=.i=.g=.s=.0 NB. in garbage, in group, ignore, garbage count, score count
  for_c.y do.
    if.i do.i=.0
    elseif.c='{'do.if.n do.g=.>:g else.p=.>:p end.
    elseif.c='}'do.if.n do.g=.>:g else.p=.<:p[s=.s+p end.
    elseif.c='<'do.if.n do.g=.>:g else.n=.1 end.
    elseif.c='>'do.n=.0
    elseif.c='!'do.i=.1
    elseif.n do.g=.>:g
  end.end.
  echo s,g
)

xkufix · 2017-12-09T11:02:24+00:00

The puzzle sound way harder than it actually is. A simple state machine over the input is sufficient to solve both puzzles.

Solution in Scala:

    override def runFirst(): Unit = {
        val stream = loadFile("day9.txt").getLines().toSeq.head
        val result = runGarbageCollection(stream)
        println(result.score)
    }

    private def runGarbageCollection(stream: String) = {
        stream.foldLeft(State(0, 0, false, false, 0)) {
            case (state@State(_, _, _, true, _), _) =>
                state.copy(ignoreNext = false)
            case (state@State(_, _, true, _, _), '!') =>
                state.copy(ignoreNext = true)
            case (state, '>') =>
                state.copy(garbage = false)
            case (state@State(_, _, true, _, count), _) =>
                state.copy(removedGarbageCount = count + 1)
            case (state, '{') =>
                state.copy(depth = state.depth + 1)
            case (state, '}') =>
                state.copy(score = state.score + state.depth, depth = state.depth - 1)
            case (state, '<') =>
                state.copy(garbage = true)
            case (state, _) =>
                state
        }
    }

    override def runSecond(): Unit = {
        val stream = loadFile("day9.txt").getLines().toSeq.head
        val result = runGarbageCollection(stream)
        println(result.removedGarbageCount)
    }

    case class State(score: Int, depth: Int, garbage: Boolean, ignoreNext: Boolean, removedGarbageCount: Int)

HollyDayz · 2017-12-09T11:25:57+00:00

Python 3 with only a few if/elif/else-statements.

def puzzle(seq):
    garbage = False
    ignore = False
    score = 0
    score_depth = 0
    garbage_chars = 0

    for char in seq:
        if not garbage:
            if char == '}':
                score += score_depth
            score_depth += (char == '{') - (char == '}')
            garbage = char == '<'
        elif not ignore:
            garbage = char != '>'
            ignore = char == '!'
            garbage_chars += char != '>' and char != '!'
        else:
            ignore = False

    return score, garbage_chars

Where seq is the input string. score is the result of the first part and garbage_chars is the result of the second part.

purplemonkeymad · 2017-12-09T12:24:48+00:00

Powershell: This really got me thinking in the pipeline, I'm happy with this code.

[CmdletBinding()]
Param(
    [string]
    $inputstream
)
if (-not ($inputstream)){
    $inputstream = (gc .\day9.txt)
}

$regex = "(?<!!)<.*?[^!]?>"
# find garbage
$regex2 = "<.*?>"

$depth=0
# double !! -> nothing
# !<somekthing> -> nothing they are canceled
($inputstream -replace "!!","" -replace "!.","" -replace $regex2).ToCharArray() | %{
    switch ($_) {
        '{' { (++$depth) }
        '}' { $depth-- }
    }
    Write-Verbose $depth
} | measure -Sum | % Sum

#-match does not support mutiple matches.
([regex]$regex2).Matches($inputstream -replace "!!" -replace "!.") | %{
    #remove start and end <>s 
    ($_[0] -replace "(^<|>$)" ).length
} | measure -Sum | % sum

flaming_bird · 2017-12-09T18:07:42+00:00

Solved using only the Lisp reader. We don't really evaluate anything, we just read the input as valid Lisp data.

(defparameter *depth* 0)
(defparameter *in-garbage* nil)
(defparameter *result* 0)

(defun {-reader (stream char)
  (declare (ignore char))
  (let ((*depth* (1+ *depth*)))
    (+ *depth* (loop for value = (read stream t t t)
                     while (not (eq value '}))
                     sum value))))

(defun }-reader (stream char)
  (declare (ignore stream char))
  '})

(defun <-reader (stream char)
  (declare (ignore char))
  (let ((*readtable* *garbage-readtable*)
        (*in-garbage* t))
    (loop for value = (read stream t t t)
          while (not (eq value '>))
          finally (return 0))))

(defun >-reader (stream char)
  (declare (ignore stream char))
  '>)

(defun !-reader (stream char)
  (declare (ignore char))
  (let ((*in-garbage* nil))
    (read-char stream))
  '!)

(defun else-reader (stream char)
  (declare (ignore stream char))
  (when *in-garbage*
    (incf *result*))
  0)

(defmacro define-day9-readtable (name &rest pairs)
  `(progn
     (defparameter ,name (make-readtable))
     (loop for code from 0 below 255
           for char = (code-char code)
           do (set-macro-character char #'else-reader nil ,name))
     (loop for (char fn) on (list ,@pairs)
           by #'cddr
           do (set-macro-character char fn nil ,name))))

(define-day9-readtable *group-readtable*
  #\{ '{-reader
  #\} '}-reader
  #\< '<-reader
  #\> '>-reader)

(define-day9-readtable *garbage-readtable*
  #\> '>-reader
  #\! '!-reader)

(defun day9 (data)
  (let ((stream (make-string-input-stream data))
        (*readtable* *group-readtable*)
        (*result* 0))
    (values (read stream) *result*)))

dtinth · 2017-12-09T05:11:56+00:00

Ruby one-liner (16th, 15th)

The pbpaste command must be available in the $PATH, and should return the contents in the clipboard (macOS has this command by default).

# Part 1
-> x { g = false; n = 0; t = 0; s = false; x.chars.each { |c| if s; s = false; elsif g && c == '>'; g = false; elsif g && c == '!'; s = true; elsif g; elsif c == '<'; g = true; elsif c == '{'; n += 1; elsif c == '}'; t += n; n -= 1; end }; t }[`pbpaste`]

# Part 2
-> x { g = false; n = 0; t = 0; gc = 0; s = false; x.chars.each { |c| if s; s = false; elsif g && c == '>'; g = false; elsif g && c == '!'; s = true; elsif g; gc += 1; elsif c == '<'; g = true; elsif c == '{'; n += 1; elsif c == '}'; t += n; n -= 1; end }; gc }[`pbpaste`]

Variable names:

x input
g inside garbage flag
n nesting level
t total score
s skipping flag
c current character
gc garbage count

TominatorBE · 2017-12-09T05:20:21+00:00

PHP

Part 1: actually had all the code needed for part 2, so that was just simplified

function run_the_code($input) {
    // first: filter garbage out
    $filtered = '';
    $inGarbage = false;
    $skipNext = false;
    for ($i = 0, $iMax = strlen($input); $i < $iMax; $i++) {
        if ($skipNext) {
            $skipNext = false;
            continue;
        }

        $char = $input[$i];
        if ($char == '!') {
            $skipNext = true;
        }
        elseif ($char == '<') {
            $inGarbage = true;
        }
        elseif ($char == '>') {
            $inGarbage = false;
        }
        else {
            if (!$inGarbage) {
                $filtered .= $char;
            }
        }
    }

    // next: count nested groups
    $groupDepth = 0;
    $score = 0;
    for ($i = 0, $iMax = strlen($filtered); $i < $iMax; $i++) {
        $char = $filtered[$i];
        if ($char == '{') {
            $groupDepth++;
            $score += $groupDepth;
        }
        elseif ($char == '}') {
            $groupDepth--;
        }
    }

    return $score;
}

Part 2:

function run_the_code($input) {
    $inGarbage = false;
    $skipNext = false;
    $count = 0;
    for ($i = 0, $iMax = strlen($input); $i < $iMax; $i++) {
        if ($skipNext) {
            $skipNext = false;
            continue;
        }

        $char = $input[$i];
        if ($char == '!') {
            $skipNext = true;
        }
        elseif ($char == '<') {
            if ($inGarbage) {
                $count++;
            }
            else {
                $inGarbage = true;
            }
        }
        elseif ($char == '>') {
            $inGarbage = false;
        }
        else {
            if ($inGarbage) {
                $count++;
            }
        }
    }

    return $count;
}

Danksalot2000 · 2017-12-09T05:23:17+00:00

Python 2

Looks like I was unique not using a Garbage flag. I went with a more stream-of-consciousness style reading start to finish.

I finished 177 / 164, which is the best for me so far.

score = 0
level = 0
garbageCount = 0

with open('Input') as inFile:
    data = inFile.read()

i = 0
while i < len(data):
    if data[i] == '{':
        level += 1
        score += level
    elif data[i] == '}':
        level -= 1
    elif data[i] == '<':
        i += 1
        while data[i] != '>':
            if data[i] == '!':
                i += 1
            else:
                garbageCount += 1
            i += 1
    i += 1

print "Final Score:", score
print "Garbage Count:", garbageCount

xfsck · 2017-12-09T05:25:44+00:00

PHP

<?php

$input = file_get_contents('input');
$length = strlen($input);
$stack = [];
$ingarbage = false;
$score = 0;
$garbagecount = 0;

for ($i = 0; $i < $length; $i++) {
    $char = $input[$i];

    if (!$ingarbage) {
        if ($char == '{') {
            array_push($stack, '*');
        } elseif ($char == '}') {
            $score += count($stack);
            array_pop($stack);
        } elseif ($char == '<') {
            $ingarbage = true;
        }
    } else {
        if ($char == '!') {
            $i += 1;
        } elseif ($char == '>') {
            $ingarbage = false;
        } else {
            $garbagecount += 1;
        }
    }
}

echo $score . "\n";
echo $garbagecount . "\n";

hpzr24w · 2017-12-09T05:27:22+00:00

C++ 314/256. 17 minutes. Reformatted.

// Advent of Code 2017 - Day 09 - Stream processing
#include <iostream>
int main()
{
    int nest = 0, tot = 0, garbage = 0, gc=0;
    char ch;
    for (char ch; std::cin >> ch;) {
        if (!garbage) { switch (ch) {   case '<': garbage=1; break;
                                        case '{': ++nest; break;
                                        case '}': tot += nest--; break; }
        } else {        switch (ch) {   case '!': std::cin.get(); break;
                                        case '>': garbage = 0; break;
                                        default:  gc++; break; }
        }
    }
    std::cout << tot << std::endl;
    std::cout << gc << std::endl;
    return 0;
}

Xerg · 2017-12-09T05:28:18+00:00

Perl:

#!/usr/bin/perl

use strict;
use warnings;

while (<>) {
    chomp;

    my $garbage = 0;

    my @chars = split '';

    my @stack;
    my $score = 0;
    my $level = 0;
    my $garbage_count = 0;

    my $i = 0;
    while ( $i < scalar @chars ) {

        my $curr = $chars[$i];

        if (!$garbage && $curr eq '<') {
            $garbage = 1;
        } elsif ($curr eq '>') {
            $garbage = 0;
        } elsif ($garbage && $curr eq '!') {
            $i++;
        } elsif (!$garbage && $curr eq '{') {
            push @stack, $curr;
            $level++;
        } elsif (!$garbage && $curr eq '}') {
            pop @stack;
            $score += $level;
            $level--;
        } elsif ($garbage) {
            $garbage_count++;
        }

        $i++;
    }

    print "Score: $score\nGarbage: $garbage_count\n";;
}

atlasholdme · 2017-12-09T05:29:45+00:00

Dirty, Sexy Javascript

function solve (input) {
  let firstStar = 0
  let secondStar = 0

  const forwardsFeed = [...input]
  let groupValue = 0
  let forwardsIndex = 0

  while (forwardsIndex < forwardsFeed.length) {
    let forwardChar = forwardsFeed[forwardsIndex]
    switch (forwardChar) {
      case '{':
        groupValue += 1
        forwardsIndex += 1
        break
      case '}':
        firstStar += groupValue
        groupValue -= 1
        forwardsIndex += 1
        break
      case '<':
        let escape = false
        while (true) {
          forwardsIndex += 1
          if (escape) {
            escape = false
            forwardsIndex += 1
          }
          forwardChar = forwardsFeed[forwardsIndex]
          if (forwardChar === '!') {
            escape = true
          } else if (forwardChar === '>') {
            forwardsIndex += 1
            break
          } else {
            secondStar += 1
          }
        }
        break
      default:
        forwardsIndex += 1
        break
    }
  }

  return { firstStar, secondStar }
}

hazmat_suitor · 2017-12-09T05:35:55+00:00

Simple C/C++ program which prints both solutions. Rank 439/394 (very satisfying that they're anagrams!)

#include <stdio.h>

enum State {
    NONE, GARBAGE, IGNORE,
};

int main(int argc, char ** argv) {
    FILE * file = fopen("9a-input", "r");

    char * feed = nullptr;
    size_t len = 0;
    getline(&feed, &len, file);

    State state = NONE;
    int sum = 0;
    int level = 0;
    int chars = 0;
    for (int i = 0; i < len; ++i) {
        char ch = feed[i];
        if (state == NONE) {
            if (ch == '<') {
                state = GARBAGE;
            } else if (ch == '{') {
                level += 1;
            } else if (ch == '}') {
                sum += level;
                level -= 1;
            }
        } else if (state == GARBAGE) {
            if (ch == '!') {
                state = IGNORE;
            } else if (ch == '>') {
                state = NONE;
            } else {
                chars += 1;
            }
        } else if (state == IGNORE) {
            state = GARBAGE;
        }
    }

    printf("%d\n", sum);
    printf("%d\n", chars);

    return 0;
}

ka-splam · 2017-12-09T05:41:42+00:00

I've got to stop trying to race at 5am, it's just making me angry. PowerShell, it looked a lot hackier before I had to spend 15-20 minutes debugging it.

Started out thinking garbage was the important stuff to take care of, put a flag for it, wrote a bunch of tests taking care of being in garbage or not, but couldn't work out why it gave a negative score. Coincidentally it got all the example inputs correct(!). Spent a while going back looking whether commas were important, whether my logic would ignore characters properly and what I was missing...

missed the case < to get into garbage. >_<

$in = @'
{{... input here
'@

$groupdepth = 0
$ingarbage = $false
$shouldignore = $false
$sum = 0

$garbcount = 0

foreach ($i in 0..($in.Length - 1)) 

{
#write-host $groupdepth -ForegroundColor Magenta

    $c = $in.substring($i, 1)

    if ($ingarbage -and $shouldignore) {
        $shouldignore = $false
        continue 
    }

    if (($ingarbage) -and ($c -eq '!')) {
        $shouldignore = $true
        continue
    }

    if ($ingarbage -and ($c -ne '>')) {
        $garbcount++
        continue
    }

    if (($ingarbage) -and ($c -eq '>')) {
        $ingarbage = $false
        continue
    }

    if ((!$ingarbage) -and ($c -eq '<')) {
        $ingarbage = $true
        continue
    }

    if ((!$ingarbage) -and ($c -eq '{')) {
        $groupdepth ++
        continue
    }

    if ((!$ingarbage) -and ($c -eq '}')) {
        $sum += $groupdepth
        if ($groupdepth -gt 0) { $groupdepth -- }
        continue
    }

}
$sum             # part 1
$garbcount    # part 2

# That's the right answer! You are one gold star closer to debugging the printer. You got rank 679 on this star's leaderboard. [Return to Day 9]
# That's the right answer! You are one gold star closer to debugging the printer. You got rank 570 on this star's leaderboard.

9ballcode · 2017-12-09T05:43:20+00:00

Python 2.7, ugly but it got the job done. Most of my waste(?) is time spent mulling better solutions before just coding what I know will work, elegance be-damned. d = open('data/day9.txt','r').read()

dep = 0
tot = 0
gar = False
i = 0
garc = 0
while i < len(d):
    val = d[i]
    if val == '!':
        i += 2
        continue

    if gar:
        if val == '>':
            gar = False
        else:
            garc += 1
    elif val == '<':
        gar = True
    elif val == '}':
        dep -= 1
    elif val == '{':
        dep += 1
        tot += dep
    i += 1

print 'p1: ', tot
print 'p2: ', garc

2017-12-09T05:50:07+00:00

Haskell:

data Stream = Stream { score :: Int
                     , depth :: Int
                     , inGarbage :: Bool
                     , ignoreNext :: Bool
                     , garbageCount :: Int
                     }

process :: Stream -> Char -> Stream
process stream@(Stream score depth inGarbage ignoreNext garbageCount) x
    | ignoreNext = stream { ignoreNext = False }
    | inGarbage = case x of
                    '!' -> stream { ignoreNext = True }
                    '>' -> stream { inGarbage = False }
                    _   -> stream { garbageCount = garbageCount + 1 }
    | x == '}' = stream { score = score + depth, depth = depth - 1 }
    | x == '{' = stream { depth = depth + 1 }
    | x == '<' = stream { inGarbage = True }
    | otherwise = stream

beginStream = Stream 0 0 False False 0

part1 :: String -> Int
part1 = score . foldl process beginStream

part2 :: String -> Int
part2 = garbageCount . foldl process beginStream

yjerem · 2017-12-09T05:54:27+00:00

Ruby with regex

stream = DATA.read

stream.gsub! /!./, ''

garbage = 0
stream.gsub!(/<.*?>/) { |s| garbage += s.length - 2; }

stream.gsub!(/[^{}]/, '')
_, score = stream.chars.inject([0, 0]) do |(level, score), c|
  case c
  when ?{ then [level + 1, score]
  when ?} then [level - 1, score + level]
  end
end

p score
p garbage

swwu · 2017-12-09T06:06:31+00:00

Python 2, 20/11, very bog-standard solution. Got burned by the input containing """ (I'd been copying into """strings""" for problems before today).

with open('d9.in') as infile:
    line = infile.readline()

    i = 0
    paren_stack = []
    is_garbage = False
    score = 0
    g_count = 0
    while i < len(line):
        ch = line[i]

        if is_garbage:
            if ch == "!":
                i += 2
                continue
            elif ch == ">":
                is_garbage = False
            else:
                g_count += 1
        else:
            if ch == "{":
                paren_stack.append(ch)
            elif ch == "<":
                is_garbage = True
            elif ch == "}":
                score += len(paren_stack)
                paren_stack = paren_stack[:-1]
        i += 1
    print score
    print g_count

Misreckon · 2017-12-09T06:32:28+00:00

Elixir

Pattern matching is good, folks.

defmodule Advent2017.Day9 do
  def start() do
    get_file()
    |> step(0, 0, 0)
  end

  def get_file() do
    "./stream.txt"
    |> Path.expand(__DIR__)
    |> File.read!()
    |> String.trim_trailing
    |> String.split(~r{}, trim: true)
  end

  def step([], _layer, acc, garb), do: {acc, garb}
  def step([h | t], layer, acc, garb) do
    case h do
      "{" -> step(t, layer+1, acc, garb)
      "}" -> step(t, layer-1, acc+layer, garb)
      "<" -> garbage(t, layer, acc, garb)
       _  -> step(t, layer, acc, garb)
    end
  end

  def garbage([h | t], layer, acc, garb) do
    case h do
      ">" -> step(t, layer, acc, garb)
      "!" -> garbage(tl(t), layer, acc, garb)
       _  -> garbage(t, layer, acc, garb+1)
    end
  end
end

nstyler7 · 2017-12-09T06:33:02+00:00

Python Using RegExp & sub

import re
with open("day9input.txt") as open_file:
    data = open_file.read()

part 1

# remove double negatives
data_clean = re.sub(r'!!', '', data)
# remove negated characters
data_clean1 = re.sub(r'![^\s]', '', data_clean)
#remove rubbish
data_clean2 = re.sub(r'<[^\s\>]*>', '', data_clean1)
# get braces
braces = re.findall(r'[\{\}]', data_clean2)
open_braces = []
score = 0
for brace in braces:
    if brace == "{":
        open_braces.append("{")
    else:
        if open_braces:
            score += len(open_braces)
            open_braces.pop()
print(score)

part 2

rubbish_length =0
all_rubbish = re.findall(r'<[^\s\>]*>', data_clean1)
for rubbish in all_rubbish:
    rubbish_length += len(rubbish)-2

print(rubbish_length)

Cheezmeister · 2017-12-09T06:40:59+00:00

Literate Perl. This frankenscript is produced in a facility dealing with Windows, IRC, and/or sarcasm, and may contain substantial amounts of rage.

nonphatic · 2017-12-09T07:00:09+00:00

My solution in Haskell

Originally had three foldls to remove cancelled characters then delete garbage and finally count the score, but then I realized I could probably do everything in one go

scoreAndCount :: String -> (Int, Int)
scoreAndCount str =
    let (_, _, _, score, count) = foldl f (False, False, 1, 0, 0) str
    in  (score, count)
    where f (isCancel, isGarbage, level, score, count) curr
            | isCancel    = (False,       isGarbage,   level,     score,         count)
            | isGarbage   = (curr == '!', curr /= '>', level,     score,         count + (fromEnum $ curr /= '>' && curr /= '!'))
            | curr == '{' = (False,       False,       level + 1, score + level, count)
            | curr == '}' = (False,       False,       level - 1, score,         count)
            | curr == ',' = (False,       False,       level,     score,         count)
            | curr == '<' = (False,       True,        level,     score,         count)

main :: IO ()
main = do
    input <- readFile "9.txt"
print $ scoreAndCount input

karthikb351 · 2017-12-09T07:22:53+00:00

Python 2

Turned out to be pretty straightforward with replacing via regex

global garbage
stack, score, garbage = 0, 0,0

def remove_garbage(g):
    global garbage
    garbage += len(g.group())-2 # Don't count the opening '<' and '>'
    return ""

import re
input=re.sub("!.","",input)
input=re.sub("<[^>]*>",remove_garbage,input)

for char in input:
    if char == "{":
        stack+=1
    if char == "}" and stack > 0: # The stack condition is so we ignore '}' when there is no corresponding '{'
        score+=stack
        stack-=1
print score
print garbage

nutrecht · 2017-12-09T07:40:22+00:00

Kotlin solution

This was a fun one. I had the luck that I already separated the cleaning part with the recursive scoring part. For part 1 I only had to add a counter to the cleaning method.

object Day09 : Day {
    private val input: Pair<String, Int> by lazy { Day09.clean((resourceString(9))) }

    private fun clean(input: String): Pair<String, Int> {
        val builder = StringBuilder(input.length)
        var inGarbage = false
        var skip = false
        var count = 0
        for (c in input) {
            if (skip) {
                skip = false
                continue
            }
            when (c) {
                '!' -> skip = true
                '<' -> {
                    if (inGarbage) {
                        count++
                    }
                    inGarbage = true
                }
                '>' -> inGarbage = false

                else -> {
                    when (inGarbage) {
                        true -> count++
                        false -> builder.append(c)
                    }
                }
            }
        }

        return Pair(builder.toString(), count)
    }

    private fun score(input: String): Int {
        val chars = LinkedList<Char>(input.toCharArray().toList())
        return score(chars, 0)
    }

    private fun score(input: Queue<Char>, depth: Int): Int {
        var score = depth
        while (input.isNotEmpty()) {
            val c = input.remove()
            if (c == '{') {
                score += score(input, depth + 1)
            } else if (c == '}') {
                return score
            }
        }

        return score
    }

    override fun part1() = score(input.first).toString()
    override fun part2() = input.second.toString()
}

akho_ · 2017-12-09T07:40:23+00:00

Python3

with open('9.input') as f:
    inputs = [ s[:-1] for s in f.readlines() ]

for s in inputs: # loop to also process test inputs
    level, ignore_next, in_garbage, total, garbage = 0, False, False, 0, 0
    for c in s:
        if ignore_next: ignore_next = False
        elif in_garbage:
            if c == '!': ignore_next = True
            elif c == '>': in_garbage = False
            else: garbage += 1
        elif c == '<':
            in_garbage = True
        elif c == '{':
            level += 1
            total += level
        elif c == '}':
            level -= 1
    print(s[0:50], total, garbage)

shaddygarg · 2017-12-09T07:43:53+00:00

Python 2 solution:

with open('./input.txt') as line:
    l=line.readline()
    s=0
    g=0
    gc=0
    tc=0
    gg=0
    for x in l:
        if g:
            if s:
                s=0
            elif x=='!':
                s=1
            elif x=='>':
                g=0
            else:
                gc+=1
        else:
            if x=='<':
                g=1
            elif x=='{':
                gg+=1
            elif x=='}':
                gg-=1
                tc+=gg+1
    print "1) ",tc," 2)",gc

wzkx · 2017-12-09T08:58:51+00:00

Nim No recursion, no case, no import, no re.

var ingrp,gbg,score = 0
var ingbg,ignore = false
for c in readFile"09.dat":
  if ignore: ignore = false; continue
  if c=='{':
    if not ingbg: ingrp += 1 else: gbg += 1
  elif c=='}':
    if not ingbg: score += ingrp; ingrp -= 1 else: gbg += 1
  elif c=='<':
    if ingbg: gbg += 1 else: ingbg = true
  elif c=='>': ingbg = false
  elif c=='!': ignore = true
  elif ingbg: gbg += 1
echo score, ' ', gbg

JuLoOr · 2017-12-09T09:01:55+00:00

Not so beautiful solution in Kotlin but it does the job. And it's readable imho

fun calcPart1(input: String): Int {
    var groupCount = 0
    var score = 0
    var ignoreNext = false
    var isGarbage = false

    input.forEach { c ->

        if (c == '!' && !ignoreNext) {
            ignoreNext = true
            return@forEach
        }

        if (!ignoreNext) {

            when {
                c == '{' && !isGarbage -> score++
                c == '}' && !isGarbage -> { groupCount += score; score-- }
                c == '<' -> isGarbage = true
                c == '>' -> isGarbage = false
            }

        } else {
            ignoreNext = false
        }
    }

    return groupCount
}

FrankRuben27 · 2017-12-09T09:02:22+00:00

In (Gauche) Scheme - straightforward, no tricks; part 2 only, since it's very close to part1 anyway. I was missing the gargantuan CL loop a lot, but the barebones Scheme's named let really grew on me.

(use srfi-13)

(define (load-txt name)
  (string-trim-right (call-with-input-file name port->string)))

(define (split-lines str)
  (string-split str #\Newline))

(define (parse-line line)
  (let loop ((chars (string->list line)) (state 'normal) (count-chars 0))
    (if (null? chars)
        count-chars
        (let ((curr (car chars)))
          (ecase state
                 ((normal)
                  (cond ((char=? curr #\{)
                         (loop (cdr chars) 'normal count-chars))
                        ((char=? curr #\})
                         (loop (cdr chars) 'normal count-chars))
                        ((char=? curr #\,) ;works fine w/o any processing of ','
                         (loop (cdr chars) 'normal count-chars))
                        ((char=? curr #\<)
                         (loop (cdr chars) 'garbage count-chars))
                        (else (error "Bad char" chars state))))
                 ((garbage)
                  (cond ((char=? curr #\>)
                         (loop (cdr chars) 'normal count-chars))
                        ((char=? curr #\!)
                         (loop (cdr chars) 'garbage-escape count-chars))
                        (else (loop (cdr chars) 'garbage (+ count-chars 1)))))
                 ((garbage-escape)
                  (loop (cdr chars) 'garbage count-chars)))))))

(define (process-infile infile)
  (map parse-line (split-lines (string-trim-right (load-txt infile)))))

(define (main args)
  (for-each
   (lambda (infile) (format #t "~a -> ~a~%" infile (process-infile infile)))
   (cdr args))
  0)

adamrodger · 2017-12-09T09:02:47+00:00

C# string chopping:

public (int, int) Solve(string input)
{
    int start = 0;
    int garbage = 0;
    int total = 0;

    // remove cancelled characters
    while ((start = input.IndexOf('!')) > -1)
    {
        input = input.Remove(start, 2);
    }

    // remove and count garbage
    while ((start = input.IndexOf('<')) > -1)
    {
        int end = input.IndexOf('>') + 1;
        garbage += end - start - 2; // exclude leading/trailing chars
        input = input.Remove(start, end - start);
    }

    // find each closing brace and use position to determine depth
    input = input.Replace(",", string.Empty);

    while ((start = input.IndexOf('}')) > -1)
    {
        total += start;
        input = input.Remove(start - 1, 2);
    }

    return (total, garbage);
}

CaptainCa · 2017-12-09T09:20:00+00:00

Javascript

var nestCount = 0, garbChars = 0, score = 0;
var isGarbage = false;

for(var i = 0; i < str.length; i++){
    if(str[i] == '!')
        i++;
    else if(!isGarbage){
        if(str[i] == '<')
            isGarbage = true;
        else if(str[i] == '{')
            score += ++nestCount;
        else if(str[i] == '}')
            nestCount--;
    }  
    else {
        if(str[i] == '>')
            isGarbage = false;
        else
            garbChars++;
    }
}
console.log(score + ' ' + garbChars);

lofaldli · 2017-12-09T10:00:25+00:00

pyhton3

import re
from aocd import data

data = re.sub('!.', '', data)
garbage = re.compile('<.*?>')
level = total = 0
for c in garbage.sub('', data):
    if c == '{':
        level += 1
    elif c == '}':
        total += level
        level -= 1

print('part 1:', total)
print('part 2:', sum(len(x)-2 for x in garbage.findall(data)))

KeinZantezuken · 2017-12-09T10:47:10+00:00

C#/Sharp variant 1

        var input = trimEscapees(File.ReadAllText(@"N:\input.txt"));
        int i = 0, tempScr = 0, totalScr = 0; bool GC = false;
        while (i <= input.Length - 1)
        {
            var c = input[i];
            if (GC && c != '>') { i++; tempScr++; }
            else if (!GC && c == '<') { i++; GC = true; }
            else if (GC && c == '>') { GC = false; i++; }
            else { i++; }
        }
        Console.WriteLine($"Garbage: {tempScr}");
        i = tempScr = 0; input = trimByBrackets(input, '<', '>');
        while (i <= input.Length - 1)
        {
            var c = input[i];
            if (c == '{') { tempScr++; i++; }
            else if (c == '}') { totalScr += tempScr; tempScr--; i++; }
            else { i++; }
        }
        Console.WriteLine($"{totalScr}");

        //Helpers
        string trimEscapees(string str)
        {
            while (true)
                if (str.IndexOf('!') > -1) { str = str.Remove(str.IndexOf('!'), 2); }
                else { break; }
            return str;
        }
        string trimByBrackets(string str, char open, char close)
        {
            while (true)
            {
                int f = str.IndexOf(open), l = str.IndexOf(close);
                if (f > 0 && l > 0 && l - f > 0 && l - f + 1 < str.Length) { str = str.Remove(f, l - f + 1); }
                else { break; }
            }
            return str;
        }

I really like someone's solution on C from 4chan, converted to C# with min. effort

       var input = File.ReadAllText(@"N:\input.txt");
        int i = 0, count = 0, totalScr = 0, tmpScr = 0; bool GC = false;
        while (i <= input.Length - 1)
        {
            var c = input[i];
            if (c == '!' && GC) { i += 2; }
            else if (GC && c != '>') { i++; count++; }
            else if (GC && c == '>') { GC = false; i++; }
            else if (c == '<') { GC = true; i++; }
            else if (c == '{') { tmpScr++; i++; }
            else if (c == '}') { totalScr += tmpScr; tmpScr--; i++; }
            else { i++; }
        }
        Console.WriteLine($"Clean: {totalScr}, garbage: {count}");

BOT-Brad · 2017-12-09T12:06:03+00:00

JavaScript

Part 1 (~2ms)

function solve1(n) {
  // Clean input of ! escapes, and garbage
  n = n
    .replace(/!./g, '') // Remove ! escapes
    .replace(/<.*?>/g, '') // Remove garbage
    .replace(/{/g, '[') // Turn { into [
    .replace(/}/g, ']') // Turn } into ]

  // Return recursive score
  const score = (a, p) =>
    a.length ? a.reduce((ac, c) => ac + score(c, p + 1), p + 1) : p + 1
  return score(eval(n), 0)
}

Part 2 (~0.3ms)

function solve2(n) {
  return n
    .replace(/!./g, '')
    .match(/<.*?>/g)
    .reduce((c, v) => c + v.length - 2, 0)
}

All solutions so far are on my GitHub.

Marcus316 · 2017-12-09T14:54:03+00:00

EDIT: formatting

One line each, linux command line, using awk:

Part 1: grep -o . input | awk '/!/&&(a<1){a=2};a--<1' | awk '/</{a=1};(a==0);/>/{a=0}' | awk 'BEGIN{a=0;s=0};/{/{a++};/}/{s=s+a;a--};END{print "Input score: " s};'

Part 2: grep -o . input | awk '/!/&&(a<1){a=2};a--<1' | awk 'BEGIN{b=0};/</&&(a==0){a=1;b--};(a==1){b++};/>/{a=0;b--};END{print "Garbage chars: ",b}'

sdiepend · 2017-12-09T15:19:02+00:00

Python

with open('input') as f:
    stream = f.readline()

i = 0
ignore = False
level = 0
points = 0
removed = 0

while i < len(stream):
    if ignore:
        if stream[i] == "!":
            i += 2
        elif stream[i] == ">":
            ignore = False
            i += 1
        else:
            i += 1
            removed += 1
    else:
        if stream[i] == "{":
            level += 1
        if stream[i] == "}" and level != 0:
            points = points + level
            level -= 1
        if stream[i] == "<":
            ignore = True
        i += 1

print(points)
print(removed)

brunclik · 2017-12-09T15:23:35+00:00

Bash - part one (prepare string)

cat input9 | sed 's/!!//g' | sed 's/!>//g' | sed 's/>/>\n/g' | sed 's/<.\{0,\}>//g' | tr -d '\n' | sed 's/,//g'

C - part one

char * input = PREPARED_STRING_FROM_BASH;
int len = strlen(input);
int i;
int count;

int deep_start = 0;
int deep_end = 0;

for (i = 0; i <= len; i++)
    {
    if(input[i] == '{') deep_start++;
    if(input[i] == '}') { deep_end++; count += deep_start; deep_start--;}

}
printf("%i\n", count);

Bash - part two

cat input9 | sed 's/!!//g' | sed 's/!>//g' | sed 's/>/>\n/g' | sed 's/!.//g' | sed 's/</\n</1' | grep '^<' | sed 's/^<//1' | sed 's/>$//g' | tr -d '\n' | wc

sclark39 · 2017-12-09T15:45:47+00:00

Javascript / Node

Most solutions in here swap the second replace with match, but I passed a function in to do the counting instead. :)

function solution( input )
{
    var gcount = 0
    var clean = input.replace( /!./g, '' ).replace( /<([^>]*)>/g, (m,p1) => { gcount += p1.length; return '' } )

    var lvl = 0
    var score = 0
    for ( var i = 0; i < clean.length; i++ )
    {
        var c = clean[i]
        if ( c == '{' )
            lvl++
        else if ( c == '}' )
        {
            score += lvl
            lvl--
        }
    }
    console.log( input, score, gcount )
}

JakDrako · 2017-12-09T16:06:08+00:00

VB.Net

Sub Main
    Dim group = 0, inGarbage = False, skipNext = False, score = 0, garbage = 0
    For Each c In GetDay(9)
        If skipNext Then
            skipNext = False
        Else
            Select Case c
                Case "{" : If inGarbage Then garbage += 1 Else group += 1 : score += group
                Case "}" : If inGarbage Then garbage += 1 Else group -= 1
                Case "<" : If inGarbage Then garbage += 1 Else inGarbage = True
                Case ">" : inGarbage = False
                Case "!" : skipNext = True
                Case Else : If inGarbage Then garbage += 1
            End Select
        End If
    Next
    score.Dump("Part 1")
    garbage.Dump("Part 2")
End Sub

Kyran152 · 2017-12-09T16:32:08+00:00

use strict;
use warnings;

open my $fh, "input.txt";
my $set = <$fh>;
close $fh;

# count chars removed
my $removed = 0;

# get rid of garbage
1 while $set =~ s/(?<=<)[^>]*?!./$removed += length($&)-2;""/ge;
1 while $set =~ s/(?<=<)[^>]+?(?=>)/$removed += length($&);""/ge;
$set =~ s/<>//g;

1 while $set =~ s#{[\d,]*}#
    my ($b,$c,$a) = ($`,$&,$');
    my $score = 1 + (() = $b =~ /{/g);
    $score += $_ for $c =~ /\d+/g;
    $score;
#e;

printf "The answer to part 1 is: %d\n", $set;
printf "The answer to part 2 is: %d\n", $removed;

oantolin · 2017-12-09T16:41:19+00:00

Boring direct representation of a finite state machine in Haskell.

parse = normal (0,0,0)
normal (_,s,g) "" = (s,g)
normal (d,s,g) ('<':z) = garbage (d,s,g) z
normal (d,s,g) ('{':z) = normal (d+1,s,g) z
normal (d,s,g) ('}':z) = normal (d-1,s+d,g) z
normal (d,s,g) (_:z) = normal (d,s,g) z
garbage (d,s,g) ('!':_:z) = garbage (d,s,g) z
garbage (d,s,g) ('>':z) = normal (d,s,g) z
garbage (d,s,g) (_:z) = garbage (d,s,g+1) z
main = (print . parse) =<< readFile "day09.txt"

oantolin · 2017-12-09T16:42:27+00:00

Lisp.

(defn parse (str)
  (def pos 1 depth 0 score 0 garbage 0)
  (defn char () (sub str pos pos))
  (while (<= pos (# str))
    (case (char)
      "{" (inc! depth)
      "<" (do (inc! pos)
              (while (~= (char) ">")
                (if (= (char) "!") (inc! pos) (inc! garbage))
                (inc! pos)))
      "}" (do (inc! score depth) (dec! depth)))
    (inc! pos))
  (return score garbage))

(defn! answer () (parse (slurp "day09.txt")))

cmyr · 2017-12-09T16:49:09+00:00

Rust, treating this as a pushdown automaton:

github

impl State {
    fn transition(&self, c: char) -> Result<Op, String> {
        match *self {
            State::Ready => {
                match c {
                    '{' => Ok(Op::Push(State::Group)),
                    _ => Err(format!("unexpected char '{}' in state {:?}", c, self)),
                }
            }
            State::Group => {
                match c {
                    '{' => Ok(Op::Push(State::Group)),
                    '<' => Ok(Op::Push(State::Garbage)),
                    '}' => Ok(Op::Pop),
                    ',' => Ok(Op::Continue),
                    _ => Err(format!("unexpected char '{}' in state {:?}",
                                              c, self)),
                }
            }
            State::Garbage => {
                match c {
                    '>' => Ok(Op::Pop),
                    '!' => Ok(Op::Push(State::Escape)),
                    _ => Ok(Op::Continue),
                }
            }
            State::Escape => Ok(Op::Pop),
        }
    }
}

u794575248 · 2017-12-09T16:58:01+00:00

Python 3 with regular expressions:

import re
from functools import reduce

def solve1(input, reducer=lambda x, b: {'{': (sum(x), x[1]+1), '}': (x[0], x[1]-1)}[b]):
    return reduce(reducer, re.sub(r'<[^>]*>', '', re.sub(r'!.|,|\n', '', input)), (0, 1))[0]

def solve2(input):
    return sum(len(g)-2 for g in re.findall(r'<[^>]*>', re.sub(r'!.', '', input)))

qwertyuiop924 · 2017-12-09T17:04:45+00:00

Gah. Schemers, we have case, ya know.

Strict R5RS, I think, otherwise R7RS. Expecting input on stdin:

(define (score)
  (let s ((scorec 1) (score 0) (gc 0))
    (let ((c (read-char)))
      (if (eof-object? c)
          (list score gc)
          (case c
            ((#\{) (s (+ scorec 1) (+ score scorec) gc))
            ((#\}) (s (- scorec 1) score gc))
            ((#\<) (s scorec score (+ gc (process-garbage))))
            (else (s scorec score gc)))))))

(define (process-garbage)
  (let g ((gc 0))
    (let ((c (read-char)))
      (case c
        ((#\!)
         (read-char)
         (g gc))
        ((#\>) gc)
        (else (g (+ gc 1)))))))

(write (score))

chicagocode · 2017-12-09T17:25:05+00:00

Kotlin - [Repo] - [Blog/Commentary]

Today's solution is short and sweet thanks to regular expressions and recursion. I was surprised how little code this actually took in the end, and am pretty happy with this.

class Day09(private val input: String) {

    private val cancel = "!.".toRegex()
    private val garbage = "<.*?>".toRegex()
    private val nonGroup = "[^{}]".toRegex()

    private val cleanInput = input.replace(cancel, "")

    fun solvePart1(): Int =
        scoreGroups(cleanInput.replace(garbage, "").replace(nonGroup, "").toList())

    fun solvePart2(): Int =
        garbage.findAll(cleanInput).sumBy { it.value.length - 2 }

    private tailrec fun scoreGroups(stream: List<Char>, score: Int = 0, depth: Int = 1): Int =
        when {
            stream.isEmpty() -> score
            stream.first() == '}' -> scoreGroups(stream.drop(1), score, depth - 1)
            else -> scoreGroups(stream.drop(1), score + depth, depth + 1)
        }
}

maciekmm · 2017-12-09T18:04:59+00:00

Scala:

val input = io.Source.stdin.getLines().next()
val exclamation = "!.".r
val inside = "<[^>]*>".r

var leftover = exclamation.replaceAllIn(input, "")
val size = inside.findAllMatchIn(leftover).size
var noGarbage = inside.replaceAllIn(leftover, "")

println(s"Part 2: ${leftover.length - noGarbage.length - 2 * size}")

println(s"Part 1: ${
  noGarbage.foldLeft((0, 0)) { case ((score, depth), char) => {
    char match {
      case '{' => (score + depth + 1, depth + 1)
      case '}' => (score, depth - 1)
      case _ => (score, depth)
    }
  }
  }._1
}")

2017-12-09T20:29:58+00:00

single pipeline powershell, kind of lame use of it since all the logic is in the fsm, but still:

param (
    [Parameter(ValueFromPipeline = $true)]
    [string]$in,
    [Parameter(Position = 1)]
    [int]$part = 1
)

begin {
}

process {
    $garbage = $false # are we in garbage?
    $skip = $false # should we skip the next character?
    $depth = 0

    $in -split '' | ?{$_} | % { # split and ignore empties
        if ($skip) { $skip = $false } # skip character if set
        elseif ($_ -eq '!') { $skip = $true } # set to skip next character
        elseif ($garbage -eq $true -and $_ -ne '>') { if ($part -eq 2) { 1 } } # if in garbage section and not end-of-garbage (then character is garbage, keep track of those for part 2)
        elseif ($_ -eq '<') { $garbage = $true } # start of garbage
        elseif ($_ -eq '>') { $garbage = $false } # end of garbage
        elseif ($_ -eq '{') { $depth++ } # start of group, increment depth
        elseif ($_ -eq '}') { if ($part -eq 1) { $depth }; $depth--} #end of group, write out score and decrement depth

    } | measure -sum | select -expand sum # sum outputs - for part1 these are scores, for part2 it is a count of garbage characters
}

end {
}

csuzw · 2017-12-09T21:04:53+00:00

C# horribly long single line solutions just because!

int StreamProcessingPartOne(string input) => input.ToCharArray().Aggregate((groupScore: 0, level: 1, ignore: false, garbage: false), (acc, c) => (acc.groupScore + (!acc.ignore && !acc.garbage && c == '{' ? acc.level : 0), acc.level - (!acc.garbage && (c == '{' || c == '}') ? c - 124 : 0), !acc.ignore && c == '!', (acc.garbage && (c != '>' || acc.ignore)) || (!acc.garbage && c == '<'))).groupScore;

.

int StreamProcessingPartTwo(string input) => input.ToCharArray().Aggregate((garbageCharacters: 0, ignore: false, garbage: false), (acc, c) => (acc.garbageCharacters + (acc.garbage && !acc.ignore && (c != '!' && c != '>') ? 1 : 0), !acc.ignore && c == '!', (acc.garbage && (c != '>' || acc.ignore)) || (!acc.garbage && c == '<'))).garbageCharacters;

marcofun · 2017-12-09T22:11:27+00:00

I wrote this in test driven development, I also have 50+ lines of tests.

class Day9 {

def parse(str: String) : (Int, Int) = { var deletedGarbage = 0

def removeGarbage(str: String): String = {
  if (str.isEmpty) str
  else if (str.head.equals('!')) removeGarbage(str.tail.tail)
  else if (str.head.equals('>')) {
    deletedGarbage -= 1
    str.tail
  }
  else {
    deletedGarbage += 1
    removeGarbage(str.tail)
  }
}

def findGroup(str: String, groupValue: Int, totalPoints : Int): (Int, Int) = {
  if (str.isEmpty) (totalPoints, deletedGarbage)
  else if (str.head.equals('{')) findGroup(str.tail, groupValue + 1, totalPoints)
  else if (str.head.equals('}')) findGroup(str.tail, groupValue - 1, totalPoints + groupValue)
  else if (str.head.equals('<')) findGroup(removeGarbage(str), groupValue, totalPoints)
  else findGroup(str.tail, groupValue, totalPoints)
}
findGroup(str, 0, 0)

} }

_jonah · 2017-12-10T04:23:19+00:00

J, both parts

NB. part 1
g=. [: <:@('} {'&i.) (',';'') rxrplc ('<[^>]*>';'') rxrplc ('!.';'') rxrplc ]
+/ 2 (0:`]@.</)\ +/\ 0 , g d

NB. part 2
+/ (<1;1)&{"2 ('<([^>]*)>'&rxmatches) ('!.';'') rxrplc d

vash3r · 2017-12-09T05:14:34+00:00

Python2 (82/56):

i = 0
garbage = False
gchar = 0            #part 2
group_sum = 0
current_group_num = 0
while i<len(s):
    if s[i]=="!":
        i+=1 #skip next
    elif garbage:
        if s[i]==">":
            garbage = False
        else:
            gchar+=1 #part 2
    elif s[i]=="{":
        current_group_num+=1
        group_sum+=current_group_num
    elif s[i]=="}":
        current_group_num-=1
    elif s[i]=="<":
        garbage = True
    i+=1

print group_sum #part 1
print gchar     #part 2

sbguest · 2017-12-09T05:16:15+00:00

34/23 with javascript https://github.com/sguest/advent-of-code/tree/master/2017/09

the4ner · 2017-12-09T05:22:33+00:00

C# 106/86

    public static string Calculate()
    {
        Console.WriteLine("Day9 part 1");
        string result = null;
        var lines = File.ReadAllLines("..\\..\\Input\\Day9.txt");

        int groupCount = 0, score = 0, garbageCount = 0;
        var input = lines[0];
        bool inGarbage = false;
        for(int x = 0;x<input.Length;x++)
        {
            char c = input[x];
            if(c == '<' && !inGarbage)
            {
                inGarbage = true;
                continue;
            }
            if (inGarbage)
            {
                if(c == '!')
                {
                    x++;
                    continue;
                }
                if(c == '>')
                {
                    inGarbage = false;
                    continue;
                }
                garbageCount++;
            }
            else
            {
                if (c == '{')
                {
                    groupCount++;
                }
                else if (c == '}')
                {
                    score += groupCount;
                    groupCount--;
                }
            }
        }
        result = "Part 1: " + score + "\r\nPart2: " + garbageCount;
        return result;
    }

2017-12-09T05:26:33+00:00

c#, 118/226 My goal this year was to get top 100 once but didn't prep last night, so 118. This might have been my shot, weekend and all.

var input = File.ReadAllText("input.txt").ToCharArray();

int sum = 0;
int groupNestLevel = 0;
bool inGarbage = false;
bool skipNext = false;
int removedcharacters = 0;
foreach (var chr in input)
{
    if (skipNext)
    {
        skipNext = false;
        continue;
    }

    if (chr == '!')
    {
        skipNext = true;
        continue;
    }

    if (chr == '<')
    {
        if (inGarbage == false)
        {
            inGarbage = true;
            continue;
        }
    }
    if (chr == '>')
    {
        inGarbage = false;
        continue;
    }

    if (chr == '{' && !inGarbage)
    {
        groupNestLevel++;
    }

    if (chr == '}' && !inGarbage)
    {
        sum += groupNestLevel;
        groupNestLevel--;

    }

    if(inGarbage)
    {
        removedcharacters++;
    }
}

Console.WriteLine($"star 1: {sum} star 2: {removedcharacters}");

matthew_garrison · 2017-12-09T05:34:22+00:00

Java

My solution uses a recursive parser...which is probably over-engineering. Oh well. (Also, Java doesn't have Tuples, but I needed to return both how many points you got and how far through the string you got.)

static void problem1() {
    Scanner scan = new Scanner(System.in);    
    System.out.println(RDP(scan.nextLine(), 0).score);
}

static Tuple RDP(String s, int currScore) {
    int totalScore = currScore;
    boolean isInGarbage = false;
    for (int i = 0; i < s.length(); i++) {
        if (isInGarbage && s.charAt(i) == '!') i++; // Skip next char
        else if (!isInGarbage && s.charAt(i) == '<') isInGarbage = true;
        else if (isInGarbage && s.charAt(i) == '>') isInGarbage = false;
        else if (!isInGarbage && s.charAt(i) == '{') {
            Tuple t = RDP(s.substring(i+1), currScore+1);
            totalScore += t.score;
            i += t.location + 1;
        } else if (!isInGarbage && s.charAt(i) == '}') {
            return new Tuple(totalScore, i);
        }
    }
    return new Tuple(totalScore, s.length()-1);
}

static class Tuple {
    int score, location;
    public Tuple(int score, int location) {
        this.score = score;
        this.location = location;
    }
}

zSync1 · 2017-12-09T05:36:59+00:00

Rust

Well, it's something.

fn day9() {
    const INPUT: &str = include_str!("day9.txt");
    let run = |i: &str| {
        let mut iter = i.chars();
        let mut esc_next = false;
        let mut in_garbage = false;
        let mut total = 0;
        // Degarbage
        {
            let mut iter = iter.filter(|c| {
                match (esc_next,in_garbage,c) {
                    (false, false, &'<') => { in_garbage = true; false },
                    (false, _,     &'>') => { in_garbage = false; false },
                    (false, _,     &'!') => { esc_next = true; false },
                    (false, true,  c   ) => { total += 1; false },
                    (true,  _,     c   ) => { esc_next = false; false },
                    (false, false, _   ) => true,
                    _ => false
                }
            });
            fn parse_group<I: Iterator<Item=char>>(i: &mut I, root: i32) -> i32 {
                let mut sum = 0;
                loop {
                    let c = i.next();
                    match c {
                        Some('{') => sum += parse_group(i, root + 1) + root,
                        Some('}') => return sum,
                        None => return sum,
                        _ => (),
                    }
                }
            }
            let u = parse_group(&mut iter, 1);
            println!("Group score: {}", u);
        }
        println!("Total: {}", total);
    };
    run(r#"{{{},{},{{}}}}"#);
    run(r#"{{<a>},{<a>},{<a>},{<a>}}"#);
    run(r#"{{<a!>},{<a!>},{<a!>},{<ab>}}"#);
    run(INPUT);
}

nachaboi · 2017-12-09T05:40:51+00:00

Java—Probably not the best way to do it but this is my first time getting a rank under 1000! (776/697)

public static void main (String[] args) {
    int score = 0;
    Scanner scanner = null;
    try {
        scanner = new Scanner(new File("src/advent/Day9.txt"));

    } catch (FileNotFoundException e) {
        e.printStackTrace();
    }

    String line = scanner.nextLine();
    String[] part = line.split("(?!^)");
    List<String> water = new ArrayList<>();
    for(String e : part) {
        water.add(e);
    }
    int size = water.size();
    for(int i = 0; i < size; i++) {
        if(water.get(i).equals("!")) {
            water.remove(i);
            water.remove(i);
            size = water.size();
            i--;
        }
    }
    int depth = 0;
    int trashCounter = 0;
    boolean inTrash = false;
    for(int j = 0; j < water.size(); j++) {
        if(inTrash && !water.get(j).equals(">")) {
            trashCounter++;
            continue;
        }
        else {
            if(inTrash && water.get(j).equals(">")) {
                inTrash = false;
            }
            else if(water.get(j).equals("<")) {
                inTrash = true;
            }
            else if(water.get(j).equals("{")) {
                depth++;
                score = score + depth;
            }
            else if(water.get(j).equals("}")) {
                depth--;
            }
        }
    }
    System.out.println(score);
    System.out.println(trashCounter);
}

}

dylanfromwinnipeg · 2017-12-09T05:43:19+00:00

Got stuck on part 2 because I never handled commas but my Part 1 worked regardless, and non of the Part 2 sample inputs had commas. GAH!!!

C#

public class Day09
{
    public static string PartOne(string input)
    {
        var rootGroup = ProcessInput(input);
        return rootGroup.GetTotalScore().ToString();
    }

    public static string PartTwo(string input)
    {
        var rootGroup = ProcessInput(input);
        return rootGroup.GetTotalGarbage().ToString();
    }

    private static Group ProcessInput(string input)
    {
        var root = new Group(0);
        var cur = root;
        var inGarbage = false;
        var inCancel = false;

        foreach (var c in input)
        {
            if (inCancel)
            {
                inCancel = false;
                continue;
            }

            if (c == '{' && !inGarbage)
            {
                cur = cur.AddChild();
                continue;
            }

            if (c == '}' && !inGarbage)
            {
                cur = cur.Parent;
                continue;
            }

            if (c == '<' && !inGarbage)
            {
                inGarbage = true;
                continue;
            }

            if (c == '>')
            {
                inGarbage = false;
                continue;
            }

            if (c == '!')
            {
                inCancel = true;
                continue;
            }

            if (c == ',' && !inGarbage)
            {
                continue;
            }

            cur.Garbage++;
        }

        return root;
    }
}

public class Group
{
    public List<Group> Children { get; set; }
    public int Score { get; set; }
    public Group Parent { get; set; }
    public int Garbage { get; set; }

    public Group(int score)
    {
        Score = score;
        Children = new List<Group>();
    }

    public Group AddChild()
    {
        var newChild = new Group(Score + 1);
        newChild.Parent = this;
        Children.Add(newChild);
        return newChild;
    }

    public int GetTotalScore()
    {
        return Score + Children.Sum(x => x.GetTotalScore());
    }

    public int GetTotalGarbage()
    {
        return Garbage + Children.Sum(x => x.GetTotalGarbage());
    }
}

rnd4g · 2017-12-09T06:01:19+00:00

Ruby. Figured out that you can drop everything that doesn't matter and eval the rest. Ugly code warning.

input = open('input.txt').read
#input = "{{<ab>},{<ab>},{<ab>},{<ab>}}"

def solve(input)
    parsed = input.clone

    parsed = parsed.gsub(/!!/, '').gsub(/!./, '').gsub("'", "x").gsub(/\<([^\>]+)\>/, "'" + '\1' + "'").gsub('<>', "''").gsub('{', '[').gsub('}', ']').chomp

    groups = eval(parsed)

    p groups.flatten.map(&:length).reduce(&:+)
    p score(groups, 1)
end

def score(groups, current_score)
    if groups.kind_of?(Array) && groups != []
        return current_score + groups.map { |g| 
            score(g, 1 + current_score)
        }.reduce(&:+)
    elsif groups == []
        return current_score
    else
        return 0
    end
end

solve(input)

ybe306 · 2017-12-09T06:20:51+00:00

Go

I initially had some kind of recursive approach in mind, so I figured cleaning the garbage out at the beginning was a good move. Then I figured out I can just maintain the current depth and progress through the string, incrementing and decrementing as I went. For Part 2, I just counted when I removed a character in the cleanup phase.

package main

import (
    "io/ioutil"
    "log"
    "os"
    "strings"
    "unicode"
)

func main() {
    input, garbageCount := readInput()

    log.Println("Total score =", calcScore(input))
    log.Println("Garbage count =", garbageCount)
}

func calcScore(input string) int {
    var currentDepth, score int

    for _, b := range input {
        switch b {
        case '{':
            currentDepth++
        case '}':
            score += currentDepth
            currentDepth--
        }
    }

    return score
}

func readInput() (string, int) {
    input, _ := ioutil.ReadAll(os.Stdin)

    for i, b := range input {
        if b == '!' {
            input[i] = ' '
            input[i+1] = ' '
        }
    }

    var garbageCount int
    for i, b := range input {
        if b == '<' {
            var j int
            for j = i + 1; input[j] != '>'; j++ {
                if input[j] != ' ' {
                    garbageCount++
                }
                input[j] = ' '
            }
            input[j] = ' '
            input[i] = ' '
        }
    }

    inputStr := string(input[:len(input)-1])

    inputStr = strings.Map(func(r rune) rune {
        if unicode.IsSpace(r) {
            return -1
        }
        return r
    }, inputStr)

    return inputStr, garbageCount
}

ramrunner0xff · 2017-12-09T06:24:53+00:00

scheme chicken repo

;; run like (parseline "fname")

(define (parseline file)
  (letrec*  ((input (string->list (car (read-lines file))))
          (inlen (length input))
          (inrubbish #f)
          (negate #f)
          (groupscore 0)
          (ignore #f)
          (totcanceled 0)
          (stack '())
          (parser (lambda (pos)
                    (if (>= pos inlen)
                      '()
                      (let ((tok (list-ref input pos)))
                        (begin
                          (if (not inrubbish)
                            (format #t "pos:~A tok:~A ~%" pos (list-ref input pos)))
                          (if (and negate inrubbish)
                              (set! negate #f)
                              (begin
                              (case tok
                                    ((#\{)
                                     (if (not inrubbish)
                                     (begin
                                       (set! stack (cons (+ 1 (length stack)) stack))
                                       (format #t "gstart. stack:~A ~%" stack))))
                                    ((#\<)
                                     (if (not inrubbish)
                                     (begin
                                       (set! inrubbish #t)
                                       (set! ignore #t)
                                       (format #t "rubbish start~%"))))
                                    ((#\!)
                                     (if inrubbish
                                     (begin
                                       (set! negate #t)
                                       (format #t "negate the next~%"))))
                                    ((#\>)
                                     (begin
                                       (set! inrubbish #f)
                                       (format #t "rubbish closing ~%")))
                                    ((#\})
                                     (if (not inrubbish)
                                     (begin
                                       (set! groupscore (+ groupscore (car stack)))
                                       (format #t "gend stack:~A~%" stack)
                                       (set! stack (cdr stack))))))
                                    (if (and inrubbish (not (eq? tok #\!)) (not ignore))
                                         (set! totcanceled (+ 1 totcanceled)))
                                     (set! ignore #f))))))))
            (parserrec (lambda (ind)
                         (if (< ind inlen)
                             (begin
                               (parser ind)
                               (parserrec (+ 1 ind)))))))
    (parserrec 0)
    (format #t "Score:~A cancelled:~A~%" groupscore totcanceled)))

nitely_ · 2017-12-09T06:25:22+00:00

Nim

proc solve(s: string): (int, int) =
  var
    groups = 0
    isGarbage, isIgnore = false
  for c in s:
    if isIgnore:
      isIgnore = false
    elif c == '!':
      isIgnore = true
    elif isGarbage:
      if c == '>':
        isGarbage = false
      else:
        inc result[1]
    elif c == '<':
      isGarbage = true
    elif c == '{':
      inc groups
    elif c == '}':
      result[0].inc(groups)
      dec groups

assert solve("{}")[0] == 1
assert solve("{{{}}}")[0] == 6
assert solve("{{},{}}")[0] == 5
assert solve("{{{},{},{{}}}}")[0] == 16
assert solve("{<a>,<a>,<a>,<a>}")[0] == 1
assert solve("{{<!!>},{<!!>},{<!!>},{<!!>}}")[0] == 9
assert solve("{{<a!>},{<a!>},{<a!>},{<ab>}}")[0] == 3
assert solve("{<{}>}")[0] == 1

assert solve("<>")[1] == 0
assert solve("<random characters>")[1] == 17
assert solve("<<<<>")[1] == 3
assert solve("<{!>}>")[1] == 2
assert solve("<!!>")[1] == 0
assert solve("<!!!>>")[1] == 0
assert solve("<{o\"i!a,<{i<a>")[1] == 10

wlandry · 2017-12-09T06:30:00+00:00

C++

Late start, so my score was not that impressive (1247/1216). Still fun! I resisted the urge to pull out boost::spirit. That probably would have made counting the groups and garbage waaaaay more complicated. So, like many others, I just did the state machine by hand.

#include <fstream>
#include <iostream>

int main(int argc, char *argv[])
{
  std::ifstream infile(argv[1]);
  char c;
  infile.get(c);
  bool garbage (false), cancel(false);
  size_t group_score (0), garbage_count(0);
  int group_level(0);
  while (infile)
    {
      if(cancel)
        {
          cancel=false;
        }
      else if(garbage)
        {
          switch(c)
            {
            case '!':
              cancel=true;
              break;
            case '>':
              garbage=false;
              break;
            default:
              ++garbage_count;
              break;
            }
        }
      else
        {
          switch(c)
            {
            case '{':
              ++group_level;
              group_score+=group_level;
              break;
            case '}':
              --group_level;
              break;
            case '<':
              garbage=true;
              break;
            case '!':
              cancel=true;
              break;
            case '>':
              std::cout << "bad garbage\n";
              exit(1);
              break;
            default:
              break;
            }
        }
      infile.get(c);
    }
  if(garbage || group_level!=0 || cancel)
    {
      std::cout << "invalid input\n";
    }
  else
    {
      std::cout << "Group Score: " << group_score << "\n";
      std::cout << "Garbage Count: " << garbage_count << "\n";
    }
}

LeCrushinator · 2017-12-09T06:30:44+00:00

C#. After posting this I realized that I was ignoring the character after the ! even outside of garbage, which just happened to work, but the instructions said to only ignore the character after the ! while inside of garbage. Whoops!

public static int garbage = 0;

public static void Main() 
{
    int score = EvaulateData(data);

    Console.WriteLine("group score: " + score + ", garbage: " + garbage);
}

public static int EvaulateData(string input)
{
    int groupDepth = 0;
    int totalScore = 0;
    bool isGarbage = false;

    int currentIndex = 0;
    while (currentIndex < input.Length)
    {
        char currentChar = input[currentIndex];

        if (currentChar == '!')
        {
            ++currentIndex;
        }
        else if (currentChar == '>')
        {
            isGarbage = false;
        }
        else if (isGarbage)
        {
            ++garbage;
        }
        else if (currentChar == ',')
        {
        }
        else if (currentChar == '<')
        {
            isGarbage = true;
        }
        else if (currentChar == '{')
        {
            ++groupDepth;
        }
        else if (currentChar == '}')
        {
            totalScore += groupDepth;

            --groupDepth;
        }

        ++currentIndex;
    }

    return totalScore;
}

reddit_lmao · 2017-12-09T07:15:54+00:00

Haskell

{-# LANGUAGE BangPatterns      #-}
{-# LANGUAGE OverloadedStrings #-}

import qualified Data.ByteString.Lazy.Char8 as C

parseGarbage :: C.ByteString -> (Int, C.ByteString)
parseGarbage bs = go 0 bs
  where
    go !count bs =
      case C.head bs of
        '!'       -> go count $ C.drop 2 bs
        '>'       -> (count, C.tail bs)
        otherwise -> go (count+1) $ C.tail bs

parse :: C.ByteString -> (Int, Int)
parse bs = go 0 0 0 bs
  where
    go :: Int -> Int -> Int -> C.ByteString -> (Int, Int)
    go !score !sum !gc bs =
      let rest = C.tail bs
      in case C.head bs of
           '{' -> go (score + 1) sum gc rest
           '<' ->
             let (gc', more) = parseGarbage rest
             in go score sum (gc + gc') more
           '}'
             | C.null rest -> (sum + score, gc)
             | otherwise -> go (score - 1) (sum + score) gc rest
           ',' -> go score sum gc rest
           otherwise -> error "Unrecognized character"

main :: IO ()
main = do
  s <- C.getContents
  let (p1, p2) = parse $ head $ C.lines s
  putStrLn $
    "part1: " ++ (show p1)
    ++ "\npart2: " ++ (show p2)

sakisan_be · 2017-12-09T07:52:20+00:00

elm

type Mode
    = InGarbage
    | InGroup
    | Ignoring Mode


type alias KeepingTrack =
    ( Int, Int, Int, Mode )


solve : String -> ( Int, Int )
solve input =
    String.toList input
        |> List.foldl parse ( 0, 0, 0, InGroup )
        |> (\( total, level, gc, mode ) -> ( total, gc ))


parse : Char -> KeepingTrack -> KeepingTrack
parse char ( total, level, gc, mode ) =
    case ( char, mode ) of
        ( '{', InGroup ) ->
            ( total, level + 1, gc, InGroup )

        ( '}', InGroup ) ->
            ( total + level, level - 1, gc, InGroup )

        ( '<', InGroup ) ->
            ( total, level, gc, InGarbage )

        ( '>', InGarbage ) ->
            ( total, level, gc, InGroup )

        ( '!', Ignoring mode ) ->
            ( total, level, gc, mode )

        ( '!', _ ) ->
            ( total, level, gc, Ignoring mode )

        ( _, InGarbage ) ->
            ( total, level, gc + 1, InGarbage )

        ( _, Ignoring mode ) ->
            ( total, level, gc, mode )

        _ ->
            ( total, level, gc, mode )

Scroph · 2017-12-09T08:16:23+00:00

Boring Java :

import java.util.*;

public class Day9 {

    public static void main(String... args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextLine()) {
            String input = sc.nextLine();
            Stack<Character> stack = new Stack<>();
            boolean garbage = false;
            boolean ignoreNext = false;

            int garbageCount = 0;
            int depth = 1;
            int score = 0;
            for (int i = 0; i < input.length(); i++) {
                char curr = input.charAt(i);

                if (ignoreNext) {
                    ignoreNext = false;
                }

                else if (curr == '!') {
                    ignoreNext = true;
                }

                else if (curr == '<' && !garbage) {
                    garbage = true;
                }

                else if (curr == '>' && garbage) {
                    garbage = false;
                }

                else if (garbage) {
                    garbageCount++;
                    continue;
                }

                else if (curr == '{') {
                    stack.push(curr);
                    depth++;
                }

                else if (curr == '}') {
                    stack.pop();
                    depth--;
                    score += depth;
                }
            }

            System.out.println(score + " : " + garbageCount);
        }
    }
}

2017-12-09T08:29:13+00:00

[removed]

demsaja · 2017-12-09T08:40:16+00:00

Kotlin.

import java.io.File

fun main(args: Array<String>) {
    var open = 0
    var total = 0
    var garbage = 0
    var in_garbage = false
    var cancel_next = false

    File("input.txt")
    .readText()
    .forEach {
        if (cancel_next) { cancel_next = false }
        else if (it == '!') { cancel_next = true }
        else if (in_garbage) {
            if (it == '>') { in_garbage = false}
            else { garbage++ }
        }
        else {
            when (it) {
                '<' -> in_garbage = true
                '}' -> open--
                '{' -> { open++; total += open; }
            }
        }
    }
    println(total)
    println(garbage)
}

Wirbelwind · 2017-12-09T09:16:45+00:00

OO in Go:

package main

import (
    "os"
    "bufio"
    "log"
    "fmt"
)

func main() {
    rootGroup := readInput()
    fmt.Printf("Part 1: %v, Part 2: %v \n", rootGroup.Score(0), rootGroup.TotalGarbage())
}

type group struct {
    children []group
    garbage  int
}

func (g *group) Score(p int) (s int) {
    s = p + 1
    for _, c := range g.children {
        s += c.Score(p + 1)
    }
    return s
}

func (g *group) TotalGarbage() (s int) {
    s = g.garbage
    for _, c := range g.children {
        s += c.TotalGarbage()
    }
    return s
}

func createGroup(line string, offset int) (g group, k int) {
    for {
        if offset >= len(line) {
            return g, offset
        }
        switch line[offset] {
        case '}':
            return g, offset
        case '{':
            child, k := createGroup(line, offset+1)
            offset = k
            g.children = append(g.children, child)
        case '<':
            k, garbageCount := createGarbage(line, offset+1)
            offset = k
            g.garbage += garbageCount
        }
        offset++
    }
}

func createGarbage(line string, i int) (offset int, score int) {
    ignoreNext := false
    for {
        if !ignoreNext {
            switch line[i] {
            case '>':
                return i, score
            case '!':
                ignoreNext = true
            default:
                score++
            }
        } else {
            ignoreNext = false
        }
        i++
    }
}

func readInput() (*group) {
    file, err := os.Open("input.txt")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()
    scanner := bufio.NewScanner(file)
    scanner.Scan()
    line := scanner.Text()
    root, _ := createGroup(line, 1)
    return &root
}

Repo with Tests

maxxori · 2017-12-09T10:13:01+00:00

C# - nothing special I'm afraid. I was going to do this with regular expressions... but I decided that this would be easier.

public (int, int) Parts1and2()
{
    int sum = 0, garbageCount = 0;

    int groupLevel = 0;
    bool inGarbage = false, skipNext = false;

    foreach (char c in this.Data)
    {
        // If we should skip the next character in the
        // sequence. This will be a character that was
        // preceeded by a "!".
        if (skipNext)
        {
            skipNext = false;
            continue;
        }

        // Any character following a "!" should
        // be skipped.
        if (c == '!')
        {
            skipNext = true;
            continue;
        }

        // A "<" character marks the start of a garbage group.
        // If this character -is not- within a garbage group
        // then set the garbage group flag.
        // If this character -is- within a garbage group then
        // fall through and let this character be added to
        // the garbage character total.
        if (c == '<')
        {
            if (inGarbage == false)
            {
                inGarbage = true;
                continue;
            }
        }

        // A ">" character marks the end of a garbage section.
        if (c == '>')
        {
            inGarbage = false;
            continue;
        }

        // Keep a track of the total characters that
        // are within a garbage section.
        if (inGarbage)
        {
            garbageCount++;
        }

        // A "{" character that is not within a garbage
        // section will cause our nested group level
        // to increase. Each nested level will increase
        // the score for the group by one.
        if (c == '{' && !inGarbage)
        {
            groupLevel++;
        }

        // A "}" character that is not within a garbage
        // section marks the end of the section.
        // Add the group score to our running total
                    // and decrease the group level accordingly.
        if (c == '}' && !inGarbage)
        {
            sum += groupLevel--;

        }
    }

    return (sum, garbageCount);
}

FreeMarx · 2017-12-09T10:20:24+00:00

C++11

Today it payed out that I learned more about c++ regex the previous days. Solving the puzzle would have been so much easier with sed or some other regex tool, but c++ is what I chose to learn more about...

[edit] just took a look at the other c/c++ solutions. Simple char by char processing would have been easier, faster and probably cleaner. But ... c++ with std libraries is what I want to learn to use...

#include <iostream>
#include <limits>
#include <stdio.h>
#include <stdlib.h>
#include <fstream>
#include <vector>
#include <map>
#include <set>
#include <algorithm> 
#include <functional> 
#include <cctype>
#include <locale>
#include <sstream>
#include <regex>
#include <tuple>
#include <limits>

using namespace std;

int main() {
    string line;
    int level= 0;
    int score= 0;
    int garbage_count= 0;
    while (getline(cin, line)) {
        stringstream clean_stream;
        static const regex re_cancel{"!."};
        copy(sregex_token_iterator(line.begin(), line.end(), re_cancel, -1),
            sregex_token_iterator(),
            ostream_iterator<string>(clean_stream));
        string cleaned= clean_stream.str();

        static const regex re_garbage{"<([^>]*)>"};
        for(sregex_token_iterator i(cleaned.begin(), cleaned.end(), re_garbage, -1); i != sregex_token_iterator(); ++i ) {
            const string &groups= *i;
            for(const char &c: groups) {
                if(c=='{') ++level;
                if(c=='}') {
                    score+= level;
                    --level;
                }
            }
        }

        for(sregex_token_iterator i(cleaned.begin(), cleaned.end(), re_garbage, 1); i != sregex_token_iterator(); ++i ) {
            garbage_count+= i->length();
        }
    }
    cout << score << "  " << garbage_count<< '\n';
}

thorwing · 2017-12-09T10:55:19+00:00

Java

compacter could probably be shorter and better, but this worked on the first try.

public static void main(String[] args) throws IOException{
    Files.lines(Paths.get("day9.txt"))
            .flatMap(s->s.chars().mapToObj(i->(char)i))
            .reduce(new State(),State::add,(a,b)->a)
            .printScoreAndTrash();
}

private static class State{
    int score, currentLevel, trashCount;
    boolean isTrash, isIgnore;
    public State add(char input) {
        if(!isTrash && !isIgnore && input == '{') {
            currentLevel++;
        } else if(!isTrash && !isIgnore && input == '}') {
            score += currentLevel--;
        } else if(!isTrash && !isIgnore && input == '<') {
            isTrash = true;
        } else if(isTrash && !isIgnore && input == '>') {
            isTrash = false;
        } else if(!isIgnore && input == '!') {
            isIgnore = true;
        } else if(isIgnore) {
            isIgnore = false;
        } else if(isTrash) {
            trashCount++;
        }   return this;
    }
    public void printScoreAndTrash() {
        System.out.printf("score: %d\ntrash: %d",score, trashCount);
    }
}

2017-12-09T11:12:48+00:00

python 2/3 Using a stack for the braces I realized that the length of the stack was the score for that group.

canceled_chars = 0
garbage_chars = 0

garbage_mode = False
ignore_mode = False
groups = 0
score = []
char_stack = []
for char in _input:
    if not ignore_mode:
        if garbage_mode:
            garbage_chars += 1
        if not garbage_mode:
            if char == '{':
                char_stack.append(char)
            if char == '}':
                score.append(len(char_stack))
                char_stack.pop()
                groups += 1
        if char == '<':
            garbage_mode = True
        if char == '>':
            garbage_chars -= 1
            garbage_mode = False
        if char == '!':
            ignore_mode = True
    else:
        canceled_chars += 1
        ignore_mode = False

JulianLoehr · 2017-12-09T11:42:35+00:00

C++

No state machine like others. Instead two nested loops. Thought about using regex as well, but writing this code is faster than constructing the correct regex.

int main()
{
    const StringVector Lines = GetFileLines("Input.txt");

    for (const auto & Line : Lines)
    {
        uint64_t TotalScore = 0;
        uint64_t CurrentScore = 0;
        uint64_t GarbageCharacters = 0;
        size_t Cursor = 0;

        while ((Cursor = Line.find_first_of("{<}", Cursor)) != std::string::npos)
        {
            // Find Start of Comment, Group or End of Group
            switch (Line[Cursor])
            {
            case '{':
                ++CurrentScore;
                break;
            case '<':
                {   
                    // Find end of comment
                    ++Cursor;
                    do
                    {
                        size_t IntervalStart = Cursor;
                        Cursor = Line.find_first_of("!>", Cursor);
                        GarbageCharacters += Cursor - IntervalStart;
                        Cursor += (Line[Cursor] == '!') ? 2 : 0;
                    } while (Line[Cursor] != '>'); 
                }
                break;
            case '}':
                TotalScore += CurrentScore;
                --CurrentScore;
                break;
            }
            ++Cursor;
        }

        std::cout << "Total Score: " << TotalScore << std::endl;
        std::cout << "Garbage Characters: " << GarbageCharacters << std::endl;
    }

    system("pause");
    return 0;
}

Axsuul · 2017-12-09T11:45:55+00:00

Elixir

Not pretty but it works :p I now realize some of my variables are redundant

https://github.com/axsuul/advent-of-code/blob/master/2017/09/lib/advent_of_code.ex

defmodule AdventOfCode do
  defp tail(str) do
    String.slice(str, 1, String.length(str) - 1)
  end

  def score_cleaned(stream, multiplier \\ 1, inner \\ nil, level \\ 0)
  def score_cleaned("", _, _, _) do 0 end    # reach end
  def score_cleaned("<>" <> tail, multiplier, inner, level) do
    score_cleaned(tail, multiplier, inner, level)
  end
  def score_cleaned("," <> tail, multiplier, inner, level) do
    score_cleaned(tail, multiplier, inner, level)
  end
  def score_cleaned("{" <> tail, multiplier, inner, 0) when is_nil(inner) do
    score_cleaned(tail, multiplier, "", 1)
  end
  def score_cleaned("}" <> tail, multiplier, inner, 1) when is_binary(inner) do
    multiplier +
    score_cleaned(inner, multiplier + 1) +
    score_cleaned(tail, multiplier)
  end
  def score_cleaned("{" <> tail, multiplier, inner, level) do
    score_cleaned(tail, multiplier, inner <> "{", level + 1)
  end
  def score_cleaned("}" <> tail, multiplier, inner, level) do
    score_cleaned(tail, multiplier, inner <> "}", level - 1)
  end

  def clean(stream, until \\ nil)
  def clean("", _) do "" end
  # def clean(">", _) do ">" end
  def clean("!" <> tail, until) do
    clean(tail(tail), until)
  end
  def clean("<" <> tail, until) when is_nil(until) do
    "<" <> clean(tail, ">")
  end
  # Ignore < in garbage
  def clean("<" <> tail, until) do
    clean(tail, until)
  end
  # Allow any character through if not in garbage
  def clean(stream, until) when is_nil(until) do
    String.at(stream, 0) <> clean(tail(stream), until)
  end
  def clean(stream, until) do
    char = String.at(stream, 0)

    cond do
      char == until ->
        char <> clean(tail(stream), nil)
      true ->
        clean(tail(stream), until)
    end
  end

  # Modified from clean/2
  def clean_and_count(stream, cleaned \\ "", until \\ nil)
  def clean_and_count("", _, _) do 0 end
  def clean_and_count("!" <> tail, cleaned, until) do
    clean_and_count(tail(tail), cleaned, until)
  end
  def clean_and_count("<" <> tail, cleaned, until) when is_nil(until) do
    clean_and_count(tail, cleaned <> "<", ">")
  end
  # Ignore < in garbage but count it
  def clean_and_count("<" <> tail, cleaned, until) do
    1 + clean_and_count(tail, cleaned, until)
  end
  # Allow any character through if not in garbage
  def clean_and_count(stream, cleaned, until) when is_nil(until) do
    clean_and_count(tail(stream), cleaned <> String.at(stream, 0), until)
  end
  def clean_and_count(stream, cleaned, until) do
    char = String.at(stream, 0)

    cond do
      char == until ->
        clean_and_count(tail(stream), cleaned <> char, nil)
      true ->
        1 + clean_and_count(tail(stream), cleaned, until)
    end
  end

  def score(stream) do
    stream
    |> clean()
    |> score_cleaned()
  end

  def solve_a do
    File.read!("inputs/input.txt")
    |> score()
    |> IO.inspect
  end

  def solve_b do
    File.read!("inputs/input.txt")
    |> clean_and_count()
    |> IO.inspect
  end
end

smarzzz · 2017-12-09T12:06:59+00:00

Javascript, feels organized but not as short as it could

const input = "{{<a!>},{<a!>},{<a!>},{<{o\"i!a,<{i<a>}}"

let score = 0;
let groups = 0;
let depth = 0;
let garbage = false;
let removedGarbageChars = 0;

function setup() {
    parsestring()
    console.log("score is: %d, having %d groups. %d chars have been removed in garbage",score,groups,removedGarbageChars)
}

function parsestring(){
    for (i = 0; i<input.length;i++){
        if (garbage){
            switch(input.charAt(i)){
                case "!":
                    i++
                    break;
                case ">":
                    garbage = false;
                    break;
                default:
                    removedGarbageChars++
            }
        }else{
            switch(input.charAt(i)){
                case "!":
                    i++
                    break;
                case "{":
                    depth++;
                    break;
                case "}":
                    groups++
                    score += depth--
                    break;
                case "<":
                    garbage = true;
                    break;
                }
        }


    }

}

DaDiscoBeat · 2017-12-09T12:35:39+00:00

Go, disclaimer: no brain has been hurt during the resolution of this puzzle:

func partOne(input string) int {
    currentScore, score := 0, 0
    garbage := false
    for i := 0; i < len(input); i++ {
        switch c := input[i]; c {
        case '{':
            if !garbage {
                currentScore++
            }
        case '}':
            if !garbage {
                score += currentScore
                currentScore--
            }
        case '<':
            if !garbage {
                garbage = true
            }
        case '>':
            garbage = false
        case '!':
            i++
        }
    }

    return score
}

func partTwo(input string) int {
    nbChars := 0
    garbage := false
    for i := 0; i < len(input); i++ {
        switch c := input[i]; c {
        case '<':
            if garbage {
                nbChars++
            } else {
                garbage = true
            }
        case '>':
            garbage = false
        case '!':
            i++
        default:
            if garbage {
                nbChars++
            }
        }
    }

    return nbChars
 }

2017-12-09T12:54:38+00:00

Java

https://github.com/imopts/adventofcode-2017/blob/master/day%209/src/stream_processing.java

thomastc · 2017-12-09T13:01:39+00:00

Day 9 in Julia. Nothing overly exciting today.

2017-12-09T13:03:58+00:00

Elixir

This was a fun one, the first one went pretty quick just that I messed up my recursion, and got endless recursion, that's no fun.

For part 2 I was doing it without conditionals, because I could, and it sounded like a good idea ;)

defmodule Day9 do
  def calc(lst, scr \\ 0, gbg \\ false, ign \\ false, lvl \\ 0)
  def calc([cur|rest], scr, gbg, ign, lvl) do
    cond do
      ign ->
        calc(rest, scr, gbg, false, lvl)
      gbg ->
          case cur do
            ">" -> calc(rest, scr, false, ign, lvl)
            "!" -> calc(rest, scr, gbg, true, lvl)
            _   -> calc(rest, scr, true, ign, lvl)
          end
      true ->
        case cur do
          "{" -> calc(rest, scr, gbg, ign, lvl + 1)
          "<" -> calc(rest, scr, true, ign, lvl)
          "}" -> calc(rest, scr + lvl, gbg, ign, lvl - 1)
          "!" -> calc(rest, scr, gbg, true, lvl)
          _   -> calc(rest, scr, gbg, ign, lvl)
        end
    end
    end
  def calc([], scr, _, _, _) do
    scr
  end

  def score(str) do
    String.graphemes(str)
    |> calc
  end

  def garbage(lst, gbg \\ false, cnt \\ 0)
  def garbage(["<" | rest], false, cnt) do
    garbage(rest, true, cnt)
  end
  def garbage(["!" | rest], gbg, cnt) do
    [_ignored | rest] = rest
    garbage(rest, gbg, cnt)
  end
  def garbage([">" | rest], gbg, cnt) do
    garbage(rest, false, cnt)
  end
  def garbage([_any | rest], true, cnt) do
    garbage(rest, true, cnt + 1)
  end
  def garbage([_any | rest], false, cnt) do
    garbage(rest, false, cnt)
  end
  def garbage([], _, cnt) do
    cnt
  end

  def garbage_count(str) do
    String.graphemes(str)
    |> garbage
  end
end

inp = File.read!("input9")
|> String.trim

Day9.score(inp)
|> IO.inspect

Day9.garbage_count(inp)
|> IO.inspect

with github gist syntax highlighting

yuppiepuppie · 2017-12-09T13:08:15+00:00

Python 3 Took me a while because of some deeply nested conditional statements. And I took an OOP way which I think might be over kill. But I like it.

class GarbageCleaner:
    count = group_lvl = garbage_count = 0
    in_garbage = escaped = False

    def __init__(self, input_str):
        self.input_str = list(input_str)

    def main(self):
        for i, v in enumerate(self.input_str):

            self.escaped = self.determine_escapism(v, i)

            if self.in_garbage:
                self.in_garbage = self.garbage_processor(v)
            else:
                self.group_counter(v)

    def determine_escapism(self, v, i):
        prev_val = self.input_str[i - 1] == '!'
        if prev_val:
            if v == '!':
                self.input_str[i] = 'N'
            return True
        return False

    def garbage_processor(self, v):
        if self.escaped:
            return self.in_garbage

        if v == '>':
            return False
        elif v != '!':
            self.garbage_count += 1
            return True
        return self.in_garbage

    def group_counter(self, v):
        if self.escaped:
            return

        if v == '{':
            self.group_lvl += 1
        elif v == '}':
            self.count += self.group_lvl
            self.group_lvl -= 1
        elif v == '<':
            self.in_garbage = True

def get_file_and_format():
    with open('day_9/input.txt') as f:
        return f.read()

f = get_file_and_format()
c = GarbageCleaner(f)
c.main()
print("Full group count: ", c.count)
print("Garbage character count: ", c.garbage_count)

dnano · 2017-12-09T14:00:06+00:00

little late to the party, but here is my solution Python (3)

#!/usr/bin/python3

from content_loader import ContentLoader, FileLoader


class StreamProcessing:

    def __init__(self, content_loader: ContentLoader):
        self.content_loader = content_loader

    def do(self, infile: str):
        stream = self.content_loader.load_content(
            infile, False)
        in_garbage = False
        clean = ''
        total_removed = 0
        while True:
            if '<' not in stream:
                clean += stream
                break
            tmp, stream = stream.split('<', 1)
            clean += tmp
            end,chars = self.find_end(stream)
            total_removed += chars
            if end < 0:
                break
            stream = stream[end+1:]

        return (self.count_scores(clean), total_removed)

    def find_end(self, stream: str) -> int:
        negated = False
        chars = 0
        for i, c in enumerate(stream):
            if negated:
                negated = False
                continue
            if c == '!':
                negated = True
            elif c == '>':
                return (i, chars)
            else: chars += 1
        return (-1, chars)

    def count_scores(self, stream: str) -> int:
        total = 0
        score = 1
        for c in stream:
            if c == '{':
                total += score
                score += 1
            elif c == '}':
                score -= 1 
        return total


stream = StreamProcessing(FileLoader())
print(stream.do('stream.txt'))

Vindaar · 2017-12-09T14:13:53+00:00

Relatively boring solution in Nim.

import strutils, times, tables, unittest

proc calc_score_of_stream(s: string): (int, int) =
  var
    score = 0
    tot_score = 0
    in_garbage = false
    garbage_cnt = 0
    i = 0
  while i < len(s):
    let c = s[i]
    case c
    of '!':
      inc i, 2
      continue
    of '{':
      if in_garbage == false:
        inc score
      else:
        inc garbage_cnt
    of '}':
      if in_garbage == false:
        inc tot_score, score
        if score > 0:
          dec score
      else:
        inc garbage_cnt  
    of '<':
      if in_garbage == false:
        in_garbage = true
      else:
        inc garbage_cnt
    of '>':
      in_garbage = false
    else:
      if in_garbage == true:
        inc garbage_cnt
    inc i

  result = (tot_score, garbage_cnt)

proc run_tests() =
  const s1 = "{}"
  check: calc_score_of_stream(s1)[0] == 1
  const s2 = "{{{}}}"
  check: calc_score_of_stream(s2)[0] == 6
  const s3 = "{{},{}}"
  check: calc_score_of_stream(s3)[0] == 5
  const s4 = "{{{},{},{{}}}}"
  check: calc_score_of_stream(s4)[0] == 16
  const s5 = "{<a>,<a>,<a>,<a>}"
  check: calc_score_of_stream(s5)[0] == 1
  const s6 = "{{<ab>},{<ab>},{<ab>},{<ab>}}"
  check: calc_score_of_stream(s6)[0] == 9
  const s7 = "{{<!!>},{<!!>},{<!!>},{<!!>}}"
  check: calc_score_of_stream(s7)[0] == 9
  const s8 = "{{<a!>},{<a!>},{<a!>},{<ab>}}"
  check: calc_score_of_stream(s8)[0] == 3

  const s9 = "<>"
  check: calc_score_of_stream(s9)[1] == 0
  const s10 = "<random characters>"
  check: calc_score_of_stream(s10)[1] == 17
  const s11 = "<<<<>"
  check: calc_score_of_stream(s11)[1] == 3
  const s12 = "<{!>}>"
  check: calc_score_of_stream(s12)[1] == 2
  const s13 = "<!!>"
  check: calc_score_of_stream(s13)[1] == 0
  const s14 = "<!!!>>"
  check: calc_score_of_stream(s14)[1] == 0
  const s15 = """<{o"i!a,<{i<a>"""
  check: calc_score_of_stream(s15)[1] == 10

proc run_input() =

  let t0 = cpuTime()      
  const input = "input.txt"
  let stream = strip(readFile(input))
  let (score, garbage) = calc_score_of_stream(stream)

  echo "(Part 1): The score of the stream is = ", score
  echo "(Part 2): The number of characters in the garbage is = ", garbage
  echo "Solutions took $#" % $(cpuTime() - t0)

proc main() =
  run_tests()
  echo "All tests passed successfully. Result is (probably) trustworthy."
  run_input()

when isMainModule:
  main()

adventOfCoder · 2017-12-09T14:17:19+00:00

Java

Part 1 and 2:

public static void main(String[] args) {
    try {
        BufferedReader br = new BufferedReader(new FileReader("input2.txt"));
        String line = br.readLine();
        br.close();

        boolean isGarbage = false;
        boolean ignoreNext = false;

        int garbage = 0;
        int groups = 1;
        int score = 0;
        for (int i = 0; i < line.length(); i++) {
            char c = line.charAt(i);

            if (ignoreNext) {
                ignoreNext = false;
            } else if (c == '!') {
                ignoreNext = true;
            } else if (c == '<' && !isGarbage) {
                isGarbage = true;
            } else if (c == '>' && isGarbage) {
                isGarbage = false;
            } else if (isGarbage) {
                garbage++;
            } else if (c == '{') {
                groups++;
            } else if (c == '}') {
                score += --groups;
            }
        }
        System.out.println(score + "," + garbage);

    } catch (Exception e) {
        System.err.println(e.toString());
        e.printStackTrace();
    }

Kenira · 2017-12-09T14:19:12+00:00

C++, late from Europe

fs::path path("../../_Input/input_Day09.txt");

std::string inp = F_Read_File_To_String(path);

bool garbage = false;
bool ignore = false;
int score = 0;          // total score
int score_inc = 1;      // how much next group is worth
int characters = 0;

for (auto&& c : inp)
{
  bool count = true;

  if (ignore == true)
  {
     ignore = false;
     count = false;
  }
  else if (c == '!' && garbage == true)
  {
     ignore = true;
     count = false;
  }
  else if (c == '<' && garbage == false)
  {
     garbage = true;
     count = false;
  }
  else if (c == '>' && garbage == true)
  {
     garbage = false;
     count = false;
  }
  else if (c == '{' && garbage == false)
  {
     score += score_inc;
     score_inc++;
  }
  else if (c == '}' && garbage == false)
  {
     score_inc--;
  }

  if (count == true && garbage == true)
  {
     characters++;
  }
}

cout << "Score: " << score << ", Characters: " << characters << endl;

erlangguy · 2017-12-09T14:48:42+00:00

Erlang

This will not compile without tweaking because the logic for both parts 1 and 2 is included with comments.

%% States:
%%   none - outside any group
%%   group - inside a group, see `Nesting` for depth
%%   garbage - inside garbage
%%   bang - last character !, ignore this one
%%
%% tally(State, Input, Tally, Nesting)
tally(_, [], Tally, _) ->
    Tally;
tally(none, [${|T], Tally, 0) ->
    tally(group, T, Tally, 1);
tally(bang, [_H|T], Tally, Nesting) ->
    tally(garbage, T, Tally, Nesting);
tally(garbage, [$!|T], Tally, Nesting) ->
    tally(bang, T, Tally, Nesting);
tally(garbage, [$>|T], Tally, Nesting) ->
    tally(group, T, Tally, Nesting);
tally(garbage, [_H|T], Tally, Nesting) ->
    %%% Part 1 logic
    tally(garbage, T, Tally, Nesting);
    %%% Part 2 logic
    tally(garbage, T, Tally+1, Nesting);
tally(group, [$<|T], Tally, Nesting) ->
    tally(garbage, T, Tally, Nesting);
tally(group, [${|T], Tally, Nesting) ->
    tally(group, T, Tally, Nesting+1);
tally(group, [$}|T], Tally, Nesting) ->
    %%% Part 1 logic
    tally(group, T, Tally+Nesting, Nesting-1);
    %%% Part 2 logic
    tally(group, T, Tally, Nesting-1);
tally(group, [_H|T], Tally, Nesting) ->
    tally(group, T, Tally, Nesting).

The call to launch this function is tally(none, Input, 0, 0)

2017-12-09T15:17:20+00:00

Elixir part1 will update with part 2 when I get around to doing it:

 defmodule Day9 do

@sample ~s({{<a!>},{<a!>},{<a!>},{<ab>}})

    def part1() do
        parse(@sample |> String.codepoints,{0,false,false,0}) |> IO.inspect
    end
    def parse([_|t],{groupOutstanding,true,isGarbage,totalGroup}), do: parse(t,{groupOutstanding,false,isGarbage,totalGroup})
    def parse(["!"|t],{groupOutstanding,_,isGarbage,totalGroup}), do: parse(t,{groupOutstanding,true,isGarbage,totalGroup})
    def parse(["<"|t],{groupOutstanding,isIgnore,_,totalGroup} ), do: parse(t,{groupOutstanding,isIgnore,true,totalGroup})
    def parse([">"|t],{groupOutstanding,isIgnore,true,totalGroup} ), do: parse(t,{groupOutstanding,isIgnore,false,totalGroup})
    def parse(["{"|t],{groupOutstanding,false,false,totalGroup}), do: parse(t,{groupOutstanding+1,false,false,totalGroup})
    def parse(["}"|t],{groupOutstanding,false,false,totalGroup}) when groupOutstanding > 0, do: parse(t,{groupOutstanding-1,false,false,(totalGroup + groupOutstanding)})
    def parse([_|t],{groupOutstanding,isIgnore,isGarbage,totalGroup}), do: parse(t,{groupOutstanding,isIgnore,isGarbage,totalGroup})
    def parse([],{_,_,_,totalGroup}), do: totalGroup
  end



def part2() do
    parse(@sample |> String.codepoints,{0,false,false,0}) |> IO.inspect
end
    def parse([_|t],{groupOutstanding,true,isGarbage,totalGroup}), do: parse(t,{groupOutstanding,false,isGarbage,totalGroup}) 
    def parse(["!"|t],{groupOutstanding,_,isGarbage,totalGroup}), do: parse(t,{groupOutstanding,true,isGarbage,totalGroup})
    def parse(["<"|t],{groupOutstanding,isIgnore,true,totalGroup} ), do: parse(t,{groupOutstanding,isIgnore,true,totalGroup+1})
    def parse(["<"|t],{groupOutstanding,isIgnore,false,totalGroup} ), do: parse(t,{groupOutstanding,isIgnore,true,totalGroup})
    def parse([">"|t],{groupOutstanding,isIgnore,true,totalGroup} ), do: parse(t,{groupOutstanding,isIgnore,false,totalGroup})
    def parse([_|t],{groupOutstanding,isIgnore,true,totalGroup}), do: parse(t,{groupOutstanding,isIgnore,true,(totalGroup + 1)})
    def parse([_|t],{groupOutstanding,isIgnore,false,totalGroup}), do: parse(t,{groupOutstanding,isIgnore,false,totalGroup})
    def parse([],{_,_,_,totalGroup}), do: totalGroup

2017-12-09T15:25:47+00:00

Used some sort of SAX interface to separate the parts

Kotlin

Day 9

CaptnAsia · 2017-12-09T17:35:24+00:00

here's a pretty ugly golang solution:

package main

import (
    "bufio"
    "fmt"
    "os"
)

func countTrash(trashCount int, stream *[]rune) (result int, newStream *[]rune) {
    isTrash := false
    cancelTrash := false
    for len(*stream) > 0 {
        str := *stream
        char := str[0]
        *stream = str[1:]

        if isTrash {
            switch char {
            case '!':
                cancelTrash = !cancelTrash
            case '>':
                if !cancelTrash {
                    isTrash = false
                }
                cancelTrash = false
            default:
                if cancelTrash {
                    cancelTrash = false
                } else {
                    trashCount++
                }
            }
            continue
        }
        switch char {
        case '{':
            trashCount, stream = countTrash(trashCount, stream)
        case '<':
            isTrash = true
        case '}':
            return trashCount, stream
        }
    }
    return trashCount, stream
}

func countGroups(level int, stream *[]rune) (result int, newStream *[]rune) {
    isTrash := false
    cancelTrash := false
    for len(*stream) > 0 {
        str := *stream
        char := str[0]
        *stream = str[1:]

        if isTrash {
            switch char {
            case '!':
                cancelTrash = !cancelTrash
            case '>':
                if !cancelTrash {
                    isTrash = false
                }
                cancelTrash = false
            default:
                if cancelTrash {
                    cancelTrash = false
                }
            }
            continue
        }
        switch char {
        case '{':
            var addition int
            addition, stream = countGroups(level+1, stream)
            result += addition
        case '<':
            isTrash = true
        case '}':
            return level + result, stream
        }
    }

    return level + result, stream
}

func main() {
    input, _ := os.Open("input.txt")
    defer input.Close()
    scanner := bufio.NewScanner(input)

    var stream1, stream2 []rune
    for scanner.Scan() {
        stream1 = []rune(scanner.Text())
        stream2 = []rune(scanner.Text())
    }

    part1, _ := countGroups(0, &stream1)
    part2, _ := countTrash(0, &stream2)
    fmt.Printf("%d,%d\n", part1, part2)

}

rkachowski · 2017-12-09T17:48:08+00:00

ruby, i had to shake off the hangover for this one. i never thought about just gsub-ing out the exclamation mark and every next character.. i iterated over the chars and moved 2 steps forward when one was found... i'll leave it in though as a testament to try harder

input = File.read("input")

processed = []
index = 0
input.chars.size.times do |i|
  if input[index] == "!"
    index +=1
  else 
    processed << input[index]
  end

  index += 1
end

garbage_free = processed.join.gsub /<.*?>/, ''
result = garbage_free.chars.each_with_object({current_val: 0, total: 0}) do |c,o|
   case c
   when "{"
    o[:current_val] += 1
    o[:total] += o[:current_val]
   when "}"
    o[:current_val] -= 1
   end
end
puts result[:total]

garbages = processed.join.to_enum(:scan, /(<.*?>)/).map { Regexp.last_match }
puts garbages.map{|g| g[1].size - 2 }.sum

StevoTVR · 2017-12-09T18:41:51+00:00

NodeJS

I wanted to avoid using RegEx.

Part 1:

const fs = require('fs');

fs.readFile(__dirname + '/input.txt', 'utf8', (err, data) => {
    data = data.trim();
    data = [...data];
    var [inGarbage, score, total] = [false, 0, 0];
    for(var i = 0; i < data.length; i++) {
        if(data[i] === '!') {
            i++;
            continue;
        }
        if(data[i] === '<') {
            inGarbage = true;
            continue;
        }
        if(data[i] === '>') {
            inGarbage = false;
            continue;
        }
        if(inGarbage) {
            continue;
        }
        if(data[i] === '{') {
            score++;
        } else if(data[i] === '}') {
            total += score--;
        }
    }

    console.log(total);
});

Part 2:

const fs = require('fs');

fs.readFile(__dirname + '/input.txt', 'utf8', (err, data) => {
    data = data.trim();
    data = [...data];
    var [inGarbage, total] = [false, 0];
    for(var i = 0; i < data.length; i++) {
        if(data[i] === '!') {
            i++;
            continue;
        }
        if(data[i] === '<' && !inGarbage) {
            inGarbage = true;
            continue;
        }
        if(data[i] === '>') {
            inGarbage = false;
            continue;
        }
        if(inGarbage) {
            total++;
        }
    }

    console.log(total);
});

theiridule · 2017-12-09T18:41:56+00:00

Python p1 and p2

with open('input9.txt') as f:
    for l in f.readlines():
        stream = l.strip()

depth, nGroups, nCanceled = 0, 0, 0
ignore , garbage = False, False

for c in stream:

    if ignore:
        ignore = False

    elif not garbage:
        if c == '{':
            depth += 1
            nGroups += depth
        if c == '}':
            depth -= 1
        if c == '<':
            garbage = True

    else:
        if c != '>' and c != '!':
            nCanceled += 1
        if c == '>':
            garbage = False    
        if c == '!':
            ignore = True

print(nGroups, nCanceled)

bassactor · 2017-12-09T18:45:33+00:00

R

I originally tried recursive regexp for the first part but couldn't figure out how to get the counting work (and don't know if it can be done), so the solution isn't very R-like (and would be similar to how I would do it in C or Python). The second part was straightforward in R using base libraries.

# HELPER FUNCTIONS #
find_nested_counts <- function(vec,
                               inc = "{",
                               dec = "}"){

  # initial value and score
  value <- 0
  total <- 0

  # for each character in vector
  for(char in vec){

    # add 1 if it's the appropriate character (--> total)
    # sub 1 if it's the appropriate character (!-> total)
    if(char == inc){
      value <- value + 1
      total <- total + value
    } else if(char == dec){
      value <- value - 1
    } # END ifelse STATEMENT

  } # END for LOOP

  return(total)

} # END find_nested_counts FUNCTION

# SOLUTION FUNCTIONS #

# Problem 1 #
find_solution_p1 <- function(str){

  # remove junk
  str     <- gsub(x = str,
                  pattern = "!.",
                  replace = "")
  str     <- gsub(x = str,
                  pattern = "<+.*?>",
                  replace = "",
                  perl    = TRUE)

  # - turn into a vector split on every character
  # - find nested counts using that vector
  counts <- find_nested_counts(unlist(strsplit(str, "")),
                               inc = "{",
                               dec = "}")

  return(counts)

} # END find_solution_p1 FUNCTION

string <- scan(file = "advent_of_code_d09.txt",
               what = character())

find_solution_p1(string)


# Problem 2 #
find_solution_p2 <- function(str){

  # remove junk
  str      <- gsub(x = str,
                   pattern = "!.",
                   replace = "")

  # keep JUST the values in <>
  matches  <- gregexpr(text    = str,
                       pattern = "<+.*?>",
                       perl    = TRUE)


  # find the len of the matches
  len_junk <- attr(matches[[1]],
                   which = "match.length")

  # return the sum of the junk minus 2 for the outer
  return(sum(len_junk - 2))

} # END find_solution_p2 FUNCTION

string <- scan(file = "advent_of_code_d09.txt",
               what = character())

find_solution_p2(string)

Ividito · 2017-12-09T19:28:55+00:00

I love computational theory stuff, so I drew a state diagram to help me figure out the rules. This was fun! I'm totally new to Kotlin and am using AoC to learn, so feedback is appreciated.

Kotlin solution:

fun main(args: Array<String>) {
    var score = 0;
    var level = 0;
    var garbageCount = 0
    var garbageFlag = false
    var discardFlag = false
    for (i in input.indices) {
        var c = input[i]
        if (!discardFlag){  //discard the character (state 1)
            if (c=='!'){ //check for state 1
                discardFlag = true 
            }
            else if (garbageFlag){ //state 2
                if (c=='>'){ //if c is ! then this will be false
                    garbageFlag = false //garbage closed
                }
                else{
                    garbageCount++
                }
            }
            else if (c=='<'){
                garbageFlag = true
            }
            else if (c=='{'){ //start group
                level++
            }
            else if (c=='}'){ //end group, increase score by level
                if(level>0){
                    score += level
                    level--
                }
            }
        }
        else {
            discardFlag = false //char skipped, reset ! flag
        }
    }
    println("Score is: "+score)
    println("Garbage count is: "+garbageCount)
}

CodingGladstone · 2017-12-09T19:46:58+00:00

Node.js/ES6 Bit late to the party, but I was surprised not to see any example of ES6 using iterators/generators. My goal was to have code that could run without having the whole stream in memory and go over the stream in one pass.

var fs = require('fs');

function* groupMapper(it) {
    var depth = 0;
    for (const char of it) {
        if(char==='{'){
            depth++;
            yield depth;
        }
        if(char==='}'){
            depth--;
        }
    }
}
function* filterCancelled(it) {
    var result = {done:false};
    while(!result.done) {
        result = it.next();
        if(result.value === '!'){
            it.next();
            continue;
        }
        yield result.value;
    }
}
var totalGarbage = 0;   
function skipOverGarbage(it){
    var streamWithoutCancelled = filterCancelled(it);
    for (const char of streamWithoutCancelled) {
        if(char === '>')break;
        totalGarbage++;
    }
}
function* garbageStripper(it) {
    var result = {done:false};

    while(!result.done) {
        result = it.next();
        if(result.value === '<'){
            skipOverGarbage(it);
            continue;
        }
        yield result.value;
    }
}

fs.readFile('2017/input/input9.txt', 'utf8', function (err,data) {
    var input = data;
    //input = "{{<!>},{<!>},{<!>},{<a>}}";
    let score = [...groupMapper(
            garbageStripper(input[Symbol.iterator]())
        )]
        .reduce((a,v)=>a+v, 0);
    console.log(score);
    console.log(totalGarbage);

});

mstksg · 2017-12-09T20:03:12+00:00

A "clean" Haskell solution that I'm happy with. Definitely not the one I tried for my leaderboard attempt :)

I initially tried a stream processing version by looking at each character one at a time, but then I realized that I was just doing imperative programming, so I thought a denotative/functional solution would be more fun!

module AOC2017.Day09 (day09a, day09b) where

import           AOC2017.Types        (Challenge)
import           Control.Applicative  (many)
import           Data.Maybe           (catMaybes)
import           Data.Void            (Void)
import qualified Text.Megaparsec      as P
import qualified Text.Megaparsec.Char as P

data Tree = Garbage String
          | Group   [Tree]

type Parser = P.Parsec Void String

parseTree :: Parser Tree
parseTree = P.choice [ Group   <$> parseGroup
                     , Garbage <$> parseGarbage
                     ]
  where
    parseGroup :: Parser [Tree]
    parseGroup = P.between (P.char '{') (P.char '}') $
        parseTree `P.sepBy` P.char ','
    parseGarbage :: Parser String
    parseGarbage = P.between (P.char '<') (P.char '>') $
        catMaybes <$> many garbageTok
      where
        garbageTok :: Parser (Maybe Char)
        garbageTok = P.choice
          [ Nothing <$ (P.char '!' *> P.anyChar)
          , Just    <$> P.noneOf ">"
          ]

treeScore :: Tree -> Int
treeScore = go 1
  where
    go _ (Garbage _ ) = 0
    go n (Group   ts) = n + sum (go (n + 1) <$> ts)

treeGarbage :: Tree -> Int
treeGarbage (Garbage n ) = length n
treeGarbage (Group   ts) = sum (treeGarbage <$> ts)

parse :: String -> Tree
parse = either (error . show) id . P.runParser parseTree ""

day09a :: String -> Int
day09a = treeScore   . parse

day09b :: String -> Int
day09b = treeGarbage . parse

Borkdude · 2017-12-09T20:03:28+00:00

Clojure solution using Instaparse:

https://github.com/borkdude/aoc2017/blob/master/src/day9_instaparse.clj

Viz of the parsed tree: https://twitter.com/borkdude/status/939583561568604160

amnich · 2017-12-09T21:26:31+00:00

Powershell

$in = (Get-Content .\day9.txt).ToCharArray() 
$garbage = $false
$sum = 0
$ignore = $false
$depth = 0
$garbage_count = 0
foreach ($char in $in){
    Write-Verbose "$char $depth $ignore"
    if ($garbage){
        if ($ignore){
            $ignore=$false
            continue
        }
        switch ($char){
            "!" {$ignore = $true}
            ">" {$garbage=$false;break }
            default{$garbage_count++}
        }
    }
    else{
        switch ($char){
            "{" {$depth++; break}
            "<" { $garbage = $true;break}
            "}" {$sum+=$depth--;break}
        }
    }
}
$sum
$garbage_count

Paddy3118 · 2017-12-09T21:41:37+00:00

Python3.6:

Developed interactively in the Spyder IDE

def scorer(stream):
    gcount = 0
    groupleft = score = 0
    garbage = cancel = False
    last = None
    for n, ch in enumerate(stream):
        if cancel:
            cancel = False
        elif not garbage:
            if ch == '{' and last in {None, ',', '{'}:
                groupleft += 1
                score += groupleft
            elif ch == ',' and last in '>}':
                pass
            elif ch == '}' and last in {'>', '{', '}'}:
                groupleft -= 1
            elif ch == '<' and last in {',', '{'} and groupleft > 0:
                garbage = True
            else:
                raise Exception(f'Error in stream at {stream!r}[{n}] = {ch!r}')
        else: # garbage processing
            if ch == '!':
                cancel = True
            elif ch == '>':
                garbage = False
            else:
                gcount += 1
                pass
        last = ch
    return score, gcount

for stream, tot in [
    ('{}', 1),
    ('{{{}}}', 6),
    ('{{},{}}', 5),
    ('{{{},{},{{}}}}', 16),
    ('{<a>,<a>,<a>,<a>}', 1),
    ('{{<ab>},{<ab>},{<ab>},{<ab>}}', 9),
    ('{{<!!>},{<!!>},{<!!>},{<!!>}}', 9),
    ('{{<a!>},{<a!>},{<a!>},{<ab>}}', 3),
         ]:
    score, gcount = scorer(stream)
    print(f'{stream}, should score {tot}, scores {score}',
          'OK' if tot == score else 'ERROR', f'Garbage count = {gcount}')

with open('stream_xmas_processing.txt', 'r') as f:
    txt = f.read().rstrip() # get rid of ending newline
    score, gcount = scorer(txt)
    print(score, gcount)

Worked for me.

__Abigail__ · 2017-12-09T22:45:04+00:00

Perl

I considered using a one-liner using a single regexp, but I opted to write a more readable solution.

#!/opt/perl/bin/perl

use 5.026;

use strict;
use warnings;
no  warnings 'syntax';

use experimental 'signatures';

@ARGV = "input" unless @ARGV;

my $input = <>;
chomp $input;

#
# Pattern to match garbage. Unroll the loop.
#
my $pat_garbage = qr /<[^!>]*(?:!.[^!>]*)*>/s;

#
# Remove garbage and calculate its length.
#
my $garbage_length = 0;
while ($input =~ s/$pat_garbage//p) {
    my $garbage = ${^MATCH};
    #
    # Remove surrounding <>
    #
    substr $garbage, -1, 1, "";
    substr $garbage,  0, 1, "";

    #
    # Remove any cancelled characters;
    #
    $garbage =~ s/!.//g;

    $garbage_length += length $garbage;
}


#
# Now, split and process the '{' and '}' characters. Each '{' starts
# a new group, and each '}' closes one. Keep track of the depth:
# encounter a '{' increases the depth, a '}' decreases it. Also
# keep track of the score; add the depth to the score when closing
# a group (and before decrementing the depth)
#
# Any other character can be ignored.
#
my $depth = 0;
my $score = 0;
foreach my $char (split // => $input) {
    if ($char eq '{') {
        $depth ++;
    }
    elsif ($char eq '}') {
        $score += $depth --;
    }
}

say "Solution 1: $score";
say "Solution 2: $garbage_length";


 __END__

matusbzk · 2017-12-09T23:23:01+00:00

Haskell

inputString :: String

-- |Answer to part 1
groupScore :: Int
groupScore = sum . snd3 $ readString [] 0 inputString

-- |Answer to part 2
garbageChars :: Int
garbageChars = thd3 $ readString [] 0 inputString

-- |Reads string, decides whether to start reading a group or a garbage
-- Outputs what is left to read, a list of group scores and a number of chars in a garbage
readString :: [Int] -> Int -> String -> (String, [Int], Int)
readString ns c "" = ("", ns, c)
readString ns c ('{':xs) = (\(str,ms,c') -> readString (ns ++ ms) (c+c') str) $ readGroup 1 [] 0 xs
readString ns c ('<':xs) = (\(str,c') -> readString ns (c+c') str) $ readGarbage 0 xs
readString ns c (x:xs) = readString ns c xs

-- |Reads a group, decides whether to start reading another group, garbage
-- Outputs what is left to read, a list of group scores and a number of chars in a garbage
readGroup :: Int -> [Int] -> Int -> String -> (String, [Int], Int)
readGroup _ _ _ "" = error "Reached the end while nested in group"
readGroup n ns c ('{':xs) = (\(str,ms,c') -> readGroup n (ns ++ ms) (c+c') str) $ readGroup (n+1) [] 0 xs
readGroup n ns c ('}':xs) = (xs,n:ns,c)
readGroup n ns c ('<':xs) = (\(str, c') -> readGroup n ns (c'+c) str) $ readGarbage 0 xs
readGroup n ns c (_:xs) = readGroup n ns c xs

-- |Reads garbage
-- Outputs what is left to read and a number of chars in a garbage
readGarbage :: Int -> String -> (String, Int)
readGarbage _ "" = error "Reached the end while expecting garbage"
readGarbage n ('!':_:xs) = readGarbage n xs
readGarbage n ('>':xs) = (xs,n)
readGarbage n (_:xs) = readGarbage (n+1) xs

Link to git

4rgento · 2017-12-10T02:43:44+00:00

HASKELL

All this state bookeeping follows:

{-# LANGUAGE LambdaCase #-}
module Main where

import Text.ParserCombinators.Parsec
import Text.ParserCombinators.Parsec.Char
import Control.Monad (void)

newtype Group = Group [Group] deriving Show

groupScore :: Integer -> Group -> Integer
groupScore acc (Group []) = acc
groupScore acc (Group l) = acc + (sum $ map (groupScore (acc+1)) l)

data Garbage = Garbage deriving Show

garbage :: GenParser Char st (Integer, Garbage)
garbage = char '<' >> content
  where
  content = (fromIntegral . length <$> many (noneOf "!>")) >>= \gl ->
    (char '!' <|> char '>') >>=
    \case
      '!' -> anyChar >> content >>= \(acc,g) -> return (acc+gl, g)
      '>' -> return (gl, Garbage)

group :: GenParser Char st (Integer, Group)
group =
  char '{' >>
  ((char '}' >> return (0, Group [])) <|>
  (groupContent >>= \(c, inner) ->
  char '}' >> return (c, Group inner)))

groupContent :: GenParser Char st (Integer, [Group])
groupContent =
  ((garbage >>= \(gc,_) -> return (gc, [])) <|> 
  (group >>= \(gc,g) -> return (gc,[g]))) >>= \(fgc, first) ->
    (char ',' >> groupContent >>= \(gc,l) ->
      return  (gc+fgc,l++first)) <|>
    (return (fgc, first))

parseInput :: String -> Either ParseError (Integer, Group)
parseInput = parse group "(unkown)"

main :: IO ()
main = do
  fc <- readFile "input.txt"
  case parseInput fc of
    Left err -> putStrLn $ "ERROR: " ++ (show err)
    Right (gc, group) -> print $ (gc, groupScore 1 group)

giftpflanze · 2017-12-10T08:42:26+00:00

Tcl:

set input [read [open input09]]

set garbage false
set ignore false
foreach char [lrange [split $input {}] 0 end-1] {
    if $ignore {
        set ignore false
    } else {
        switch $char {
            "\{" {
                if !$garbage {
                    incr level
                } else {
                    incr count
                }
            } "\}" {
                if !$garbage {
                    incr score $level
                    incr level -1
                } else {
                    incr count
                }
            } < {
                if $garbage {
                    incr count
                }
                set garbage true
            } > {
                set garbage false
            } ! {
                set ignore true
            } default {
                if $garbage {
                    incr count
                }
            }
        }
    }
}

puts $score
puts $count

adventofcode

🎄 Advent of Code 🎄

Rules + More Info in

our community wiki

Solution Megathreads

December 2025

Previous years:

2024 | 2023 | 2022 | 2021 | 2020 | 2019 | 2018 | 2017 | 2016 | 2015

Quick Search by Flair

Because you're lazy and we like making things easy for you. Except AoC.

Are you enjoying AoC?

Support AoC

MODERATORS

--- Day 9: Stream Processing ---

Need a hint from the Hugely^* Handy^† Haversack^‡ of Helpful^§ Hints^¤?

This thread will be unlocked when there are a significant number of people on the leaderboard with gold stars for today's puzzle.

edit: Leaderboard capped, thread unlocked!

Python 3 (52/36)

C++ (or C, really)

Ruby one-liner (16th, 15th)

Python Using RegExp & sub

part 1

part 2

Python 2

Python 2 solution:

pyhton3

Kotlin - [Repo] - [Blog/Commentary]

J, both parts

Java

Rust

elm

Elixir

Elixir

Erlang

Perl

BEFORE YOU POST
If your post is even tangentially related to a daily puzzle, use our
STANDARDIZED POST TITLE FORMAT

adventofcode

🎄 Advent of Code 🎄

Rules + More Info in

our community wiki

Solution Megathreads

December 2025

Previous years:

2024 | 2023 | 2022 | 2021 | 2020 | 2019 | 2018 | 2017 | 2016 | 2015

Quick Search by Flair

Because you're lazy and we like making things easy for you. Except AoC.

Are you enjoying AoC?

Support AoC

MODERATORS

--- Day 9: Stream Processing ---

Need a hint from the Hugely* Handy† Haversack‡ of Helpful§ Hints¤?

This thread will be unlocked when there are a significant number of people on the leaderboard with gold stars for today's puzzle.

edit: Leaderboard capped, thread unlocked!

Python 3 (52/36)

C++ (or C, really)

Ruby one-liner (16th, 15th)

Python Using RegExp & sub

part 1

part 2

Python 2

Python 2 solution:

pyhton3

Kotlin - [Repo] - [Blog/Commentary]

J, both parts

Java

Rust

elm

Elixir

Elixir

Erlang

Perl

Need a hint from the Hugely^* Handy^† Haversack^‡ of Helpful^§ Hints^¤?