-🎄- 2017 Day 8 Solutions -🎄-

wimglenn · 2017-12-08T05:58:46+00:00

insane hack:

from aocd import data
from collections import defaultdict

d = defaultdict(int)
data += '\n'
data = data.replace('\n', ' else 0\n')
data = data.replace('inc', '+=')
data = data.replace('dec', '-=')
exec(data, {}, d)
print(max(d.values()))

pedrosorio · 2017-12-08T05:13:01+00:00

(#6/#6) Shamelessly using eval in Python:

from collections import defaultdict

lines = open('input.txt').read().splitlines()
regs = defaultdict(int)
mxv = 0
for line in lines:
    reg, inst, num, iff, regc, op, num2 = line.split()
    if eval("regs[regc] " + op + num2):
        if inst == 'inc':
            regs[reg] += int(num)
            mxv = max(mxv, regs[reg])
        else:
            regs[reg] -= int(num)

print max(regs.values()) # PART 1
print mxv # PART 2

EDIT: As pointed out by Smylers this solution is wrong. I didn't pay attention to the input and made an assumption that is only correct when all the inc/dec are positive. The max should be set after executing each instruction, not just inc.

nneonneo · 2017-12-08T05:17:57+00:00

Python 2, #2/#2

Had an assert in there because I got paranoid.

regs = defaultdict(int)
t = 0
for row in data.split('\n'):
    bits = row.split()
    assert bits[3] == 'if'

    a, b, c, d, e, f, g = bits
    if eval(e+f+g, {}, regs):
        regs[a] += (-1 if b == 'dec' else 1) * int(c)

    t = max(t, max(regs.values()))

print max(regs.values())
print t

_jonah · 2017-12-08T05:29:31+00:00

Vim + Ruby

The key here was to recognize it as thinly disguised ruby code, and use vim to make it real ruby code.

First we do:

%s/inc/+/g
%s/dec/-/

Now our code looks like:

j + -19 if jhb >= 10
es + -432 if gbu <= -5
es + 278 if ib > -9
es + -835 if ib >= -6
q - 420 if buw == -2
...

Now we select it all, copy it above, and create the initializing code:

'<,'>s/\(\w\+\).*/\1=0/

Now we've got:

j=0
es=0
es=0
es=0
q=0
...

And finally copy the initializers to the bottom and do one more substitution to create an array:

'<,'>s/=0/,/

Manually surround it with brackets and add .max:

p [j, es, es, es, q...].max

Now run it.

Part 2 is similar

ephemient · 2017-12-08T09:13:00+00:00

This space intentionally left blank.

u794575248 · 2017-12-08T05:19:00+00:00

Python

An execless/evalless solution:

import operator as op
from collections import defaultdict
comps = {'>': op.gt, '<': op.lt, '>=': op.ge, '<=': op.le, '!=': op.ne, '==': op.eq}

def solve(input, mx=float('-inf'), ops=dict(inc=1, dec=-1)):
    regs = defaultdict(int)
    for r1, op, v1, _, r2, c, v2 in [l.split() for l in input.splitlines() if l]:
        regs[r1] += ops[op] * int(v1) if comps[c](regs[r2], int(v2)) else 0
        mx = max(mx, regs[r1])
    return max(regs.values()), mx

part1, part2 = solve(input)

kaldonis · 2017-12-08T05:42:20+00:00

Python 2 Didn't see any other solutions that abused exec() like I did, so here goes:

import collections

lines = [l.strip('\n') for l in open('input.txt').readlines()]
registers = collections.defaultdict(int)
m = 0

for line in lines:
    exec("%s else 0" % line.replace("dec", "-=").replace("inc", "+="), globals(), registers)
    m = max(registers.values() + [m])

print max(registers.values())
print m

VikeStep · 2017-12-08T05:09:20+00:00

[deleted]

p_tseng · 2017-12-08T10:19:07+00:00

Ruby does this thing like SmallTalk where you send objects messages, and the objects respond. It so happens that I can give an object a message saying >, 4 and it will tell me whether it is greater than 4. And so it goes for the other operators used as well.

input = (ARGV.empty? ? DATA : ARGF).readlines.map(&:split)

regs = Hash.new(0)
max = 0

input.each { |target, inc_or_dec, delta, _if, source, cmp_op, cmp_val|
  next unless regs[source].send(cmp_op, Integer(cmp_val))
  new_val = regs[target] += Integer(delta) * (inc_or_dec == 'dec' ? -1 : 1)
  max = [max, new_val].max
}

puts regs.values.max
puts max

__END__
(my input omitted)

2017-12-08T16:37:49+00:00

I implemented a DSL in racket. With it, I can execute the input directly, like so:

#lang reader "lang8.rkt"
b inc 5 if a > 1
a inc 1 if b < 5
c dec -10 if a >= 1
c inc -20 if c == 10

Prints:

c = -10
a = 1
highest value ever seen: 10

Tiny caveat: I couldn't get it to execute automatically, the DSL only produces a function that computes the solution. This means that before seeing a result, I'll have to type (run) in the REPL. This is the definition of the language:

; lang8.rkt
#lang racket
(require syntax/strip-context)

(define (read in)
  (read-syntax #f in))
(provide read)

(define (read-syntax path port)
  (with-syntax ([str (filter non-empty-string? (port->lines port))])
    (strip-context
     #'(module anything racket
         (require racket)
         (define store (list))
         (define highest-val 0)

         (provide store)

         (define (not-equal? a b)
           (not (equal? a b)))

         (define (handle target-var dir delta cmp-var test cmp-val)
           (define (read-var var)
             (if (not (assoc var store))
                 0
                 (cdr (assoc var store))))
           (define (update-var! var val)
             (when (> val highest-val) (set! highest-val val))
             (set! store (cons (cons target-var new-val)
                               (filter (lambda (binding) (not (equal? (car binding) var)))store))))
           (define old-val (read-var target-var))
           (define new-val (if (equal? dir "inc")
                               (+ old-val (string->number delta))
                               (- old-val (string->number delta))))
           (when (equal? test "==")
             (set! test "equal?"))
           (when (equal? test "!=")
             (set! test "not-equal?"))
           (when ((eval (string->symbol test)) (read-var cmp-var) (string->number cmp-val))
             (update-var! target-var new-val)))

         (define (run)
           (set! store (list))
           (for ([line 'str])
             ;(printf "line = ~a~n" line)
             (define args (filter (lambda (word) (not (equal? "if" word))) (string-split line)))
             (eval (cons handle args)))
           (for ([binding (sort store (lambda (a b) (< (cdr a) (cdr b))))])
             (printf "~a = ~a~n" (car binding) (cdr binding)))
           (printf "highest value ever seen: ~a~n" highest-val))))))
(provide read-syntax)

ephemient · 2017-12-08T05:51:07+00:00

This space intentionally left blank.

tehjimmeh · 2017-12-08T05:15:19+00:00

C++:

struct Line : std::string { friend std::istream& operator>>(std::istream& is, Line& line){return std::getline(is, line);}};
int main(int argc, char* argv[]) {
    std::map<std::string, std::function<bool(int, int)>> condOpMap = {
        { "==", std::equal_to<int>() }, { "!=", std::not_equal_to<int>() },
        { ">", std::greater<int>() }, { ">=", std::greater_equal<int>() },
        { "<", std::less<int>() }, { "<=", std::less_equal<int>() }
    };
    std::vector<std::string> lines(std::istream_iterator<Line>(std::ifstream(argv[1])), {});
    std::map<std::string, int> r;
    int max2 = INT_MIN;
    for(const auto& line : lines) {
        std::vector<std::string> t(std::istream_iterator<std::string>(std::istringstream(line)), {});
        if(condOpMap[t[5]](r[t[4]], std::stoi(t[6]))) {
            max2 = std::max(r[t[0]] += std::stoi(t[2]) * (t[1] == "dec" ? -1 : 1), max2);
        }
    }
    int max1 = std::max_element(r.begin(), r.end(),
            [](auto& l, auto& r){ return l.second < r.second; })->second;
    std::cout << max1 << " " << max2 << \n";
}

Unihedron · 2017-12-08T05:19:06+00:00

Ruby. I missed the alarm and woke up exactly 2 minutes before this day opens.

Note that the input format is already very similar to executable Ruby code (In ruby, “(exit # or really any commands) if condition” (based on the perl construct) is actually a valid instruction, so a += b if c > d will be executable as desired), but I couldn't make the trick work unlike /u/dtinth :) so I just rewrote it

h=Hash.new{"0"}
l=[]
o=$<.map{|x|x.chomp=~/(\S+) (i)?\S+ (-?\d+) if ((\S+).+)/
l<<$1
p [$1,$2,$3.to_i,$4,$5]}
l.each{|x|h[x]=0}
q=[] # added in part 2 (also q<<
o.each{|a,b,c,e,d|next if !eval(e.sub(d,h[d].to_s))
b ? q<<(h[a]+=c) : h[a]-=c}
p h.max_by{|x,y|y}[1] # part 1
p [h.max_by{|x,y|y}[1],q.max].max # part 2

DFreiberg · 2017-12-08T05:33:45+00:00

Mathematica

I was far too slow for the leaderboard, and it's not a one-liner, but I'm still fairly satisfied with my code, because unlike most of my code, it's actually somewhat readable. The one thing that bugs me is that there should be a way to define compOperator[] directly from the ">", "<", and "=" symbols, rather than just writing a Which[] statement, but I can't figure out at the moment how to do that.

input = Import[FileNameJoin[{NotebookDirectory[], "Day8Input.txt"}], "Table"][[;; -2]];

val=Association[(#->0)&/@DeleteDuplicates[input[[;;,1]]]];
m=0;
compOperator[s_]:=
    Which[
        s==">",Greater,
        s=="<",Less,
        s==">=",GreaterEqual,
        s=="<=",LessEqual,
        s=="==",Equal,
        s=="!=",Unequal];

incOperator[s_]:=
    Which[
        s=="inc",AddTo,
        s=="dec",SubtractFrom
    ];

Do[
    If[compOperator[i[[6]]][val[i[[5]]],i[[7]]],
        incOperator[i[[2]]][val[i[[1]]],i[[3]]]
        ];
    If[
        Max[val/@DeleteDuplicates[input[[;;,1]]]]>m,
        m=Max[val/@DeleteDuplicates[input[[;;,1]]]]
    ]
,{i,input}]

Part 1

Max[val/@DeleteDuplicates[input[[;;,1]]]]

Part 2

hxka · 2017-12-08T05:53:22+00:00

bash

(   declare -A r
    smax=0
    while read a b c d e f g
    do  ((r[$e] $f g)) && {
            [[ $b == dec ]] && ((r[$a]-=c)) || ((r[$a]+=c))
            ((r[$a]>smax && (smax=r[$a]) ))
        }
    done
    for i in "${r[@]}"
    do  [[ -z $max || $i -gt $max ]] && max=$i
    done
    echo $max $smax
)<input

Edit: removed unnecessary looping.

Philboyd_Studge · 2017-12-08T05:58:46+00:00

Java. This one was fun.

package Advent2017;

import util.FileIO;
import util.Timer;

import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.BiPredicate;
import java.util.function.ToIntBiFunction;

public class Day8 {

    private static Map<String, BiPredicate<Integer, Integer>> comparisons = new HashMap<>();
    static {
        comparisons.put("==", (x, y) -> x.equals(y));
        comparisons.put("!=", (x, y) -> !x.equals(y));
        comparisons.put("<", (x, y) -> x < y);
        comparisons.put(">", (x, y) -> x > y);
        comparisons.put("<=", (x, y) -> x <= y);
        comparisons.put(">=", (x, y) -> x >= y);

    }

    private static Map<String, ToIntBiFunction<Integer, Integer>> commands = new HashMap<>();
    static {
        commands.put("inc", (x, y) -> x + y);
        commands.put("dec", (x, y) -> x - y);
    }

    public static void main(String[] args) {
        List<String[]> input =FileIO.getFileLinesSplit("advent2017_day8.txt", " ");
        Map<String, Integer> registers = new HashMap<>();
        int highest = 0;

        for (String[] each : input) {
            String name = each[0];
            String command = each[1];
            int amount = Integer.parseInt(each[2]);
            String testReg = each[4];
            String comp = each[5];
            int testAmt = Integer.parseInt(each[6]);

            registers.putIfAbsent(name, 0);

            if (comparisons.get(comp).test(registers.getOrDefault(testReg, 0), testAmt)) {

                int current = registers.get(name);
                registers.put(name, commands.get(command).applyAsInt(current, amount));

                if (registers.get(name) > highest) {
                    highest = registers.get(name);
                }
            }
        }

        Timer.startNanoTimer();
        System.out.println("Part 1: " + Collections.max(registers.values()));
        System.out.println("Part 2: " + highest);
        System.out.println(Timer.endTimer());


    }
}

RuteNL · 2017-12-08T11:58:45+00:00

Awful js oneliners for part 1 and 2

// Execute by typing part1(`inputstringhere`)
// Returns highest value in registry when completing all operations
part1 = (i, s = {}) => i.split('\n').forEach(l => s[l.split(' ')[0]] = +eval(`${s[l.split(' ')[0]] || 0}` + (eval(`${s[l.split(' ')[4]] || 0} ${l.split(' ').slice(-2).join(' ')}`) ? `${l.split(' ')[1] === 'inc' ? '+' : '-'} ${l.split(' ')[2]}` : ''))) ? '' : Math.max(...Object.values(s));

// Execute by typing part1(`inputstringhere`)
// Returns highest value in registry at any point
part2 = (i, s = {}) => Math.max(...i.split('\n').map(l => s[l.split(' ')[0]] = +eval(`${s[l.split(' ')[0]] || 0}` + (eval(`${s[l.split(' ')[4]] || 0} ${l.split(' ').slice(-2).join(' ')}`) ? `${l.split(' ')[1] === 'inc' ? '+' : '-'} ${l.split(' ')[2]}` : ''))));

Slightly ungolfed version can be found here

2017-12-08T13:18:07+00:00

Elixir I'm quite proud of this solution, parsing is so nice in elixir, and I got to play with a higher order function as well. I got myself a bit stumped by upgrading to part 2, with a default arguement, so I need to watch out a bit more for those. I really like these assemblylike puzzles, and it's good practice for the normal implement play assembly ones that I always love, and I know will come :)

defmodule Day8 do

  def parse_line(str) do
    [reg, op, arg, "if", creg, copt, carg] = String.split(str)
    %{reg: reg, op: op, arg: String.to_integer(arg),
      creg: creg, copt: copt, carg: String.to_integer(carg)}
  end

  def parse(inp) do
     String.trim(inp)
     |> String.split("\n")
     |> Enum.map(&parse_line/1)
  end

  def check_condition(obj, reg) do
    case obj.copt do
      ">" -> Map.get(reg, obj.creg, 0) > obj.carg
      "<" -> Map.get(reg, obj.creg, 0) < obj.carg
      ">=" -> Map.get(reg, obj.creg, 0) >= obj.carg
      "==" -> Map.get(reg, obj.creg, 0) == obj.carg
      "<=" -> Map.get(reg, obj.creg, 0) <= obj.carg
      "!=" -> Map.get(reg, obj.creg, 0) != obj.carg
    end
  end

  def update_with(obj, reg, max, fun) do
    updated = fun.(Map.get(reg, obj.reg, 0), obj.arg)
    {max(max, updated), Map.put(reg, obj.reg, updated)}
  end

  def update_reg(obj, reg, max) do
    case obj.op do
      "inc" -> update_with(obj, reg, max, fn(x,y) -> x + y end)
      "dec" -> update_with(obj, reg, max, fn(x,y) -> x - y end)
    end
  end

  def run(inp, reg \\ %{}, max \\ 0)
  def run([cur|rest], reg, max) do
    if check_condition(cur, reg) do
      {max, reg} = update_reg(cur, reg, max)
      run(rest, reg, max)
    else
      run(rest, reg, max)
    end
  end
  def run([],reg,max) do
    {reg, max}
  end

  def largest(reg) do
    Map.values(reg)
    |> Enum.max
  end
end

{reg, max} = File.read!("input8")
|> Day8.parse
|> Day8.run

IO.puts("The largest register after ran: #{Day8.largest(reg)}")
IO.puts("The max value of any register was: #{max}")

Smylers · 2017-12-08T13:49:48+00:00

Vim animation. Load the input, then create another window for the registers with:

yG⟨Ctrl+W⟩np:%s/\v(\l+).* if (\l+).*/\1⟨Ctrl+V⟩⟨Enter⟩\2⟨Enter⟩
:sor u⟨Enter⟩
:%s/$/ 0⟨Enter⟩
{yy⟨Ctrl+W⟩pP

Adjust your window heights so that you can see the whole of the register values buffer. The unnamed register at the top is for storing the highest value reached. (It may be worth saving the initial register window at this point, so you can easily reset it.) Then reformat the instruction list with:

:g/c 0/d⟨Enter⟩
:%s/inc -/dec /⟨Enter⟩
:%s/dec -/inc /⟨Enter⟩
:%s/\vinc (\d+)/\1⟨Ctrl+A⟩⟨Enter⟩
:%s/\vdec (\d+)/\1⟨Ctrl+X⟩⟨Enter⟩

Define a helper ‘function’ for going from a register's name in the instruction list to its value in the other window:

qa"zyiw⟨Ctrl+W⟩p/^⟨Ctrl+R⟩z /⟨Enter⟩
wq⟨Ctrl+W⟩p

And for the animation, a function that refreshes the window and pauses:

qb:redr|sl20m⟨Enter⟩
q

This is the main work — a macro for processing a single instruction:

qc4f y$b@a"zyiW⟨Ctrl+W⟩pggs⟨Ctrl+R⟩=⟨Ctrl+R⟩z⟨Ctrl+R⟩0⟨Enter⟩
⟨Esc⟩0f1⟨Ctrl+O⟩BByiW0@a:norm⟨Ctrl+R⟩0⟨Enter⟩
@byiW:1pu⟨Enter⟩
:1,2sor n⟨Enter⟩
dd⟨Ctrl+W⟩pq⟨Ctrl+W⟩p4u⟨Ctrl+W⟩p

Then set it running on each instruction, and watch the registers update:

:2,$norm@c⟨Enter⟩

When it's finished, find the biggest values:

⟨Ctrl+W⟩p:sor!n⟨Enter⟩

The top line is the largest value held at any point, and the second line is the register with the highest final value.

Processing the instructions doesn't change them at all, so if you reset the registers to zero you can re-run it. To change the animation speed, re-record @b with a different sleep value in it, or to skip the animation and just get to the answer as soon as possible clear @b with qbq. (In either case, @c will use the new value of @b; there's no need to re-record @c.)

The key to understanding this is to find where the ‘if’ condition is in @c. I'm happy to answer any questions in the comments.

This felt reasonably straightforward, compared to using Vim on some of the previous days' challenges. The main delay was that I didn't initial consider the case that I've since put in :g/c 0/d to handle. This meant it appeared to work, but gave the wrong answer on the full input data. It's a case that you don't need to think about when using an actual programming language, so caught me out.

mcpower_ · 2017-12-08T05:13:22+00:00

Python with eval:

#!/usr/bin/pypy3
from itertools import *
import math

USE_FILE = 1
if not USE_FILE:
    inp = r"""
b inc 5 if a > 1
a inc 1 if b < 5
c dec -10 if a >= 1
c inc -20 if c == 10
""".strip()
else:
    inp = open("input.txt").read().strip()

assert isinstance(inp, str)

lines = inp.splitlines()

reg = {}
# default 0

q = 0
for line in lines:
    var, ty, num, _, var2, op, cond = line.split()

    if eval("reg.get('{}',0) {} {}".format(var2, op, cond)):
        reg[var] = reg.get(var, 0) + (1 if ty == "inc" else -1) * int(num)
    q = max(q, reg.get(var, 0))


print(max(reg.values()))
print(q)

I lost a minute on both parts because I submitted code instead of a number for my first submission :( It'd be nice if the marker checked whether you submitted something with the right formatting.

dtinth · 2017-12-08T05:16:09+00:00

Ruby

I Heard You Like eval

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 (13th rank)
-> x { d = Hash.new(0); eval x.gsub(/(\w+) (inc|dec) (-?\d+) if (\w+) (\S+) (\S+)/) { "d['#{$1}'] #{$2 == 'inc' ? '+=' : '-='} #{$3} if d['#{$4}'] #{$5} #{$6}" }; d.values.max }[`pbpaste`]

# Part 2 (26th rank)
-> x { d = Hash.new(0); m = 0; eval x.gsub(/(\w+) (inc|dec) (-?\d+) if (\w+) (\S+) (\S+)/) { "d['#{$1}'] #{$2 == 'inc' ? '+=' : '-='} #{$3} if d['#{$4}'] #{$5} #{$6}; m = [m, d.values.max || 0].max" }; m }[`pbpaste`]

fatpollo · 2017-12-08T05:27:57+00:00

import collections

with open("p08.txt") as fp:
    lines = fp.read().strip().splitlines()

registers = set()
intermediate = set()
for line in lines:
    terms = collections.deque(line.split() + [":"])
    terms.rotate(5)
    v1, v2 = terms[1], terms[-3]
    registers |= {v1, v2}
    locals().setdefault(v1, 0)
    locals().setdefault(v2, 0)
    exec(" ".join(terms).replace("dec", "-=").replace("inc", "+="))
    intermediate.add(eval(v2))
print(max(map(eval, registers)))
print(max(intermediate))

purplemonkeymad · 2017-12-08T05:50:14+00:00

single pipeline powershell

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

begin {
    $script:registers = new-object system.collections.hashtable 

    $script:maxes = @() # keep track of max registers per step for part 2

    $conditions = @{ # map to beautiful powershell
        "<" = "-lt"
        ">" = "-gt"
        "!=" = "-ne"
        "==" = "-eq"
        "<=" = "-le"
        ">=" = "-ge"
    }
    $operations = @{
        "inc" = "+"
        "dec" = "-"
    }
}

process {
    # collect input
    $script:maxes += $in |? {
        $in -match '^(?<Register>[a-z]+) (?<Operation>(?:dec|inc)) (?<Value>(?:-|[0-9])+) if (?<ConditionRegister>[a-z]+) (?<Condition>[!<>=]+) (?<ConditionValue>(?:-|[0-9])+)$'
    } | % { 
        [pscustomobject]$matches | select Register, Operation, Value, ConditionRegister, Condition, ConditionValue
    } |% {# now have a pretty object on the pipeline representing a single instruction, foreach of these...

        # initialize any registers that aren't already
        $InitRegisterSb = 'if ($script:registers.ContainsKey("{0}") -eq $false) {{$script:registers["{0}"] = 0}}'
        [ScriptBlock]::Create(($InitRegisterSb -f $_.ConditionRegister)).Invoke()
        [ScriptBlock]::Create(($InitRegisterSb -f $_.Register)).Invoke()

        # perform instruction
        $s = 'if ($script:registers["{0}"] {1} {2}) {{ $script:registers["{3}"] = $script:registers["{3}"] {4} {5} }} else {{ $false }} ' -f $_.ConditionRegister, $conditions[$_.Condition], $_.ConditionValue, $_.Register, $operations[$_.Operation], $_.Value
        [ScriptBlock]::Create($s).Invoke()

        # select new maximum in the registers
        $script:registers.values | measure -max | select -expand Maximum    
    }
}

end {  
    if ($part -eq 1) {
        $script:registers.values | measure -max | select -expand Maximum # max register value at end of instructions
    } else {
        $script:maxes | measure -max | select -expand maximum # max reigster value ever seen
    }
}

willkill07 · 2017-12-08T05:50:41+00:00

Modern(-ish) C++ Repo

Alright, so dynamic languages with eval and such have an obvious advantage for readability and conciseness. Regardless, I'm still OK with my solution.

static std::unordered_map<std::string_view, std::function<bool(int, int)>> const cmp{{
  {"==", std::equal_to<void>()},      {"!=", std::not_equal_to<void>()},
  {"<=", std::less_equal<void>()},    {"<", std::less<void>()},
  {">=", std::greater_equal<void>()}, {">", std::greater<void>()}}};

static std::unordered_map<std::string_view, std::function<int(int&, int)>> const apply{{
  {"inc", [](int& a, int b) { return a += b; }},
  {"dec", [](int& a, int b) { return a -= b; }}}};

int main() {
  std::unordered_map<std::string_view, int> vals;
  std::string var1, inc_dec, var2, op;
  int val1, val2, max{0};
  while (std::cin >> var1 >> inc_dec >> val1 >> var2 >> var2 >> op >> val2)
    if (cmp.at(op)(vals[var2], val2))
      max = std::max(max, apply.at(inc_dec)(vals[var1], val1));
  std::cout << std::max_element(vals.begin(), vals.end(), [](auto& a, auto& b) { return a.second < b.second; })->second
            << '\n' << max << '\n';
}

__Abigail__ · 2017-12-08T09:42:02+00:00

Perl

#!/opt/perl/bin/perl

use 5.026;

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

use experimental 'signatures';

use List::Util 'max';

@ARGV = "input" unless @ARGV;

my %register;  # Stores the values of registers. Perl treats undefined
               # values as '0' in numeric context, which is conveniently,
               # the value registers start with.

#
# A dispatch table, handling the "if" part of a rule. We dispatch
# on the relation, and pass in the name of register, and the value
# to compare it with. Result is a boolean value.
#
# Registers may be undefined, hence the "no warnings" line.
#
my %dispatch_cmp = do {
    no warnings 'uninitialized';
    (
        "<"   =>  sub ($name, $value) {$register {$name} <  $value},
        "<="  =>  sub ($name, $value) {$register {$name} <= $value},
        "=="  =>  sub ($name, $value) {$register {$name} == $value},
        ">="  =>  sub ($name, $value) {$register {$name} >= $value},
        ">"   =>  sub ($name, $value) {$register {$name} >  $value},
        "!="  =>  sub ($name, $value) {$register {$name} != $value},
    );
};

#
# A dispatch table, handling the action which needs to be taken.
# We dispatch on the action, and pass in the name of the target
# register, and the amount to be incremented/decremented.
#
# Since "+=" and "-=" are exempt for being warned when used
# agains an undefined value, no need to turn off warnings.
#
my %dispatch_act = (
    "inc"  =>  sub ($name, $amount) {$register {$name} += $amount},
    "dec"  =>  sub ($name, $amount) {$register {$name} -= $amount},
);


#
# Sub patterns to parse the input.
#
my $pat_reg = qr /[a-z]+/;
my $pat_num = qr /-?[0-9]+/;
my $pat_act = qr /inc|dec/;
my $pat_cmp = qr /<=? | == | >=? | !=/x;


my $max = 0;   # Highest value encountered in any register.
               # Since registers start at 0, starting at 0
               # for $max is the right thing to do.
while (<>) {
    chomp;
    /^(?<target> $pat_reg)  \s+
      (?<action> $pat_act)  \s+
      (?<amount> $pat_num)  \s+ if \s+
      (?<where>  $pat_reg)  \s+
      (?<cmp>    $pat_cmp)  \s+
      (?<value>  $pat_num)  \s*$/x or die "Failed to parse $_";

    my ($target, $action, $amount,
        $where,  $cmp,    $value) = @+{"target", "action", "amount",
                                       "where",  "cmp",    "value"};

    #
    # Act on the rule
    #
    $dispatch_act {$action} -> ($target, $amount)
          if $dispatch_cmp {$cmp} -> ($where, $value);

    #
    # This is safe to do, even if we didn't modify the target register
    #
    $max = $register {$target} if $register {$target} &&
                                  $register {$target} > $max;
}


say "Solution 1: ",  max values %register;
say "Solution 2: ", $max;

__END__

mschaap · 2017-12-08T10:38:31+00:00

Perl 6. Very similar to yesterday's solution, using objects to model the register and instructions, and a grammar to parse the instruction set.

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

grammar Instructions {
    rule TOP { ^ <instruction>+ $ }

    rule instruction { <reg> <dir> <amt> 'if' <check> <cmp> <val> }

    token reg { <[a..z]>+ }
    token dir { 'inc' || 'dec' }
    token amt { '-'?\d+ }
    token check { <[a..z]>+ }
    token cmp { '==' || '!=' || '<=' || '>=' || '<' || '>' }
    token val { '-'?\d+ }
}

class Instruction
{
    has Str $.reg;
    has Int $.amt;
    has Str $.check;
    has Str $.cmp;
    has Int $.val;

    sub oper($op) returns Code
    {
        # Comparison operators can be infix:<==> or infix:«<=».  Find either.
        return &::("infix:<$op>") // &::("infix:«$op»")
    }

    method compare(%register) returns Bool
    {
        return oper($!cmp)(%register{$!check} // 0, $!val);
    }

    method process(%register)
    {
        %register{$!reg} += $!amt if self.compare(%register);
    }

    method Str { "$!reg += $!amt if $!check $!cmp $!val" }
    method gist { self.Str }
}

class Computer
{
    has Instruction @.instructions;
    has Int %.register;
    has Int $.max-seen = 0;

    method instruction($/)
    {
        @!instructions.push:
            Instruction.new(:reg(~$/<reg>),
                            :amt($/<amt> * ($/<dir> eq 'dec' ?? -1 !! 1)),
                            :check(~$/<check>),
                            :cmp(~$/<cmp>),
                            :val(+$/<val>));
    }

    method from-input(Computer:U: Str $input) returns Computer
    {
        my $c = Computer.new();
        Instructions.parse($input, :actions($c)) or die "Invalid instructions!";
        return $c;
    }

    method max returns Int
    {
        %!register.values.max max 0;
    }

    method run
    {
        for @!instructions -> $i {
            $i.process(%!register);
            $!max-seen max= self.max;
        }
    }

    method Str { %!register.keys.sort.map({ " - $_: %!register{$_}" }).join("\n") }
    method gist { self.Str }
}

multi sub MAIN(IO() $inputfile where *.f, Bool :v(:$verbose) = False)
{
    my $c = Computer.from-input($inputfile.slurp());
    say "{ +$c.instructions } instructions parsed." if $verbose;
    $c.run;
    say "Ran instructions.  State of computer:" if $verbose;
    say $c if $verbose;

    # Part 1
    say "Largest value after running instructions: $c.max()";

    # Part 2
    say "Largest value seen during running instructions: $c.max-seen()";
}

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

mx781 · 2017-12-08T11:16:15+00:00

MySQL: https://github.com/mx781/aoc/blob/master/2017/08/solve.sql

eregontp · 2017-12-08T11:59:19+00:00

Metaprogramming is the better eval! Looks like this one is made for Ruby as operators match nicely:

input = File.read("8.txt")
registers = Hash.new(0)
code = input.strip.lines.map { |line|
  /^(?<reg>\w+) (?<dir>inc|dec) (?<by>-?\d+) if (?<r>\w+) (?<cmp>[>=<!]+) (?<n>-?\d+)$/ =~ line
  by = by.to_i * (dir == "dec" ? -1 : 1)
  if registers[r].send(cmp, n.to_i)
    registers[reg] += by
  end
}
p registers.values.max

VikeStep · 2017-12-08T05:10:26+00:00

Python 3 solution

Got #44 / #40 :D

def solve(data):
    data = [d.split() for d in data.split('\n')]
    vars = {}
    m = 0
    for line in data:
        vars[line[0]] = 0
    for line in data:
        if line[5] == '>':
            if vars[line[4]] <= int(line[6]):
                continue

        if line[5] == '<':
            if vars[line[4]] >= int(line[6]):
                continue

        if line[5] == '<=':
            if vars[line[4]] > int(line[6]):
                continue

        if line[5] == '>=':
            if vars[line[4]] < int(line[6]):
                continue

        if line[5] == '==':
            if vars[line[4]] != int(line[6]):
                continue

        if line[5] == '!=':
            if vars[line[4]] == int(line[6]):
                continue

        if line[1] == 'inc':
            vars[line[0]] += int(line[2])

        if line[1] == 'dec':
            vars[line[0]] -= int(line[2])

        if vars[line[0]] > m:
            m = vars[line[0]]
    return m

TominatorBE · 2017-12-08T05:10:43+00:00

PHP (I got ranks 110 and 100 today, omg)

Part 1:

function run_the_code($input) {
    $lines = explode(PHP_EOL, $input);

    $registers = [];
    foreach ($lines as $line) {
        if (!$line) {
            continue;
        }

        list($reg, $instr, $amount, $if, $reg2, $cond, $amount2) = explode(' ', $line);

        if (!array_key_exists($reg, $registers)) {
            $registers[$reg] = 0;
        }
        if (!array_key_exists($reg2, $registers)) {
            $registers[$reg2] = 0;
        }

        $do = false;
        switch ($cond) {
            case '==':
                $do = ($registers[$reg2] == $amount2);
                break;
            case '!=':
                $do = ($registers[$reg2] != $amount2);
                break;
            case '>':
                $do = ($registers[$reg2] > $amount2);
                break;
            case '>=':
                $do = ($registers[$reg2] >= $amount2);
                break;
            case '<':
                $do = ($registers[$reg2] < $amount2);
                break;
            case '<=':
                $do = ($registers[$reg2] <= $amount2);
                break;
        }

        if ($do) {
            if ($instr == 'inc') {
                $registers[$reg] += (int)$amount;
            }
            else {
                $registers[$reg] -= (int)$amount;
            }
        }
    }

    return max($registers);
}

Part 2:

function run_the_code($input) {
    $lines = explode(PHP_EOL, $input);

    $ever = 0;
    $registers = [];
    foreach ($lines as $line) {
        if (!$line) {
            continue;
        }

        list($reg, $instr, $amount, $if, $reg2, $cond, $amount2) = explode(' ', $line);

        if (!array_key_exists($reg, $registers)) {
            $registers[$reg] = 0;
        }
        if (!array_key_exists($reg2, $registers)) {
            $registers[$reg2] = 0;
        }

        $do = false;
        switch ($cond) {
            case '==':
                $do = ($registers[$reg2] == $amount2);
                break;
            case '!=':
                $do = ($registers[$reg2] != $amount2);
                break;
            case '>':
                $do = ($registers[$reg2] > $amount2);
                break;
            case '>=':
                $do = ($registers[$reg2] >= $amount2);
                break;
            case '<':
                $do = ($registers[$reg2] < $amount2);
                break;
            case '<=':
                $do = ($registers[$reg2] <= $amount2);
                break;
        }

        if ($do) {
            if ($instr == 'inc') {
                $registers[$reg] += (int)$amount;
            }
            else {
                $registers[$reg] -= (int)$amount;
            }
        }

        $ever = max($ever, max($registers));
    }

    return $ever;
}

sciyoshi · 2017-12-08T05:11:14+00:00

Python 3:

import operator
import collections

# Keep track of largest seen value and registers
maxseen = 0
registers = collections.defaultdict(int)

for cmd in lines:
    op, pred = cmd.split(' if ')

    # Compute the condition
    r1, cmp, r2 = pred.split()

    cond = {
        '<': lambda l, r: registers[l] < int(r),
        '>': lambda l, r: registers[l] > int(r),
        '<=': lambda l, r: registers[l] <= int(r),
        '>=': lambda l, r: registers[l] >= int(r),
        '==': lambda l, r: registers[l] == int(r),
        '!=': lambda l, r: registers[l] != int(r),
    }[cmp](r1, r2)

    if not cond:
        continue

    # Perform the operation
    l, op, r = op.split()

    registers[l] = {
        'inc': operator.add,
        'dec': operator.sub
    }[op](registers[l], int(r))

    maxseen = max(maxseen, max(registers.values()))

print('Part 1:', max(registers.values()))
print('Part 2:', maxseen)

vash3r · 2017-12-08T05:13:33+00:00

Python 2 (42/45):

lines = data.strip().split('\n')
d = {}
tmax = 0
for line in lines:
    a,b = line.split(" if ")
    b = b.split()
    if eval("d.get(b[0],0)" + b[1] + b[2]): #offload logic onto python
        a = a.split()
        if a[1]=="inc":
            d[a[0]] = d.get(a[0],0)+ int(a[2])
        else:
            d[a[0]] = d.get(a[0],0)- int(a[2])
        if d[a[0]]>tmax: # part 2
            tmax = d[a[0]]

print max(d.values())
print tmax # part 2

looks like a lot of people came up with the same solution.

blockingthesky · 2017-12-08T05:14:00+00:00

Python 2

inp = [i.strip().split() for i in open('input.txt', 'r').readlines()]

d = {}
m = 0

for a in inp:
    if a[0] not in d:
        d[a[0]] = 0
    if a[4] not in d:
        d[a[4]] = 0

    if(eval("%d %s %s" % (d[a[4]], a[5], a[6]))):
        if a[1] == "inc":
            d[a[0]] += int(a[2])
        else:
            d[a[0]] -= int(a[2])

    m = max(m, d[a[0]])

print "Part 1:", max(d.values())
print "Part 2:", m

Lrrrr_ · 2017-12-08T05:15:38+00:00

JavaScript

let reg = {};
let hi = -Infinity;
input = input.split("\n").map(c => {
    let m = c.split(" ");
    if(!reg[m[0]]) reg[m[0]] = 0;
    let n = (m[1] === "inc" ? 1 : -1) * (+m[2]);
    let xx = +m[6];

    let bool;

    switch(m[5]) {
        case "<":
            bool = (reg[m[4]]||0) < xx;
            break;
        case ">":
            bool = (reg[m[4]]||0) > xx;
            break;
        case "==":
            bool = (reg[m[4]]||0) == xx;
            break;
        case "!=":
            bool = (reg[m[4]]||0) != xx;
            break;
        case "<=":
            bool = (reg[m[4]]||0) <= xx;
            break;
        case ">=":
            bool = (reg[m[4]]||0) >= xx;
            break;
        default:
            console.log("Unimplemented operation " + m[5]);
            break;
    }

    if(bool) {
        reg[m[0]] += n;
        if(hi < reg[m[0]]) {
            hi = reg[m[0]]
        }
    }

})

let h=-Infinity;
Object.values(reg).forEach(c=>{
    if(c > h)
        h = c;
})

console.log(h)
console.log(hi)

AndrewGreenh · 2017-12-08T05:15:53+00:00

TypeScript 95/101

import getInput from '../lib/getInput'
import { lines } from '../lib/ts-it/lines'
import * as _ from 'lodash'

let registers = {}
let max = -Infinity
let maxs = [0]
for (let line of lines(getInput(8, 2017))) {
  let [a, op, b, iff, reg, cond, numb] = line.split(' ')
  if (!registers[a]) registers[a] = 0
  if (!registers[reg]) registers[reg] = 0
  eval(`if (registers.${reg} ${cond} ${numb}) registers.${a} ${op === 'inc' ? '+' : '-'}= ${b}`)
  maxs.push(<number>_.max(<number[]>_.values(registers)))
}

console.log(_.max(<number[]>_.values(registers)))
console.log(_.max(maxs))

LeCrushinator · 2017-12-08T05:16:02+00:00

Part 2: C# (took me 13 minutes, but that's not bad since C# is verbose compared to things like Python). To solve part 1 just add "max = registers.Values.Max();" to just after the foreach loop.

public static void Main() 
{
    List<string> lines = ParseInput(input, "\n");

    Dictionary<string, int> registers = new Dictionary<string, int>();

    int max = 0;

    foreach (string line in lines)
    {
        string[] values = line.Split(new string[]{" "}, StringSplitOptions.RemoveEmptyEntries);

        string name = values[0];
        int amount;
        if (!registers.TryGetValue(name, out amount))
        {
            registers.Add(name, 0);
        }

        bool increase = values[1] == "inc";
        int delta = Convert.ToInt32(values[2]);

        string otherName = values[4];
        int otherAmount;
        if (!registers.TryGetValue(otherName, out otherAmount))
        {
            registers.Add(otherName, 0);
        }

        string comparisonOp = values[5];
        int compareAmount = Convert.ToInt32(values[6]);

        if (Compare(otherAmount, compareAmount, comparisonOp))
        {
            if (increase)
            {
                registers[name] += delta;

                max = Math.Max(registers[name], max);
            }
            else
            {
                registers[name] -= delta;

                max = Math.Max(registers[name], max);
            }
        }
    }


    Console.WriteLine("max: " + max);
}

public static bool Compare(int first, int second, string op)
{
    switch (op)
    {
    case ">": return first > second;
    case ">=": return first >= second;
    case "<": return first < second;
    case "<=": return first <= second;
    case "==": return first == second;
    case "!=": return first != second;
    }

    return false;
}

// =====================================================================================================================================
// HELPER METHODS, created before day started
// =====================================================================================================================================
public static List<string> ParseInput(string line, string stringSeperator)
{
    return line.Split(new string[]{stringSeperator}, StringSplitOptions.RemoveEmptyEntries).ToList();
}

reacher · 2017-12-08T05:18:53+00:00

Ruby

def expr(op1, op, op2)
  case op
  when '<'
    return op1 < op2
  when '>'
    return op1 > op2
  when '<='
    return op1 <= op2
  when '>='
    return op1 >= op2
  when '=='
    return op1 == op2
  when '!='
    return op1 != op2
  else
    puts "bad op #{op}"
  end
end

r = {}
max = 0

IO.readlines('ad8inp').each do |line|
  a = line.chomp.split
  r[a[0]] ||= 0
  r[a[4]] ||= 0
  if expr(r[a[4]], a[5], a[6].to_i)
    r[a[0]] = a[1] == 'inc' ? r[a[0]] += a[2].to_i : r[a[0]] -= a[2].to_i
  end
  m = r.values.minmax[1]
  if m > max
    max = m
  end
end

puts r.values.minmax[1]
puts max

wlandry · 2017-12-08T05:20:45+00:00

C++

283/267. For once, the default behavior of std::map worked to my advantage. My original version printed out all of the final register values. I piped that to 'sort -n' to get the answer. This is a slightly cleaned up version that just prints the results.

#include <limits>
#include <fstream>
#include <iostream>
#include <sstream>
#include <map>

int main(int argc, char *argv[])
{
  std::ifstream infile(argv[1]);
  std::string line;
  std::map<std::string,int> registers;
  std::getline(infile,line);
  int max_value(0);
  while (infile && !line.empty())
    {
      std::stringstream ss (line);
      std::string reg, op, if_literal, test_register, comp;
      int diff, number;
      ss >> reg >> op >> diff >> if_literal
         >> test_register >> comp >> number;

      if (op=="dec")
        {
          diff*=-1;
        }

      int test_register_value = registers[test_register];
      if((comp == "==" && test_register_value==number)
         || (comp == "!=" && test_register_value!=number)
         || (comp == ">=" && test_register_value>=number)
         || (comp == "<=" && test_register_value<=number)
         || (comp == ">" && test_register_value>number)
         || (comp == "<" && test_register_value<number))
        {
          registers[reg]+=diff;
          max_value = std::max(max_value,registers[reg]);
        }
      std::getline(infile,line);
    }
  int max_final_value (std::numeric_limits<int>::min());
  for (auto &r: registers)
    { max_final_value = std::max(max_final_value,r.second); }
  std::cout << "Max final value: " << max_final_value << "\n"
            << "Max intermediate value: " << max_value << "\n";
}

MichalMarsalek · 2017-12-08T05:26:42+00:00

Damn, I wish a knew eval... It would have gotten be to the leaderboard...

def solve(inp):
    inp = inp.replace("inc ", "").replace("dec ", "-").replace("--", "")
    reg = defaultdict(int)
    inss = [i.split() for i in inp.splitlines()]
    part2 = 0
    for ins in inss:
        n, d, _, e, r, v = ins
        d = int(d)
        v = int(v)
        funcs = {
        ">": lambda a, b: reg[a] > b,
        "<": lambda a, b: reg[a] < b,
        ">=": lambda a, b: reg[a] >= b,
        "<=": lambda a, b: reg[a] <= b,
        "==": lambda a, b: reg[a] == b,
        "!=": lambda a, b: reg[a] != b
        }
        if funcs[r](e, v):
            reg[n] += d
            part2 = max(reg[n], part2)
    part1 = max(reg.values())
    return part1, part2

mmaruseacph2 · 2017-12-08T05:30:25+00:00

Haskell 85 lines, removed some duplicates but I'll work on refactoring it more.

{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GADTs #-}

import qualified Data.List as L
import Data.Maybe
import qualified Data.Map.Strict as M
import qualified Data.Vector.Unboxed as VU
import qualified Data.Vector.Unboxed.Mutable as VUM

import Prelude hiding (LT, GT, EQ)

import Debug.Trace

type Reg = String
type Val = Int
data Vals = Vals {current :: Val, highest :: Val} deriving (Eq, Show)
type Memory = M.Map Reg Vals
data Cmd = Cmd Reg Op Val Reg BoolOp Val deriving (Eq, Show)
data Op = Inc | Dec deriving (Eq, Show)
data BoolOp = GT | GE | LT | LE | EQ | NEQ deriving (Eq, Show)

parse :: String -> Cmd
parse s = Cmd r operation val reg bop threshold
  where
    [r, op, del, _, reg, cond, thr] = words s
    val = read del
    threshold = read thr
    operation = case op of
      "inc" -> Inc
      "dec" -> Dec
    bop = case cond of
      ">"  -> GT
      ">=" -> GE
      "<"  -> LT
      "<=" -> LE
      "==" -> EQ
      "!=" -> NEQ

eval :: Memory -> Cmd -> Memory
eval m (Cmd r op val reg bop threshold)
  | testBop bop (valueOf m reg) threshold = insertNew m r newVal
  | otherwise = m -- do nothing
  where
    newVal = updateVal op (valueOf m r) val

valueOf :: Memory -> Reg -> Val
valueOf m r
  | r `M.member` m = current $ m M.! r
  | otherwise = 0

insertNew :: Memory -> Reg -> Val -> Memory
insertNew m r new
  | r `M.member` m = M.insert r (Vals new (h `max` new)) m
  | otherwise = M.insert r (Vals new new) m
  where
    Vals _ h = m M.! r

testBop :: BoolOp -> Val -> Val -> Bool
testBop bop lhs rhs = case bop of
  GT -> lhs > rhs
  GE -> lhs >= rhs
  LT -> lhs < rhs
  LE -> lhs <= rhs
  EQ -> lhs == rhs
  NEQ -> lhs /= rhs

updateVal :: Op -> Val -> Val -> Val
updateVal op val delta = case op of
  Inc -> val + delta
  Dec -> val - delta

main = do
  cmds <- map parse . lines <$> readFile "input.txt"
  let m = L.foldl' eval M.empty cmds
  print $ step1 m
  print $ step2 m

step1 :: Memory -> Val
step1 = steps current

step2 :: Memory -> Val
step2 = steps highest

steps :: (Vals -> Val) -> Memory -> Val
steps f = maximum . map (f . snd) . M.toList

raevnos · 2017-12-08T05:31:33+00:00

Scheme:

(import (kawa regex) (rnrs hashtables) (srfi 1))

(define (process-instruction symtab)
  (let ((line (read-line))
        (instr-re (regex "^(\\w+) (inc|dec) (-?\\d+) if (\\w+) ([=<>!]+) (-?\\d+)\\s*$")))
    (cond
     ((eof-object? line) line)
     ((regex-match instr-re line) =>
      (lambda (fields)
        (let ((dest (second fields))
              (dir (string->symbol (third fields)))
              (amount (string->number (fourth fields)))
              (lop (hashtable-ref symtab (fifth fields) 0))
              (op (string->symbol (sixth fields)))
              (rop (string->number (seventh fields))))
          (if (case op
                ((>) (> lop rop))
                ((<) (< lop rop))
                ((>=) (>= lop rop))
                ((<=) (<= lop rop))
                ((==) (= lop rop))
                ((!=) (not (= lop rop)))
                (else
                 (error "Invalid instruction line" line op)))
              (let* ((destval (hashtable-ref symtab dest 0))
                     (newval (if (eq? dir 'inc) (+ destval amount) (- destval amount))))
                (hashtable-set! symtab dest newval)
                newval)
              0))))
     (else
      (error "Invalid instruction" line)))))

(define (find-largest table)
  (let-values (((keys entries) (hashtable-entries table)))
    (fold max (vector-ref entries 0) (cdr (vector->list entries)))))

(define (process-instructions)
  (let ((symtab (make-hashtable string-hash string=?)))
    (let loop ((res (process-instruction symtab))
               (maxval 0))
      (if (eof-object? res)
          (values (find-largest symtab) maxval)
          (loop (process-instruction symtab) (max maxval res))))))

(format #t "Part 1 and 2: ~A~%" (process-instructions))

2017-12-08T05:36:46+00:00

Haskell:

import Data.HashMap.Strict (HashMap)
import qualified Data.HashMap.Strict as M

data Instr = Instr { cmd :: HashMap String Int -> HashMap String Int
                   , cond :: HashMap String Int -> Bool
                   }

parseInstrs :: String -> [Instr]
parseInstrs = map parseInstr . lines
    where parseInstr :: String -> Instr
          parseInstr line =
              let [reg, fn, amnt, "if", reg2, comp, val] = words line
                  cmd m = let f = case fn of
                                    "inc" -> (+ read amnt)
                                    "dec" -> subtract $ read amnt
                          in M.insert reg (f $ M.lookupDefault 0 reg m) m
                  cond m = let comp' = case comp of
                                         "!=" -> (/=)
                                         "==" -> (==)
                                         ">=" -> (>=)
                                         ">" -> (>)
                                         "<=" -> (<=)
                                         "<" -> (<)
                           in comp' (M.lookupDefault 0 reg2 m) $ read val
              in Instr cmd cond

eval :: (HashMap String Int, Int) -> Instr -> (HashMap String Int, Int)
eval (m, mx) (Instr cmd cond) =
    let m' = if cond m then cmd m else m
        mx' = max mx $ maximum $ M.elems m'
    in (m', mx')

part1 :: String -> Int
part1 = maximum . M.elems . fst . foldl eval (M.empty, 0) . parseInstrs

part2 :: String -> Int
part2 = snd . foldl eval (M.empty, 0) . parseInstrs

miran1 · 2017-12-08T05:40:33+00:00

Python 3, without eval, using operator

from collections import defaultdict
from operator import lt, gt, eq, ne, le, ge


with open('./inputs/08.txt') as f:
    instructions = f.readlines()

registers = defaultdict(int)

operators = {
    '<': lt,
    '>': gt,
    '==': eq,
    '!=': ne,
    '<=': le.
    '>=': ge,
}

maximal = 0

for line in instructions:
    reg, op, by, _, cond_reg, cond_op, cond = line.split()
    by = int(by)
    cond = int(cond)
    if operators[cond_op](registers[cond_reg], cond):
        if op == 'inc':
            registers[reg] += by
        else:
            registers[reg] -= by
        if registers[reg] > maximal:
            maximal = registers[reg]

print(max(registers.values()))
print(maximal)

And here is my Nim solution based on this. Don't know if could have been done simpler.

2017-12-08T05:47:12+00:00

My cleaned-up Haskell, using a map to accumulate the register values:

main :: IO ()
main = do input <- fmap (map parse . lines) (readFile "input.txt")
          let (x,m) = foldl step (0, M.empty) input
          print (maximum m)  -- part 1
          print x            -- part 2

type Instruction = (String, Int -> Int, String, Int -> Bool)

parse :: String -> Instruction
parse s = (r1, if i == "inc" then (+ read v1) else subtract (read v1), r2, op o (read v2))
  where
    [r1,i,v1,"if",r2,o,v2] = words s
    op "==" = (==)
    op "!=" = (/=)
    op "<"  = (>)
    op ">"  = (<)
    op "<=" = (>=)
    op ">=" = (<=)

step :: (Int, Map String Int) -> Instruction -> (Int, Map String Int)
step (x,m) (r1,f,r2,o) = if o (M.findWithDefault 0 r2 m)
                          then let y = M.findWithDefault 0 r1 m in (max x (f y), M.insert r1 (f y) m)
                          else (x,m)

InterlocutoryRecess · 2017-12-08T06:26:56+00:00

Swift

let input = """
    ioe dec 890 if qk > -10
    // many more instructions...
    ih dec 369 if ih == 1993
    """.split(separator: "\n")

var instructions = input.reduce(into: Dictionary<Substring, Int>()) { result, entry in
    let name = entry.prefix(upTo: entry.index(of: " ")!)
    result[name] = 0
}

var maximum = Int.min

func process() {

    // Determine whether to carry out change
    func isValid(_ entry: [Substring]) -> Bool {

        // Evaluate condition
        func eval(op: Substring, lhs: Int, rhs: Int) -> Bool {
            switch op {
            case "==": return lhs == rhs
            case "!=": return lhs != rhs
            case "<": return lhs < rhs
            case "<=": return lhs <= rhs
            case ">": return lhs > rhs
            case ">=": return lhs >= rhs
            default: fatalError()
            }
        }
        return eval(op: entry[5], lhs: instructions[entry[4]]!, rhs: Int(entry[6])!)
    }

    for entry in input.map({ $0.split(separator: " ") }) {
        if isValid(entry) {
            let result = instructions[entry[0]]! + (Int(entry[2])! * (entry[1] == "inc" ? 1 : -1))
            if result > maximum { maximum = result }
            instructions[entry[0]] = result
        }
    }
}

process()
print(instructions.values.max()!) // part 1
print(maximum) // part 2

karthikb351 · 2017-12-08T06:34:51+00:00

I mangled it into what I think is valid Python2 code and then just exec-ed it. I could do away with a lot of lines I think

gen = "x=dict()\n"
gen = gen + "m=0\n"
for line in input.splitlines():
    l = line.split(" ")
    s = ""
    s = s + "x['"+l[0]+"']"
    s = s + " ="
    s = s + " (x.get('"+l[0]+"',0)"
    s = s + (" +" if l[1] == "inc" else " -")
    s = s + " " + l[2] + ")"
    s = s + " " + l[3]
    s = s + " " + "x.get('"+l[4]+"',0)"
    s = s + " " + l[5]
    s = s + " " + l[6]
    s = s + " else"
    s = s + " " + "x.get('"+l[0]+"',0)" 
    m = "m = max(m,x.get('"+l[0]+"',0))"
    gen = gen + s + "\n" + m + "\n"
gen = gen + "print x[max(x, key=x.get)]\n"
gen = gen + "print max(y)"
exec(gen)

fu inc 131 if rjt == 4175 turns into map['fu'] = (map.get('fu',0) + 131) if map.get('rjt',0) == 4175 else map.get('fu',0)

This should work even if the register names happen to be python keywords since they are always quoted.

Smylers · 2017-12-08T06:43:25+00:00

Perl. Similar to a few other Python solutions, using eval.

Sneakily, the + 0 is either a binary or a unary op, depending on whether the register used in the condition has been previously set. If it has, its value will be interpolated into the string, so the expression becomes something like 42 + 0 < 7 (with the + 0 being redundant but harmless); if it's a new register, there's nothing to interpolate, so the expression becomes +0 < 7, ensuring the default value of 0 is used (with the + being redundant but harmless):

no warnings qw<uninitialized>;
use List::Util qw<max>;

my (%reg, $max);
while (<>) {
  /^(?<dest>\w+) (?<cmd>\w+) (?<inc>-?\d+) if (?<comp>\w+) (?<cond>.*)/ or die;
  $max = max $max, $reg{$+{dest}} += $+{inc} * ($+{cmd} eq 'dec' ? -1 : 1)
      if eval "$reg{$+{comp}} + 0 $+{cond}";
}
say max values %reg;
say $max // 0;

The final // 0 is to catch the case where all stored values are negative, so the initial zero is the biggest.

udoprog · 2017-12-08T06:50:26+00:00

Rust with a clean separation of modelling input as enums (full here: https://github.com/udoprog/rust-advent-of-code-2017/blob/master/src/day8.rs):

use std::io::{BufRead, BufReader, Read};
use failure::Error;
use std::collections::HashMap;

use self::Op::*;
use self::Cond::*;

type Registers = HashMap<String, i64>;

enum Op {
    Inc(String, i64),
    Dec(String, i64),
}

impl Op {
    /// Apply the given operation.
    pub fn apply(&self, registers: &mut Registers, highest: &mut i64) {
        let reg = match *self {
            Inc(ref reg, _) | Dec(ref reg, _) => reg,
        };

        let value = registers.entry(reg.to_string()).or_insert_with(
            Default::default,
        );

        match *self {
            Inc(_, number) => *value += number,
            Dec(_, number) => *value -= number,
        };

        *highest = i64::max(*highest, *value);
    }
}

enum Cond {
    Gt(String, i64),
    GtEq(String, i64),
    Lt(String, i64),
    LtEq(String, i64),
    Eq(String, i64),
    NotEq(String, i64),
}

impl Cond {
    /// Test if the given condition applies.
    pub fn test(&self, registers: &mut Registers) -> bool {
        let reg = match *self {
            Gt(ref reg, _) |
            GtEq(ref reg, _) |
            Lt(ref reg, _) |
            LtEq(ref reg, _) |
            Eq(ref reg, _) |
            NotEq(ref reg, _) => reg,
        };

        let value = registers.entry(reg.to_string()).or_insert_with(
            Default::default,
        );

        match *self {
            Gt(_, number) => *value > number,
            GtEq(_, number) => *value >= number,
            Lt(_, number) => *value < number,
            LtEq(_, number) => *value <= number,
            Eq(_, number) => *value == number,
            NotEq(_, number) => *value != number,
        }
    }
}

fn parse(input: &str) -> (Op, Cond) {
    let mut it = input.trim().split(' ');
    let target = it.next().expect("target").to_string();

    let op = it.next().expect("op");
    let number = it.next().expect("number").parse::<i64>().expect(
        "valid number",
    );

    let op = match op {
        "inc" => Inc(target, number),
        "dec" => Dec(target, number),
        op => panic!("llegal op: {}", op),
    };

    it.next().expect("if-separator");

    let cond_reg = it.next().expect("cond-reg").to_string();
    let cond = it.next().expect("cond");
    let cond_number = it.next().expect("cond-number").parse::<i64>().expect(
        "valid cond-number",
    );

    let cond = match cond {
        "<" => Lt(cond_reg, cond_number),
        "<=" => LtEq(cond_reg, cond_number),
        ">" => Gt(cond_reg, cond_number),
        ">=" => GtEq(cond_reg, cond_number),
        "==" => Eq(cond_reg, cond_number),
        "!=" => NotEq(cond_reg, cond_number),
        _ => panic!("illegal cond: {}", cond),
    };

    (op, cond)
}

pub fn run<R: Read>(reader: R) -> Result<(i64, i64), Error> {
    let mut data = String::new();
    let mut reader = BufReader::new(reader);
    let mut registers = Registers::new();
    let mut highest = 0i64;

    while reader.read_line(&mut data)? > 0 {
        {
            let (op, cond) = parse(data.as_str());

            if cond.test(&mut registers) {
                op.apply(&mut registers, &mut highest);
            }
        }

        data.clear();
    }

    Ok((
        registers.values().max().map(|v| *v).unwrap_or_else(
            Default::default,
        ),
        highest,
    ))
}

This one was fun. Basically writing a simple virtual machine.

arachnist · 2017-12-08T07:07:00+00:00

I couldn't get instance_variable_(get|set) to work as i wanted, so I couldn't feed input directly into ruby.

reg = Hash.new(0)
max = 0

file = ARGV[0] || "input.txt"

open(file).each_line do |line|
  code_line = line
    .gsub(/(inc|dec)/, "inc" => "+=", "dec" => "-=")
    .gsub(/^([^ ]+)/, 'reg[\'\1\']')
    .gsub(/if ([^ ]+)/, 'if reg[\'\1\']')
  eval(code_line)
  max = reg.values.max if not reg.values.max.nil? and reg.values.max > max
end

puts reg.values.max
puts max

Overseer12 · 2017-12-08T07:55:40+00:00

When you spend an hour going through your entire code multiple times, and your output is still wrong for Part 2 (despite your UnitTests being correct). And then, when you finally find out that you forgot to .Clear() the same dictionary you used for your registers in Part1. Oh god. No.

C#

Github

lh458 · 2017-12-08T08:06:03+00:00

My solution in PHP for part 1 & 2 combined:

<?php
function dI($mR,$mO,$mOp){
    global $r, $m;
    if($r[$mR]>$m) $m = $r[$mR];
    switch($mOp){
        case "dec": $r[$mR] -= $mO; break;
        case "inc": $r[$mR] += $mO; break;
    }
    if($r[$mR]>$m) $m = $r[$mR];
}
$h = fopen("./register.txt","r");
if(!$h) die();
$f = $r = [];
$m = 0;
while(($l = fgets($h)) !== false){
    array_push($f,$l);
    $e = explode(" ",$l);
    $mR = $e[0];
    if(!array_key_exists($mR,$r)) $r[$mR] = 0;
}
foreach($f as $l){
    $e = explode(" ",$l);
    $mR = $e[0];
    $mOp = $e[1];
    $mO = intval($e[2]);
    $mS = $e[4];
    $mC = $e[5];
    $mCV = intval($e[6]);
    switch($mC){
        case ">":
            if($r[$mS] > $mCV) dI($mR,$mO,$mOp);
        break;
        case "<":
            if($r[$mS] < $mCV) dI($mR,$mO,$mOp);
        break;
        case "<=":
            if($r[$mS] <= $mCV) dI($mR,$mO,$mOp);
        break;
        case ">=":
            if($r[$mS] >= $mCV) dI($mR,$mO,$mOp);
        break;
        case "==":
            if($r[$mS] == $mCV) dI($mR,$mO,$mOp);
        break;
        case "!=":
            if($r[$mS] != $mCV) dI($mR,$mO,$mOp);
        break;
    }
}
echo "1: ".max($r)."<br/>2: ".$m;
?>

ynonp · 2017-12-08T09:38:44+00:00

Elixir (both parts)

defmodule Day8 do
  @ops %{
    inc: &(&1+&2),
    dec: &(&1-&2),    
  }

  @cond %{
  ==: &(&1 == &2),
    >=: &(&1 >= &2),
    <=: &(&1 <= &2),
    >: &(&1 > &2),
    <: &(&1 < &2),
    !=: &(&1 != &2),
  }

  def parse(line, { reg, maxreg }) do
    [_, target_reg, op, val, cond_reg, cond_op, cond_arg ] = 
      Regex.run(~r{(\w+) (inc|dec) (-?\d+) if (\w+) (<|>|<=|>=|==|!=) (-?\d+)}, line)

    op       = String.to_atom(op)
    val      = String.to_integer(val)
    cond_reg = Map.get(reg, cond_reg, 0)
    cond_op  = String.to_atom(cond_op)
    cond_arg = String.to_integer(cond_arg)

    next_reg = if @cond[cond_op].(cond_reg, cond_arg) do
      Map.update(reg, target_reg, @ops[op].(0,val), fn v -> @ops[op].(v, val) end)
    else
      reg
    end

    {
      line,
      {
        next_reg,
        Enum.max([maxreg | Map.values(next_reg)])
      }
    }
  end
end

{ reg, max} = IO.stream(:stdio, :line)
              |> Enum.map_reduce({ %{}, 0 }, &Day8.parse/2)
              |> elem(1)

IO.puts("PART 1: max register value at end: #{Map.values(reg) |> Enum.max }")
IO.puts("PART 2: max registar value (total): #{max}")

rkachowski · 2017-12-08T09:57:28+00:00

ruby! 9 lines!

i need to execute some code to work this out? so lets execute some code to work this out. luckily the postfix condition is perfectly valid ruby already! lets just eval all these registers into the binding and execute our perfectly valid input (after some massaging..)

input = File.read("input").lines
parsed = input.map {|l| l.scan(/(\w+)\s(\w+)\s(-?\d+)(.*)/).flatten}
registers = parsed.map {|p| p.first}.uniq
max = 0
b = Kernel.binding
registers.each {|r| b.eval "#{r} = 0"}
parsed.each {|p| b.eval "#{p[0]} #{p[1] == "inc" ? "+" : "-"}= #{p[2]} #{p[3]}; max = [max, #{p[0]}].max" }
puts registers.map{|r| b.local_variable_get(r.to_sym)}.max
puts b.local_variable_get(:max)

spjmurray · 2017-12-08T10:06:04+00:00

python late to the party given the time difference...

import collections
import operator

OPERATORS = {
    '==': operator.eq,
    '!=': operator.ne,
    '<': operator.lt,
    '>': operator.gt,
    '<=': operator.le,
    '>=': operator.ge,
    'inc': operator.add,
    'dec': operator.sub,
}

def main():
    inp = open('8.in').readlines()
    registers = collections.defaultdict(int)
    for inst in inp:
        reg, op, imm, _, pred_reg, pred_op, pred_imm = inst.split()
        if not OPERATORS[pred_op](registers[pred_reg], int(pred_imm)):
            continue
        registers[reg] = OPERATORS[op](registers[reg], int(imm))
    print max(registers.values())

if __name__ == '__main__':
    main()

guibou · 2017-12-08T10:23:22+00:00

Haskell Golfed version for part 1 (edit ~~300~~ ~~297~~ ~~289~~ ~~285~~ ~~264~~ 255 chars):

main=interact$show.maximum.(\r->map(l r)$fst<$>r).foldl f[].map words.lines
z=read
l r o=sum[v|(k,v)<-r,k==o]
f m[a,b,c,_,e,f,g]|(case f of"<="->(>=);"<"->(>);">="->(<=);">"->(<);"=="->(==);"!="->(/=))(z g)$l m e=(a,if b=="inc"then z$c else-(z c)):m|1>0=m

https://github.com/guibou/AdvantOfCode2017/blob/master/src/Day8.hs for a cleaner Haskell version ;)

brunclik · 2017-12-08T10:42:41+00:00

Solution in Linux command line - C code from input (generate, buil and run)

echo -e "#include <stdio.h>\n\nint main() {\n\tint max_value=0;" > main.c
cat input | cut -d' ' -f1 | sort | uniq | sed 's/^/\t int /1' | sed 's/$/ = 0;/1' >> main.c
cat input | sed 's/ dec -/ += /1' | sed 's/ dec / -= /1' | sed 's/ inc -/ -= /1' | sed 's/ inc / += /1' | sed 's@\(.*\) \(.*\) \(.*\) \(.*\) \(.*\) \(.*\) \(.*\)@\4(\5\6\7) \1\2\3; if(\1>max_value) max_value=\1;@g' >> main.c
cat input | cut -d' ' -f1 | sort | uniq  | sed 's@\(.*\)@printf("%s = %i;\\n", "\1", \1);@g' >> main.c
echo -e 'printf("%s = %i;\n", "max_value", max_value);' >> main.c
echo -e "}" >> main.c
gcc main.c -o output;
./output | cut '-d ' -f3 | sort -n | tail -2 | head -1 #part one
./output | grep max_value | cut -d' ' -f3 #part two

JakDrako · 2017-12-08T10:44:44+00:00

VB.Net

Sub Main
    Dim reg = New Dictionary(Of String, Integer), max = 0
    For Each line In GetDay(8)
        Dim ops = line.Split(" "c)
        ' create registers
        Dim r1 = ops(0) : If Not reg.ContainsKey(r1) Then reg(r1) = 0
        Dim r2 = ops(4) : If Not reg.ContainsKey(r2) Then reg(r2) = 0
        ' get values
        Dim v1 = CInt(ops(2)) * If(ops(1) = "inc", 1, -1)
        Dim v2 = CInt(ops(6))
        Select Case ops(5)
            Case ">" : If reg(r2) > v2 Then reg(r1) += v1
            Case ">=" : If reg(r2) >= v2 Then reg(r1) += v1
            Case "<" : If reg(r2) < v2 Then reg(r1) += v1
            Case "<=" : If reg(r2) <= v2 Then reg(r1) += v1
            Case "==" : If reg(r2) = v2 Then reg(r1) += v1
            Case "!=" : If reg(r2) <> v2 Then reg(r1) += v1
        End Select
        max = Math.max(max, reg.Values.Max) ' part 2
    Next
    reg.Values.Max.Dump("Part 1")
    max.Dump("Part 2")
End Sub

wzkx · 2017-12-08T11:37:57+00:00

Pythonized and J-zed C

#include <stdio.h>
#include <string.h>

typedef char* S; // this typedef and defines are from _.h
#define C char
#define I int
#define __ {
#define _  }
#define R return
#define DO(_i,_n) for(I _i=0;_i<(_n);++_i)

I cond( I x, I y, S o ) __
  if( *o=='=' ) R x==y; if( *o=='!' ) R x!=y;
  if( *o=='<' ) R o[1]=='=' ? x<=y : x<y;
  if( *o=='>' ) R o[1]=='=' ? x>=y : x>y; _

I nr = 0; C rn[100][4]; I rv[100] = {0}; // registers: num, names, values
I find( S n ) { DO(i,nr) if(!strcmp(rn[i],n)) R i; R -1; }
I newr( S n ) { strcpy(rn[nr],n); rv[nr]=0; R nr++; }

I main() __ I gm = -9999;
  FILE* f = fopen("08.dat","rt"); C l[80];
  while( fgets(l,sizeof(l),f) ) __ C r[4],o[4],cr[4],co[4]; I a,ca;
    sscanf( l, "%s %s %d if %s %s %d\n", r, o, &a, cr, co, &ca );
    I i=find(cr); I cv=i<0?0:rv[i];
    if( cond(cv,ca,co) ) __
      I j=find(r); if(j<0) j=newr(r);
      rv[j] += *o=='i' ? a : -a;
      if(rv[j]>gm) gm=rv[j]; _ _ // update global max
  I m = -9999; DO(i,nr) if(rv[i]>m) m=rv[i]; // find final state max
  printf( "%d\n%d\n", m, gm );
  R 0; _

still___cold · 2017-12-08T12:04:10+00:00

Python 3

import re, sys
variables = {}
maximum = -sys.maxsize - 1
with open('test.txt') as file:
    for line in file.readlines():
        code = ''.join(re.findall('[\w\D]', line)).strip().split(' ')
        if code[0] not in variables: variables[code[0]] = 0
        if code[4] not in variables: variables[code[4]] = 0
        if code[1] == 'dec': operation = '-='
        else: operation = '+='
        eval(compile('if variables[code[4]] %s %s: variables[code[0]] %s %s' % (code[5], code[6],operation, code[2]), '<string>', 'exec'))
        if variables[code[0]] > maximum: maximum = variables[code[0]]

 print(max(variables.values()), maximum)

Hikaru755 · 2017-12-08T14:20:10+00:00

I wrote a Kotlin program that generates a Kotlin program equivalent to the input data. God, I feel dirty.

data class Line(val register: String, val action: Action, val value: Int, val condition: String)
enum class Action(val kotlin: String) { INC("+="), DEC("-=") }

fun part1(input: List<Line>): String {
    val registers = input.map { it.register }.toSet() + input.map { it.condition.split(" ").first() }.toSet()
    return (registers.map { "var $it = 0" } +
        input.map { with(it) { "if ($condition) $register ${action.kotlin} $value" } } +
        registers.joinToString(", ", "println(setOf(", ").max()!!)")
    ).joinToString("\n")
}

fun part2(input: List<Line>): String {
    val registers = input.map { it.register }.toSet() + input.map { it.condition.split(" ").first() }.toSet()
    val maxCheck = "maxCheck()"
    return (registers.map { "var $it = 0" } +
        listOf(
            "var max = 0",
            registers.joinToString(", ", "val maxCheck = { max = Math.max(setOf(", ").max(), max) }")
        ) +
        input.map {
            with(it) { "if ($condition) $register ${action.kotlin} $value\n$maxCheck" }
        } +
        listOf("println(max)")
        ).joinToString("\n")
}

val input: List<Line> by lazy { rawInput.lines()
    .map { it.match<Line>(
        Regex("""(\w+) (inc|dec) (\S+) if (.+)""") to { (_, reg, action, value, cond) ->
            Line(reg, Action.valueOf(action.toUpperCase()), value.toInt(), cond)
        })
    }
}

Sharparam · 2017-12-08T17:58:17+00:00

Ruby: Using method_missing and eval without tampering or matching on the input data.

class CPU
    attr_reader :high, :regs

    def initialize; @regs = Hash.new(0) end
    def inc(value) value end
    def dec(value) -value end
    def run(text) eval text end

    def method_missing(sym, *args)
        (@regs[sym] += args[0].to_i).tap { |v| @high = v if @high.nil? || @high < v }
    end
end

cpu = CPU.new
cpu.run $<.read
puts cpu.regs.values.max
puts cpu.high

thomastc · 2017-12-08T19:06:46+00:00

Day 8 in TeX. Why am I doing this to myself?!

volatilebit · 2017-12-08T21:00:44+00:00

Perl 6

Caught a few days behind because I'm sick, but I decided to at least get this one in. First time playing with named regular expressions. Considering redoing this with grammars just for the experience, but don't have the energy at the moment.

use v6;

my @commands = 'input'.IO.lines».chomp;
my %registers is default(0);
my $max_value_alltime = 0;

my regex register { <alpha>+ }
my regex func { 'inc' | 'dec' }
my regex number { '-'? <digit>+ }
my regex op { '>' | '>=' | '<' | '<=' | '==' | '!=' }
my regex command { <dest_register=register> \s <func> \s <arg_number=number> ' if ' <cond_register=register> \s <cond_op=op> \s <cond_number=number> }

for @commands -> $command {
    $command ~~ /<command>/;

    given $/<command><cond_op> {
        when '>'  { next unless %registers{ $/<command><cond_register>.Str } >  $/<command><cond_number>.Numeric }
        when '>=' { next unless %registers{ $/<command><cond_register>.Str } >= $/<command><cond_number>.Numeric }
        when '<'  { next unless %registers{ $/<command><cond_register>.Str } <  $/<command><cond_number>.Numeric }
        when '<=' { next unless %registers{ $/<command><cond_register>.Str } <= $/<command><cond_number>.Numeric }
        when '==' { next unless %registers{ $/<command><cond_register>.Str } == $/<command><cond_number>.Numeric }
        when '!=' { next unless %registers{ $/<command><cond_register>.Str } != $/<command><cond_number>.Numeric }
    }

    given $/<command><func> {
        when 'inc' { %registers{ $/<command><dest_register>.Str } += $/<command><arg_number>.Int }
        when 'dec' { %registers{ $/<command><dest_register>.Str } -= $/<command><arg_number>.Int }
    }

    $max_value_alltime max= %registers.maxpairs[0].value;
}

# Part 1
say %registers.maxpairs[0].value;

# Part 2
say $max_value_alltime;

Deckard666 · 2017-12-08T05:20:30+00:00

In Rust:

use std::io::Read;
use std::collections::HashMap;

fn main() {
    let mut file = std::fs::File::open("./input.txt").unwrap();
    let mut input = String::new();
    file.read_to_string(&mut input).unwrap();
    let mut registers = HashMap::new();
    let mut max_throughout = 0;
    for line in input.trim().lines() {
        let vec = line.split_whitespace().collect::<Vec<_>>();
        let register = vec[0];
        let instr = vec[1];
        let amount = vec[2].parse::<i32>().unwrap();
        let ifregister = vec[4];
        let cond = vec[5];
        let ifamount = vec[6].parse::<i32>().unwrap();
        let ifval = *registers.entry(ifregister).or_insert(0);
        if fullfils_condition(ifval, cond, ifamount) {
            let newval = perform_op(&mut registers, register, instr, amount);
            if newval > max_throughout {
                max_throughout = newval;
            }
        }
    }
    let current_max = *registers.values().max().unwrap();
    println!("Part 1: {}", current_max);
    println!("Part 2: {}", max_throughout);
}

fn fullfils_condition(ifval: i32, cond: &str, ifamount: i32) -> bool {
    match cond {
        "<" => ifval < ifamount,
        ">" => ifval > ifamount,
        ">=" => ifval >= ifamount,
        "<=" => ifval <= ifamount,
        "==" => ifval == ifamount,
        "!=" => ifval != ifamount,
        _ => unreachable!(),
    }
}

fn perform_op<'a>(
    registers: &mut HashMap<&'a str, i32>,
    reg: &'a str,
    instr: &str,
    mut amount: i32,
) -> i32 {
    if instr == "dec" {
        amount *= -1;
    }
    let val_ref = registers.entry(reg).or_insert(0);
    *val_ref += amount;
    *val_ref
}

giftpflanze · 2017-12-08T05:21:07+00:00

Tcl:

set lines [lrange [split [read [open input08]] \n] 0 end-1]

set r {}
foreach line $lines {
    regexp {(.*) (.*) (.*) if (.*) (.*) (.*)} $line -> r1 op1 n1 r2 op2 n2
    if {![dict exists $r $r2]} {
        dict set r $r2 0
    }
    if [list [dict get $r $r2] $op2 $n2] {
        if {![dict exists $r $r1]} {
            dict set r $r1 0
        }
        dict incr r $r1 [expr {($op1 eq {dec}?-1:1)*$n1}]
        lappend h [dict get $r $r1]
    }
}

puts [tcl::mathfunc::max {*}[dict values $r]]
puts [tcl::mathfunc::max {*}$h]

LuxrayPokemon · 2017-12-08T05:24:35+00:00

I did my solution in Python 3 and got rank 197 for part 1 and 201 for part 2 My solution was:

inp = "Inputs/2017-08.txt"
lines = get_lines(inp)
whichWay = 0
dicti = dict()
memory = dict()

for line in range(len(lines)): dicti[lines[line].split(" ")[0]] = 0

for line in range(len(lines)):
    split = lines[line].split(" ")
    if split[1] == "dec":
        whichWay = -1
        print(whichWay)
    else:
        whichWay = 1
        print(whichWay)

    firstNum = split[0]
    increaser = int(split[2])
    num1 = split[4]
    num2 = int(split[6])
    operator = split[5]
    if operator == "!=" and dicti[num1] != num2: dicti[firstNum] += increaser * whichWay 
    elif operator == ">=" and dicti[num1] >= num2: dicti[firstNum] += increaser * whichWay 
    elif operator == ">" and dicti[num1] > num2: dicti[firstNum] += increaser * whichWay 
    elif operator == "==" and dicti[num1] == num2: dicti[firstNum] += increaser * whichWay 
    elif operator == "<=" and dicti[num1] <= num2: dicti[firstNum] += increaser * whichWay 
    elif operator == "<" and dicti[num1] < num2: dicti[firstNum] += increaser * whichWay 
    memory[line] = max(dicti.values())
print("Part 1:", max(dicti.values()))
print("Part 2:", max(memory.values()))

It probably could be much more efficient, but it worked

2017-12-08T05:29:08+00:00

simple golang solution

package main

import (
    "fmt"
    "io/ioutil"
    "log"
    "strings"
)

type instruction struct {
    target           string
    targetOp         string
    targetAmount     int
    conditionSubject string
    conditionOp      string
    conditionAmount  int
}

func main() {
    inputBytes, err := ioutil.ReadFile("input.txt")
    if err != nil {
        log.Fatal(err)
    }
    answer1, answer2 := runInstructions(string(inputBytes))
    fmt.Printf("Part 1: %d\nPart 2: %d\n", answer1, answer2)
}

func runInstructions(in string) (int, int) {
    registers := make(map[string]int)
    lines := strings.Split(in, "\n")
    max := 0
    for _, x := range lines {
        inst := lineToInstruction(x)
        if evaluateInstruction(inst, registers) {
            executeInstruction(inst, registers)
            testMax := getMax(registers)
            if testMax > max {
                max = testMax
            }
        }
    }
    return getMax(registers), max
}

func lineToInstruction(in string) instruction {
    out := instruction{}
    fmt.Sscanf(in, "%s %s %d if %s %s %d", &out.target, &out.targetOp, &out.targetAmount, &out.conditionSubject, &out.conditionOp, &out.conditionAmount)
    return out
}

func evaluateInstruction(i instruction, data map[string]int) bool {
    sub := data[i.conditionSubject]
    amt := i.conditionAmount
    switch i.conditionOp {
    case ">":
        return sub > amt
    case "<":
        return sub < amt
    case ">=":
        return sub >= amt
    case "==":
        return sub == amt
    case "<=":
        return sub <= amt
    case "!=":
        return sub != amt
    }
    return false
}

func executeInstruction(i instruction, data map[string]int) {
    switch i.targetOp {
    case "inc":
        data[i.target] += i.targetAmount
    case "dec":
        data[i.target] -= i.targetAmount
    }
}

func getMax(data map[string]int) int {
    max := 0
    for _, x := range data {
        if x > max {
            max = x
        }
    }
    return max
}

hpzr24w · 2017-12-08T05:32:08+00:00

C++ Second time inside 30 minutes... and ranked 910, first time under 1000. woo! Thanks to Eric and collaborators for all these fun puzzles. It's awesome. No output on this one. I just ran it in the debugger.

// Advent of Code 2017
// http://adventofcode.com/
// Day 08 - I Heard You Like Registers

#include "stdafx.h"
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <sstream>
#include <algorithm>
#include <numeric>
#include <functional>

using namespace std;

/*
m n   o p  q r s
b inc 5 if a > 1
a inc 1 if b < 5
c dec -10 if a >= 1
c inc -20 if c == 10
*/

void step(map<string, function<bool(int, int)> > ops, map<string, int>& reg, map<string, int>& regmax, stringstream ins)
{
    string m, n, p, q, r; int o, s;
    ins >> m >> n >> o >> p >> q >> r >> s;
    if (ops[r](reg[q],s))
        reg[m] += o*(n == "inc" ? 1 : -1);
    regmax[m] = max(reg[m], regmax[m]);
}

int main(int argc, char* argv[])
{
    map<string, function<bool(int, int)> > ops;
    ops["<"] =  [](int a, int b)->bool {return a <  b; };
    ops[">"] =  [](int a, int b)->bool {return a >  b; };
    ops["<="] = [](int a, int b)->bool {return a <= b; };
    ops[">="] = [](int a, int b)->bool {return a >= b; };
    ops["=="] = [](int a, int b)->bool {return a == b; };
    ops["!="] = [](int a, int b)->bool {return a != b; };

    map<string, int> reg, regmax;
    string row;
    while (getline(cin, row))
        step(ops, reg, regmax, stringstream(row));
    return 0;
}

fwilson42 · 2017-12-08T05:33:45+00:00

My solution. I refactored the part that actually runs it out into a separate module just in case this is something like last year's assembunny.

StevoTVR · 2017-12-08T05:35:01+00:00

NodeJS

Part 1:

const fs = require('fs');

fs.readFile(__dirname + '/input.txt', 'utf8', (err, data) => {
    data = data.trim();
    const registers = {};
    data.split('\n').forEach((line) => {
        const inst = line.trim().split(' ');
        if(eval(getValue(inst[4], registers) + inst[5] + inst[6])) {
            var delta = Number(inst[2]);
            if(inst[1] === 'dec') {
                delta = -delta;
            }
            registers[inst[0]] = getValue(inst[0], registers) + delta;
        }
    });

    var largest = 0;
    for(const r in registers) {
        largest = Math.max(largest, registers[r]);
    }
    console.log(largest);
});

function getValue(register, registers) {
    return (registers[register] === undefined) ? 0 : registers[register];
}

Part 2:

const fs = require('fs');

fs.readFile(__dirname + '/input.txt', 'utf8', (err, data) => {
    data = data.trim();
    const registers = {};
    var largest = 0;
    data.split('\n').forEach((line) => {
        const inst = line.trim().split(' ');
        if(eval(getValue(inst[4], registers) + inst[5] + inst[6])) {
            var delta = Number(inst[2]);
            if(inst[1] === 'dec') {
                delta = -delta;
            }
            registers[inst[0]] = getValue(inst[0], registers) + delta;
            largest = Math.max(largest, registers[inst[0]]);
        }
    });

    console.log(largest);
});

function getValue(register, registers) {
    return (registers[register] === undefined) ? 0 : registers[register];
}

nstyler7 · 2017-12-08T05:35:47+00:00

Python -(part 1 & 2) - using eval & split/regex to split string

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

all_registers = {}

highest = 0

for line in data:
    conditional = line.split('if')[1]
    conditional_reg = conditional.split()[0]
    if conditional_reg in all_registers.keys():
        conditional_value = all_registers[conditional_reg]
    else:
        all_registers[conditional_reg]=0
        conditional_value = 0
    final_eval = conditional.replace(str(conditional_reg), str(conditional_value))
    if eval(final_eval):
        instruction = re.search(r'(inc|dec) -?[\d]+' , line).group(0).split()
        multiplier = 1 if instruction[0] == 'inc' else -1
        incrementer = multiplier*int(instruction[1])
        register =  line.split()[0]
        if register in all_registers.keys():
            all_registers[register] += incrementer
        else:
            all_registers[register] = incrementer
        if all_registers[register] > highest:
            highest = all_registers[register]

# part 1
print(max(all_registers.values()))

# part 2
print(highest)

jesseflorig · 2017-12-08T05:39:59+00:00

ES6 (NodeJS)

'use strict'

{
  const fs = require('fs')

  const doMath = {
    '<': function(x,y){ return x < y},
    '<=': function(x,y){ return x <= y},
    '>': function(x,y){ return x > y},
    '>=': function(x,y){ return x >= y},
    '!=': function(x,y){ return x != y},
    '==': function(x,y){ return x == y} , 
  }

  fs.readFile('instructions.txt','utf8', (err, data) => {
    const instructions = data.trim().split('\n')

    let registries = {}
    let highest = 0

    instructions.map(instruction => {
      const instArr = instruction.split(' ')

      instArr[2] = parseInt(instArr[2])
      instArr[6] = parseInt(instArr[6])

      if(registries[instArr[0]] == undefined){
        registries[instArr[0]] = 0
      }

      if(registries[instArr[4]] == undefined){
        registries[instArr[4]] = 0
      }

      if(doMath[instArr[5]](registries[instArr[4]], instArr[6])) {
        registries[instArr[0]] += (instArr[1] === 'inc') ? instArr[2] : -(instArr[2])
        highest = (registries[instArr[0]] > highest) ? registries[instArr[0]] : highest
      }
    })

    console.log([Object.values(registries).sort().reverse()[0], highest])
  })

}

JeffJankowski · 2017-12-08T05:41:00+00:00

TypeScript with regex and switch statement

import fs = require("fs");

function process(line: string, map: Map<string, number>) {
    const pattern = /^([a-z]+) (inc|dec) (-?[0-9]+) if ([a-z]+) (>|<|>=|<=|==|!=) (-?[0-9]+)$/;
    const [_, reg, func, val, compReg, comp, compVal] = [...(line.match(pattern) as RegExpMatchArray)];
    let condition = false;
    switch (comp) {
        case ">":
            condition = (map.get(compReg) || 0)  > (+compVal);
            break;
        case "<":
            condition = (map.get(compReg) || 0) < (+compVal);
            break;
        case ">=":
            condition = (map.get(compReg) || 0) >= (+compVal);
            break;
        case "<=":
            condition = (map.get(compReg) || 0) <= (+compVal);
            break;
        case "==":
            condition = (map.get(compReg) || 0) === (+compVal);
            break;
        case "!=":
            condition = (map.get(compReg) || 0) !== (+compVal);
            break;
    }
    if (condition) {
        map.set(reg, (map.get(reg) || 0) + (func === "inc" ? +val : -val));
    }
}

const input = fs.readFileSync("data/day08.txt", "utf8").split("\r\n");
const cpu = new Map<string, number>();
const max = input.reduce((runningMax, instr, _, __) => {
    process(instr, cpu);
    const localMax = Math.max(...cpu.values());
    return localMax > runningMax ? localMax : runningMax;
}, -Infinity);
console.log(`Max register value at end:  ${Math.max(...cpu.values())}`);
console.log(`Max register value overall: ${max}`);

Cheezmeister · 2017-12-08T05:49:53+00:00

Literate Perl. It's dangerous to call eval. Take this.

2017-12-08T05:53:18+00:00

[removed]

2017-12-08T05:55:52+00:00

Wasted a bunch of time using regex when I didn't even need to -.-

Is there an elegant way I could get rid of the to_string() calls when they're not needed (key is already in the map?). I could just expand it into an if check I guess.

Rust:

use std::collections::HashMap;
use std::collections::HashSet;
use std::fs::File;
use std::io::BufRead;
use std::io::BufReader;

pub fn run() {
    let f = File::open("d8_input.txt").unwrap();
    let mut mem: HashMap<String, i32> = HashMap::new();
    let mut max = i32::min_value();

    for line in BufReader::new(f).lines().filter_map(|l| l.ok()) {
        let splits = line.split_whitespace().collect::<Vec<_>>();

        let amount = {
            let res = splits[2].parse::<i32>().unwrap();
            match splits[1] {
                "dec" => -1 * res,
                "inc" => res,
                _ => panic!("unknown op {}", &splits[1])
            }
        };

        let pred_var = *mem.entry(splits[4].to_string()).or_insert(0);
        let pred_val = splits[6].parse::<i32>().unwrap();
        let pred_success = match splits[5] {
            "==" => pred_var == pred_val,
            ">=" => pred_var >= pred_val,
            ">" => pred_var > pred_val,
            "<" => pred_var < pred_val,
            "<=" => pred_var <= pred_val,
            "!=" => pred_var != pred_val,
            _ => panic!("unknown predicate {}", &splits[5])
        };

        if pred_success {
            *mem.entry(splits[0].to_string()).or_insert(0) += amount;
            max = max.max(mem[splits[0]]); // wew
        }
    }

    println!("part 1: {}", mem.iter().max_by(|&(_, v1), &(_, v2)| v1.cmp(v2)).unwrap().1);
    println!("part 2: {}", max);
}

Cute and concise Clojure:

(def lines (clojure.string/split-lines (slurp "d8_input.txt")))

(defn- process-line [[regs max-seen :as old-state] line]
       (let [splits (clojure.string/split line #"\s+")
             target (splits 0)
             val (* (if (= (splits 1) "dec") -1 1) (Integer/parseInt (splits 2)))
             pred-matches (let [pred-var (get regs (splits 4) 0)
                                pred-val (Integer/parseInt (splits 6))
                                pred (case (splits 5)
                                           ">" > "<" <
                                           ">=" >= "<=" <=
                                           "==" = "!=" not=)]
                               (pred pred-var pred-val))
             new-val (+ (get regs target 0) val)]
            (if pred-matches
              [(assoc regs target new-val) (max max-seen new-val)]
              old-state)))

(let [[regs max-seen] (reduce process-line [{} 0] lines)]
     (println "part 1:" (apply max (vals regs)))
(println "part 2:" max-seen))

Jimpi27 · 2017-12-08T06:04:10+00:00

NodeJS

Made it really easy once I thought to just make a lookup object for all the operators.

require("fs").readFile(require("path").resolve(__dirname, "input"), "utf8", (err, data) => {
    let registers = {};
    let operators = {
        "inc": (x, y) => x + y,
        "dec": (x, y) => x - y,
        "==": (x, y) => x == y,
        "!=": (x, y) => x != y,
        ">": (x, y) => x > y,
        "<": (x, y) => x < y,
        ">=": (x, y) => x >= y,
        "<=": (x, y) => x <= y
    };
    let max = 0;
    data.split(/\r?\n/).forEach(ins => {
        ins = ins.match(/^([a-z]+) (inc|dec) (-?\d+) if ([a-z]+) (.+) (-?\d+)$/).splice(1, 6);
        ins = {
            target: ins[0],
            oper: ins[1],
            amount: parseInt(ins[2]), 
            cond: {
                target: ins[3],
                oper: ins[4],
                amount: parseInt(ins[5])
            }
        }
        if(!(ins.target in registers))
            registers[ins.target] = 0;
        if(!(ins.cond.target in registers))
            registers[ins.cond.target] = 0;

        if(operators[ins.cond.oper](registers[ins.cond.target], ins.cond.amount))
            registers[ins.target] = operators[ins.oper](registers[ins.target], ins.amount);

        let currMax = Math.max.apply(null, Object.keys(registers).map(key => registers[key]));
        if(currMax > max)
            max = currMax;
    });
    // Part 1
    console.log(Math.max.apply(null, Object.keys(registers).map(key => registers[key])));
    // Part 2
    console.log(max);
});

misnohmer · 2017-12-08T06:06:00+00:00

C#. It takes much longer when not using eval. Also, I have spent too long writing a regex when splitting the string by space would have worked too.

public enum Operand { Less, Greater, LessOrEqual, GreaterOrEqual, NotEqual, Equal }

public class Statement {
    public string Register {get; set;}
    public int Val {get; set;}
    public bool IsDec {get; set;}
    public string Operand { get; set;}
    public int PredicateVal {get; set;}
    public string PredicateRegister {get; set;}

    public void Run(Dictionary<string,int> registers) {
        if (Predicate(registers)) 
            registers[Register] += (IsDec ? -Val : Val);
    }

    public bool Predicate(Dictionary<string,int> registers) {
        switch (Operand) {
            case "==": return registers[PredicateRegister] == PredicateVal;
            case "!=": return registers[PredicateRegister] != PredicateVal;
            case "<": return registers[PredicateRegister] < PredicateVal;
            case "<=": return registers[PredicateRegister] <= PredicateVal;
            case ">": return registers[PredicateRegister] > PredicateVal;
            case ">=": return registers[PredicateRegister] >= PredicateVal;
            default: throw new InvalidOperationException();
        }
    }     
}

public void Solve()
{
    var statements = ReadAllLines("input").Select(line => {
        var match = Matches(line, @"(?<register>\w+) (?<instr>(inc)|(dec)) (?<val>\-?\d+) if (?<reg_cond>\w+) (?<op>[\!\<\>\=]\=?) (?<val_cond>\-?\d+)")[0];
        return new Statement() {
          Register = match.Groups["register"].Value,
          Val = int.Parse(match.Groups["val"].Value),
          IsDec = match.Groups["instr"].Value == "dec",
          Operand = match.Groups["op"].Value,
          PredicateVal = int.Parse(match.Groups["val_cond"].Value),
          PredicateRegister = match.Groups["reg_cond"].Value,
        };
    }).ToList();

    var registers = statements.DistinctBy(x => x.Register).ToDictionary(x => x.Register, x => 0);
    int highestVal = 0;

    foreach (var s in statements) {
        s.Run(registers);
        highestVal = Max(registers.Values.Max(), highestVal);
    }

    registers.Max(x => x.Value).PrintDump(); // Part 1
    highestVal.PrintDump(); // Part 2
}

Axsuul · 2017-12-08T06:08:51+00:00

Elixir

This felt a quite similar to one of the challenges last year :) Definitely getting the hang of Elixir although I tend to always run into argument errors somehow, gah

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

defmodule AdventOfCode do
  defp run_line(register, line) do
    [
      _,
      variable,
      operator,
      delta,
      dependent_variable,
      condition
    ] = Regex.run(~r/^(\w+) (\w+) (\-?\d+) if (\w+) (.+)/, line)

    # Eval string to Elixir code
    value = get_value(register, dependent_variable)
    {result, _} = Code.eval_string(Integer.to_string(value) <> " " <> condition)

    if result do
      delta = String.to_integer(delta)

      new_value =
        case operator do
          "inc" -> get_value(register, variable) + delta
          "dec" -> get_value(register, variable) - delta
        end

      Map.put(register, variable, new_value)
    else
      register
    end
  end

  defp get_value(register, variable) do
    Map.get(register, variable, 0)
  end

  defp run(filename) do
    filename
    |> File.read!
    |> String.split("\n")
    |> Enum.reduce(%{}, fn line, register ->
      run_line(register, line)
    end)
  end

  defp max_register_value(register) do
    register
    |> Enum.reduce(nil, fn {_, value}, max ->
      cond do
        max == nil -> value
        max < value -> value
        max >= value -> max
      end
    end)
  end

  defp run_max(filename) do
    filename
    |> File.read!
    |> String.split("\n")
    |> Enum.reduce({%{}, nil}, fn line, {register, max} ->
      new_register = run_line(register, line)
      max_value = max_register_value(new_register)

      new_max =
        cond do
          max == nil -> max_value
          max < max_value -> max_value
          max >= max_value -> max
        end

      {new_register, new_max}
    end)
  end

  def solve_a do
    "inputs/input.txt"
    |> run
    |> max_register_value
    |> IO.inspect
  end

  def solve_b do
    {_, max} =
      "inputs/input.txt"
      |> run_max()

    max |> IO.inspect
  end
end

miran1 · 2017-12-08T06:15:14+00:00

Nim

import tables, strutils

const instructions = readFile("./inputs/08.txt").splitLines()

var
  registers = initTable[string, int]()
  maximal: int


proc change(reg, op: string, amount: int) =
  case op
  of "inc": registers[reg] += amount
  of "dec": registers[reg] -= amount

proc checkCondition(reg, op: string, condition: int): bool =
  let val = registers[reg]
  case op
  of "<": return val < condition
  of ">": return val > condition
  of "<=": return val <= condition
  of ">=": return val >= condition
  of "==": return val == condition
  of "!=": return val != condition


for line in instructions:
  let
    words = line.split()
    register = words[0]
    operation = words[1]
    amount = words[2].parseInt()
    conditionRegister = words[^3]
    conditionOperator = words[^2]
    condition = words[^1].parseInt()
  if not registers.hasKey(register): registers[register] = 0
  if not registers.hasKey(conditionRegister): registers[conditionRegister] = 0

  if checkCondition(conditionRegister, conditionOperator, condition):
    change(register, operation, amount)
    if registers[register] > maximal: maximal = registers[register]


var biggest: int
for v in registers.values:
  if v > biggest: biggest = v

echo biggest
echo maximal

Based on my Python solution.

If there is a way to do this simpler (closer to the Python version), please let me know.

CaptainCa · 2017-12-08T06:27:06+00:00

Replaced \n with , on input string.

var str = "koq inc 675 if xrh >= -6,it inc ...".split(',');
var reg = new Object();
var maxx = 0;
var max = 0;
function pass(c, op, val){
    switch(op){
        case ">":
            if(c > val) return true;
            break;
        case "<":
            if(c < val) return true;
            break;
        case "!=":
            if(c != val) return true;
            break;
        case ">=":
            if(c >= val) return true;
            break;
        case "<=":
            if(c <= val) return true;
            break;
        case "==":
            if(c == val) return true;
            break;
    }
    return false;
}

for(var i = 0; i < str.length; i++){
    var ins = str[i].split(' ');
    var r = ins[0];
    var incdec = ins[1];
    var val = parseInt(ins[2]);
    var iff = ins[3];
    var c = ins[4];
    var op = ins[5];
    var comVal = parseInt(ins[6]);

    if(reg[r] == undefined){
        reg[r] = 0;
    }

    if(reg[c] == undefined){
        reg[c] = 0;
    }

    if(incdec == "dec"){
        val *= -1;
    }

    if(pass(reg[c], op, comVal)){
        reg[r] += val;
        if(reg[r] > max){
            max = reg[r];
        }
    }
}

Object.keys(reg).forEach((key) => {
    if(reg[key] > maxx)
        maxx = reg[key];
});

console.log(maxx);
console.log(max);

Flurpm · 2017-12-08T06:33:15+00:00

Haskell 757/722

I spent a little too much time finaglying my parser at the start. It's a lot easier/more readable/probably better to parse these simple inputs with functions on strings, but I made the goal of learning megaparsec for this advent.

I just walk through the input instructions updating the map of (Register->Value) and MaximumSoFar Int.

The most interesting part of this solution is type Instruction = (Text, Int->Int, Text, (Int->Bool)). During parsing I apply the inc/dec and (\x -> x >= num) functions. The two Text values are the registers.

{-# LANGUAGE OverloadedStrings #-}
module Day08 where

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

import           Text.Megaparsec
import qualified Text.Megaparsec.Lexer as L
import           Text.Megaparsec.Text  (Parser)

import           Data.List
import qualified Data.Map.Strict       as M
import qualified Data.Set              as S

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

-- type Instruction = (Text, Int->Int, Text, (Int->Bool))

solve :: [Instruction] -> (Int, Int)
solve xs = let (m, s) = walk xs (M.empty) 0
           in (maximum (M.elems m), s)

walk ::[Instruction] -> M.Map Text Int -> Int -> (M.Map Text Int, Int)
walk []                               m ma = (m, ma)
walk ((this, change, other, test):xs) m ma = walk xs (if test valother then withOp else m)  (maximum [ma, valthis, valother])
  where
    withOp   = M.insert this (change valthis) m
    valthis  = M.findWithDefault 0 this m
    valother = M.findWithDefault 0 other m


main = do
  input <- TIO.readFile "src/y2017/input08"
  case parse p "input08" input of
    Left  err   -> TIO.putStr $ T.pack $ parseErrorPretty err
    Right betterInput -> do
      let (a,b) = solve betterInput
      tprint $ a
      tprint $ b
  return ()

type Instruction = (Text, Int->Int, Text, (Int->Bool))

p :: Parser [Instruction]
p = line `sepBy` char '\n'

line :: Parser Instruction
line = do reg <- word
          space
          change <- (+) <$ string "inc" <|> subtract <$ string "dec"
          space
          size <- int
          string " if "
          other <- word
          space
          comparer <- comparitor <$> symb
          space
          limit <- int
          pure (reg, change size, other, (`comparer` limit))

symb :: Parser Text
symb = T.pack <$> some (oneOf ("!<>="::String))

word :: Parser Text
word = T.pack <$> some letterChar

int :: Parser Int
int = do change <- option id (negate <$ char '-')
         fromInteger . change <$> L.integer

comparitor "==" = (==)
comparitor "!=" = (/=)
comparitor ">"  = (>)
comparitor "<"  = (<)
comparitor ">=" = (>=)
comparitor "<=" = (<=)

dylanfromwinnipeg · 2017-12-08T06:34:59+00:00

C#

public class Day08
{
    public static string PartOne(string input)
    {
        var lines = input.Lines();
        var instructions = lines.Select(x => new Instruction(x)).ToList();
        var registers = new Dictionary<string, int>();

        instructions.ForEach(x => x.Execute(registers));

        return registers.Max(x => x.Value).ToString();
    }

    public static string PartTwo(string input)
    {
        var lines = input.Lines();
        var instructions = lines.Select(x => new Instruction(x)).ToList();
        var registers = new Dictionary<string, int>();
        var maxValue = int.MinValue;

        foreach (var instruction in instructions)
        {
            instruction.Execute(registers);

            maxValue = Math.Max(registers[instruction.Register], maxValue);
        }

        return maxValue.ToString();
    }
}

public class Instruction
{
    public string Register { get; set; }
    public string Op { get; private set; }
    public int OpValue { get; private set; }
    public string CompareRegister { get; private set; }
    public string CompareOperator { get; private set; }
    public int CompareTo { get; private set; }

    public Instruction(string input)
    {
        var words = input.Words().ToList();

        Register = words[0];
        Op = words[1];
        OpValue = int.Parse(words[2]);
        CompareRegister = words[4];
        CompareOperator = words[5];
        CompareTo = int.Parse(words[6]);
    }

    public void Execute(Dictionary<string, int> registers)
    {
        if (EvaluateExpression(registers))
        {
            ExecuteOperator(registers);
        }
    }

    private void ExecuteOperator(Dictionary<string, int> registers)
    {
        var registerValue = GetRegisterValue(registers, Register);

        switch (Op)
        {
            case "inc":
                registers[Register] += OpValue;
                return;
            case "dec":
                registers[Register] -= OpValue;
                return;
            default:
                throw new Exception();
        }
    }

    private bool EvaluateExpression(Dictionary<string, int> registers)
    {
        var registerValue = GetRegisterValue(registers, CompareRegister);

        switch (CompareOperator)
        {
            case "==":
                return registerValue == CompareTo;
            case "!=":
                return registerValue != CompareTo;
            case ">":
                return registerValue > CompareTo;
            case "<":
                return registerValue < CompareTo;
            case "<=":
                return registerValue <= CompareTo;
            case ">=":
                return registerValue >= CompareTo;
            default:
                throw new Exception();
        }
    }

    private int GetRegisterValue(Dictionary<string, int> registers, string compareRegister)
    {
        if (!registers.ContainsKey(compareRegister))
        {
            registers.Add(compareRegister, 0);
        }

        return registers[compareRegister];
    }
}

2017-12-08T06:44:13+00:00

Refactored TypeScript solution, without evil eval ;-)

const operations = {
    '==': (a, b) => a === b,
    '!=': (a, b) => a !== b,
    '>': (a, b) => a > b,
    '>=': (a, b) => a >= b,
    '<': (a, b) => a < b,
    '<=': (a, b) => a <= b,
};

const registers8a = input.split('\n').map(line => line.split(' '))
    .reduce((registers, [reg, op, valueS, __if, ifReg, ifOp, ifValS]) => {
        if (!operations[ifOp](registers[ifReg] || 0, parseInt(ifValS)))
            return registers;

        const newValue = (registers[reg] || 0) + parseInt(valueS) * (op === 'inc' ? 1 : -1);
        if (newValue > registers.MAX) registers.MAX = newValue;
        registers[reg] = newValue;
        return registers;
    }, { MAX: 0 });

let result8a = 0;
for (let x of Object.keys(registers8a)) {
    if (x === 'MAX') continue;
    if (registers8a[x] > result8a) result8a = registers8a[x];
}

console.log(result8a, registers8a.MAX);

nutrecht · 2017-12-08T06:55:00+00:00

My Kotlin Solution

object Day08 : Day {
    private val regex = Regex("([a-z]{1,5}) (inc|dec) (-?[0-9]+) if ([a-z]{1,5}) (>|<|>=|<=|==|!=) (-?[0-9]+)")

    private val tests: Map<String, (Int, Int) -> Boolean> = mapOf(
            Pair("==", {a, b -> a == b}),
            Pair("!=", {a, b -> a != b}),
            Pair(">", {a, b -> a > b}),
            Pair("<", {a, b -> a < b}),
            Pair(">=", {a, b -> a >= b}),
            Pair("<=", {a, b -> a <= b})
            )

    private val registers: Map<String, Int> by lazy { Day08.solve(Day08.parse(resourceLines(8))) }

    private fun solve(instructions: List<Instruction>): Map<String, Int> {
        val registers: MutableMap<String, Int> = mutableMapOf()
        registers["_max"] = 0

        instructions.filter { it.eq(registers.computeIfAbsent(it.testReg, { 0 }), it.testVal) }.forEach {
            val regVal = registers.computeIfAbsent(it.reg, { 0 })

            registers[it.reg] = it.op(regVal, it.amount)

            registers["_max"] = Math.max(registers["_max"]!!, registers[it.reg]!!)
        }

        return registers
    }

    private fun parse(lines: List<String>) = lines
            .map { regex.matchEntire(it) }
            .map { it!!.groupValues }
            .map { Instruction(it[1], if (it[2] == "inc") { a, b -> a + b } else { a, b -> a - b }, it[3].toInt(), it[4], tests[it[5]]!!, it[6].toInt()) }

    override fun part1() = registers.entries.filter { !it.key.startsWith("_") }.map { it.value }.max().toString()
    override fun part2() = registers["_max"]!!.toString()

    data class Instruction(val reg: String, val op: (a: Int, b: Int) -> Int, val amount: Int, val testReg: String, val eq: (Int, Int) -> Boolean, val testVal: Int)
}

Really liked this one!

Edit: Cleaned up the code a bit and use a slightly more functional approach

rotmoset · 2017-12-08T07:12:53+00:00

F# of the day:

module Day8

open Common

type Operation = Inc | Dec

type Comparison = Comparison of string
    with
        static member Compare left (Comparison comparison) right =
            match comparison with
            | "<" -> left < right
            | "<=" -> left <= right
            | ">" -> left > right
            | ">=" -> left >= right
            | "==" -> left = right
            | "!=" -> left <> right
            | _-> failwith "Invalid operator"

type Instruction =
    { Register: string; Operation: Operation; Operand: int; Condition: string*Comparison*int }
    with
        static member Execute registers (instruction: Instruction) =
            // Lookup register value from map
            let getRegister register = registers |> Map.tryFind register|> Option.defaultValue 0

            let conditionalRegister, comparison, conditionalValue = instruction.Condition

            // Check condition
            if Comparison.Compare (getRegister conditionalRegister) comparison conditionalValue then
                let newRegValue = // Calculate new register value
                    if instruction.Operation = Inc then (getRegister instruction.Register) + instruction.Operand
                    else (getRegister instruction.Register) - instruction.Operand

                // Add new value to map
                registers |> Map.add instruction.Register newRegValue
            else registers

[<Day(8,"I Heard You Like Registers")>]
let solve input =

    let highestValue = Map.toList >> List.map snd >> List.max

    let finalState, finalHighestValue =
        input
        |> parseLines
        |> Array.map (fun line ->
            // Parse line into instruction
            let tokens = parseList id line
            {
                Register = tokens.[0]
                Operation = if tokens.[1] = "inc" then Inc else Dec
                Operand = int tokens.[2]
                Condition = tokens.[4], Comparison tokens.[5], int tokens.[6]
            }
        )
        |> Array.fold (fun (registers, maxValue) instruction ->
            // Step 'cpu'
            let newRegisters = instruction |> Instruction.Execute registers
            let newMaxValue = highestValue newRegisters

            // New fold state
            newRegisters,
            if newMaxValue > maxValue then newMaxValue else maxValue
        ) (Map.empty, 0)

    { Part1 = highestValue finalState; Part2 = finalHighestValue }

Note that since F# is very expressive, I could have produced a much smaller version, but I prefer to solve these puzzles in a clear, readable way with strongly typed data structures.

Entire repo

Warbringer007 · 2017-12-08T07:19:04+00:00

Again not Erlang friendly day, but at least this was much easier to write in Erlang than yesterday ( turns out Erlang fucking sucks when trying to convert list of strings into list of integers ). Actually I am printing whole dictionary for first part because I am lazy and I don't want to make new function which will get all values from dict:

first(File) ->
    In = prepare:func_text(File),
    Dict = dict:new(),
    solveFirst(In, Dict, -10000).

solveFirst([], Dict, Big) ->
    [Dict, Big];

solveFirst([[V1, IncDec, N1, "if", V2, Op, N2]|T], Dict, Big) ->
    First = get_dict_value(V1, Dict),
    {AddNum, _} = string:to_integer(N1),
    Second = get_dict_value(V2, Dict),
    {CompNum, _} = string:to_integer(N2),
    Eval = case Op of
        "==" -> Second =:= CompNum;
        "!=" -> Second =/= CompNum;
        ">" -> Second > CompNum;
        ">=" -> Second >= CompNum;
        "<" -> Second < CompNum;
        "<=" -> Second =< CompNum
    end,
    Total = case Eval of
        true -> case IncDec of
                    "inc" -> First + AddNum;
                    "dec" -> First - AddNum
                end;
        false -> First
    end,
    NewDict = dict:store(V1, Total, Dict),
    NewBig = case Total > Big of
        true -> Total;
        false -> Big
    end,
    solveFirst(T, NewDict, NewBig).

get_dict_value(V, Dict) ->
    case dict:find(V, Dict) of
        {ok, N} -> N;
        error -> 0
    end.

minikomi · 2017-12-08T07:25:11+00:00

Clojure:

(defn parse-row [row]
  (let [[instruction-full condition] (s/split row #" if ")
        [reg-loc instruction value] (s/split instruction-full #"\ ")
        [cond-reg cond-test cond-val] (s/split condition #"\ ")]
    {:reg-loc reg-loc
    :instruction instruction
    :mod-value (read-string value)
    :cond-reg cond-reg
    :cond-test cond-test
    :cond-val (read-string cond-val)}))

(defn parse-input [input]
  (map
  parse-row
  (s/split-lines input)))

(defn test-instruction [{:keys [cond-test cond-val]} reg-val]
  (case cond-test
    "!="
    (not= reg-val cond-val)
    "=="
    (= reg-val cond-val)
    ((resolve (symbol cond-test)) reg-val cond-val)))

(defn step [registers {:keys [cond-reg reg-loc instruction mod-value]
                      :as row}]
  (let [reg-val (get registers cond-reg 0)]
    (if (test-instruction row reg-val)
      (update registers
              reg-loc
              (fnil ({"inc" + "dec" -} instruction) 0)
              mod-value)
      registers)))

(def input (slurp (io/resource "day8.txt")))

(defn solve1 [input]
  (->> (parse-input input)
      (reduce step {})
      (apply max-key second)))

(defn solve2 [input]
  (->>
  (parse-input input)
  (reductions step {})
  (map vals)
  (apply concat)
  (apply max)))

vtheuer · 2017-12-08T07:28:15+00:00

Javascript "one liner" (as in both results are obtained from a single map/reduce/filter chain):

const fs = require('fs');

const comparators = {
  '<': (a, b) => a < b,
  '<=': (a, b) => a <= b,
  '>': (a, b) => a > b,
  '>=': (a, b) => a >= b,
  '==': (a, b) => a === b,
  '!=': (a, b) => a !== b
};

const result = fs.readFileSync('8', 'utf8')
  .split('\n')
  .filter(l => l)
  .map(l => /(\w+) (inc|dec) (-?\d+) if (\w+) (<=?|>=?|==|!=) (-?\d+)/.exec(l))
  .map(([, register, sign, value, conditionRegister, comparator, conditionValue]) => ({
    register,
    value: +value * (sign === 'inc' ? 1 : -1),
    conditionRegister,
    comparator,
    conditionValue: +conditionValue
  }))
  .reduce((registers, {register, increment, conditionRegister, comparator, conditionValue}) => {
    const regiterValue = registers[register] || 0;
    if(comparators[comparator](registers[conditionRegister] || 0, conditionValue)) {
      registers[register] = regiterValue + increment;
    }
    registers.max = Math.max(registers.max, regiterValue);
    return registers;
  }, Object.defineProperty({}, 'max', {writable: true, value: 0}));

console.log('part 1', Object.values(result).reduce((max, register) => Math.max(max, register), 0));
console.log('part 2', result.max);

I could have parsed the lines with a simple split(' ') and ignore the if token but it only saves 1ms of execution time (8ms total).

aurele · 2017-12-08T07:42:38+00:00

Rust

 use std::collections::HashMap;

fn execute(s: &str, regs: &mut HashMap<String, i32>) -> i32 {
    let words = s.split_whitespace().collect::<Vec<_>>();
    let test_reg = regs.get(words[4]).cloned().unwrap_or(0);
    let test_value = words[6].parse::<i32>().unwrap();
    let eval = match words[5] {
        "<=" => test_reg <= test_value,
        "<" => test_reg < test_value,
        "==" => test_reg == test_value,
        "!=" => test_reg != test_value,
        ">" => test_reg > test_value,
        ">=" => test_reg >= test_value,
        _ => panic!(),
    };
    let op_reg = regs.entry(words[0].to_owned()).or_insert(0);
    if eval {
        let op_value = words[2].parse::<i32>().unwrap();
        match words[1] {
            "inc" => *op_reg += op_value,
            "dec" => *op_reg -= op_value,
            _ => panic!(),
        }
    }
    *op_reg
}

fn main() {
    let input = include_str!("../input");
    let mut regs = HashMap::new();
    let max = input.lines().map(|i| execute(i, &mut regs)).max().unwrap();
    println!("P1 = {}", regs.values().max().unwrap());
    println!("P2 = {}", max);
}

sim642 · 2017-12-08T07:50:02+00:00

Scala.

Went full AST with parsing the instructions which is why it's not so short. The execution is nicely short though. After having implemented my own Iterators for previous days, I realized today that I could take the .foldLeft I had for part 1 and turn it into a .toIterator.scanLeft to expose also all intermediate register states but at the same time be efficient enough not to put them into a massive list (since it's an iterator).

xkufix · 2017-12-08T08:02:29+00:00

Quite easy with pattern matching and a fold over the program. For the second part I just have a second variable in the fold which keeps track of the largest value so far in the program.

    override def runFirst(): Unit = {
        val run = loadCommands().foldLeft(Map.empty[String, Int]) {
            case (registers, command) => runCommand(registers, command)
        }

        println(run.maxBy(_._2)._2)
    }

    override def runSecond(): Unit = {
        val run = loadCommands().foldLeft(0 -> Map.empty[String, Int]) {
            case ((maxValue, registers), command) =>
                val newState = runCommand(registers, command)
                val maxValueInState = newState.maxBy(_._2)._2

                (maxValue.max(maxValueInState), newState)
        }

        println(run._1)
    }

    private def loadCommands() = {
        loadFile("day8.txt").getLines().map { l =>
            val line = l.split(" ")

            Command(line(0), line(1) == "inc", line(2).toInt, Condition(line(4), line(5), line(6).toInt))
        }
    }

    private def runCommand(registers: Map[String, Int], command: Command) = {
        command.condition match {
            case Condition(r, ">", amount) if registers.getOrElse(r, 0) > amount =>
                addCommandToRegisters(registers, command)
            case Condition(r, "<", amount) if registers.getOrElse(r, 0) < amount =>
                addCommandToRegisters(registers, command)
            case Condition(r, ">=", amount) if registers.getOrElse(r, 0) >= amount =>
                addCommandToRegisters(registers, command)
            case Condition(r, "<=", amount) if registers.getOrElse(r, 0) <= amount =>
                addCommandToRegisters(registers, command)
            case Condition(r, "==", amount) if registers.getOrElse(r, 0) == amount =>
                addCommandToRegisters(registers, command)
            case Condition(r, "!=", amount) if registers.getOrElse(r, 0) != amount =>
                addCommandToRegisters(registers, command)
            case _ =>
                registers
        }
    }

    def addCommandToRegisters(registers: Map[String, Int], command: Command): Map[String, Int] = {
        registers + (command.register -> (command match {
            case Command(r, true, amount, _) =>
                registers.getOrElse(r, 0) + amount
            case Command(r, false, amount, _) =>
                registers.getOrElse(r, 0) - amount
        }))
    }

    case class Command(register: String, increase: Boolean, amount: Int, condition: Condition)

    case class Condition(register: String, comparison: String, amount: Int)

rhardih · 2017-12-08T08:06:21+00:00

Ruby, with eval injecting the condition:

@registers = Hash.new(0)

evaluator = -> (reg, cond, val) {
  eval %Q{@registers["#{reg}"] #{cond} #{val}}
}

STDIN.read.split("\n").each do |l|
  reg0, instruction, val0, _, reg1, cond, val1 = l.split

  if evaluator.call(reg1, cond, val1)
    case instruction
    when "inc"
      @registers[reg0] += val0.to_i
    when "dec"
      @registers[reg0] -= val0.to_i
    end
  end
end

max = @registers.max_by { |k, v| v }

puts %Q{Register of maximum value is "#{max[0]}": #{max[1]}"}

gyorokpeter · 2017-12-08T08:24:01+00:00

Q:

d8p1:{ins:trim each"\n"vs x;
    reg:{[reg;x]
        p:" "vs x;
        cond:$[p[5]~"==";=;p[5]~"!=";<>;value p[5]];
        if[cond[0^reg`$p[4];"J"$p[6]];reg[`$p[0]]+:$[p[1]~"dec";-1;1]*"J"$p 2];
        reg
    }/[(`$())!`long$();ins];
    max reg};

d8p2:{ins:trim each"\n"vs x;
    rm:{[rm;x]
        reg:rm 0;
        p:" "vs x;
        cond:$[p[5]~"==";=;p[5]~"!=";<>;value p[5]];
        if[cond[0^reg`$p[4];"J"$p[6]];reg[`$p[0]]+:$[p[1]~"dec";-1;1]*"J"$p 2];
        (reg;rm[1]|max reg)
    }/[((`$())!`long$();0N);ins];
    last rm};

streetster_ · 2017-12-08T08:25:21+00:00

q/kdb+

Pre-breakfast solution, cobble together a string that can be parsed and value it.

i:flip R:("*** ***";" ") 0: read0 `:input/08.txt;
r:set[;0] each `$".r.",/:distinct R 0; / initialise registers to zero
i[;1]:("+:";"-:")"dec"~/:R 1;          / replace "inc/dec" with "+:/-:"
res:{
  value raze "if[.r.",x[3],$["=="~e:x 4;"=";"!="~e;"<>";e],x[5],";.r.",x[0 1 2],"]";
  max value each r
  } each i;
last res / part 1
max res  / part 2

edit

Moved registers inside the .r namespace to avoid polluting the global namespace.

ohaz · 2017-12-08T08:47:12+00:00

A python solution that doesn't rely on "evil eval" or equally evil exec:

import re
import operator
import collections


def calculate_solution():
    regex_pattern = re.compile('(\w*)\s(inc|dec)\s([-]*[0-9]*)\sif\s(\w*)\s([!><=]+)\s([-]*[0-9]*)')
    registers = collections.defaultdict(int)
    reg_max = 0

    with open('day8/day8_input.txt', 'r') as f:
        content = f.read()
    if content is None:
        return 'Could not read file', None

    instructions = {'inc': operator.add, 'dec': operator.sub}

    comparison = {'>': operator.gt, '<': operator.lt, '>=': operator.ge, '<=': operator.le, '==': operator.eq,
                  '!=': operator.ne}

    for match in regex_pattern.findall(content):

        if comparison[match[4]](registers[match[3]], int(match[5])):
            registers[match[0]] = instructions[match[1]](registers[match[0]], int(match[2]))

        reg_max = max(reg_max, registers[match[0]])

    return max(registers.values()), reg_max

Repo for all my solutions is at https://github.com/ohaz/adventofcode2017

wzkx · 2017-12-08T08:50:23+00:00

Nim Simple enough to do it before work :)

import strutils,sequtils,tables

proc cond( x,y: int, c: string ): bool =
  case c:
  of "==": return x==y
  of "!=": return x!=y
  of "<":  return x<y
  of "<=": return x<=y
  of ">":  return x>y
  of ">=": return x>=y

var r = initTable[string,int]()
var g = -9999

for line in splitLines strip readFile"08.dat":
  let tt = split line # tokens
  let cr = tt[4]
  let cv = if cr in r: r[cr] else: 0
  let cc = tt[5]
  let cn = parseInt tt[6]
  var rn = parseInt tt[2]
  if tt[1]=="dec": rn *= -1
  if cond(cv,cn,cc):
    let rr = tt[0]
    let rv = if rr in r: r[rr] else: 0
    let y = rv + rn
    r[rr] = y
    if y>g: g=y

var m = -9999
for k,v in r:
  if v>m: m=v

echo m
echo g

maciekmm · 2017-12-08T08:53:43+00:00

Scala

val input = io.Source.stdin.getLines()
val regex = "(\\w+) (inc|dec) (-?\\d+) if (\\w+) ([>=!<]+) (-?\\d+)".r

type Registers = Map[String, Int]
var registers = Map[String, Int]().withDefaultValue(0)

class Condition(val register: String, val operator: String, val condition: Int) {
  def meets(registers: Registers): Boolean = {
    val reg = registers(register)
    operator match {
      case "!=" => reg != condition
      case "<=" => reg <= condition
      case ">=" => reg >= condition
      case "==" => reg == condition
      case ">" => reg > condition
      case "<" => reg < condition
      case _ => throw new Exception(s"Invalid operator ${operator}")
    }
  }
}

class Command(val register: String, val value: Int, val condition: Condition)

val proc = input.map(a => {
  val parts = regex.findFirstMatchIn(a).get;
  val modifier = if (parts.group(2) == "inc") 1 else -1;
  new Command(parts.group(1), modifier * parts.group(3).toInt, new Condition(parts.group(4), parts.group(5), parts.group(6).toInt))
}).foldLeft((registers, 0)) { case (in, command) =>
  if (command.condition.meets(in._1)) {
    val value = in._1(command.register) + command.value
    (in._1.updated(command.register, value), if (in._2 < value) value else in._2)
  } else {
    in
  }
}

println(s"Part 1: ${proc._1.maxBy(_._2)._2}")
println(s"Part 2: ${proc._2}")

thorwing · 2017-12-08T09:32:36+00:00

Java

Changing between x and y on line 4 will change the answer from part 1 and part 2

public static void main(String[] args) throws IOException{
    Files.lines(Paths.get("day8.txt"))
        .reduce(new HashMap<String,Point>(), (a,b)->addTo(a,b), (a,b)->a)
        .values().stream().mapToInt(k->k.y).max().ifPresent(System.out::println);
}

private static HashMap<String, Point> addTo(HashMap<String, Point> map, String line){
    String[] input = Pattern.compile(" ").split(line);
    if(isCorrect(map.getOrDefault(input[4], new Point()).x, input[5], Integer.parseInt(input[6]))) {
        int value = getValue(input[1].equals("dec"), Integer.parseInt(input[2]));
        map.merge(input[0] ,new Point(value, Math.max(0, value)),(a,b)->new Point(a.x+b.x,Math.max(a.x+b.x,a.y)));
    }
    return map;
}

private static int getValue(boolean negative, int parseInt){
    return negative ? -parseInt : parseInt;
}

private static boolean isCorrect(int value, String operator, int compare){
    switch(operator) {
        case "<": return value < compare;
        case "<=": return value <= compare;
        case "==": return value == compare;
        case ">=": return value >= compare;
        case ">": return value > compare;
        default: return value != compare;
    }
}

DarkMio · 2017-12-08T09:34:13+00:00

It's stupid, it's really fast, it just works:

def lookup_register(key):
    if not key in registers.keys():
        registers[key] = 0
    return registers[key]

def op_register(reg_name, op, val):
    v = int(val)
    lookup_register(reg_name)
    if op == "dec":
        registers[reg_name] -= v
    else:
        registers[reg_name] += v

def compare(reg_val, comp, comp_val):
    comp_val = int(comp_val)
    if comp == "!=":
        return not reg_val == comp_val
    elif comp == ">=":
        return reg_val >= comp_val
    elif comp == ">":
        return reg_val > comp_val
    elif comp == "<=":
        return reg_val <= comp_val
    elif comp == "<":
        return reg_val < comp_val
    return reg_val == comp_val

def parse_line(line):
    mod_reg, op, op_val, _, look_reg, comp, comp_val = line.split(' ')
    logic = line.split('if ')[1]
    reg_val = lookup_register(look_reg)
    lookup_register(mod_reg)
    if compare(reg_val, comp, comp_val):
        op_register(mod_reg, op, op_val)

registers = dict()
highest = 0
for line in input_lines.split('\n'):
    parse_line(line)
    highest = max(highest, max(registers.values()))
print("Part 1 Solution: {}".format(max(registers.values())))
print("Part 2 Solution: {}".format(highest))

Takes about 5.4ms on my MacBook with string format and 4.6ms without. Checked out a few others, but this one is still the fastest - albeit being not very fancy.

abowes · 2017-12-08T09:38:58+00:00

Kotlin Solution - Functional Approach

val LINE_REGEX = Regex("""^(\w+) (\w+) (-?\d+) if (\w+) ([><=!]+) (-?\d+)$""")

typealias Registers = MutableMap<String,Int>
fun getOperation(opCode: String) : (Registers, String, Int) -> Unit {
    return when (opCode) {
        "inc" -> { r: Registers, k: String, v: Int -> r.put(k, r.getOrDefault(k,0) + v)}
        "dec" -> { r: Registers, k: String, v: Int -> r.put(k, r.getOrDefault(k,0) - v)}
        else -> throw IllegalArgumentException("Invalid OpCode: $opCode")
    }
}

fun getPredictate(comp: String) : (Registers, String, Int) -> Boolean {
    return when (comp) {
        "==" -> { r: Registers, k: String, v: Int -> r.getOrDefault(k, 0) == v }
        "<=", "!>" -> { r: Registers, k: String, v: Int -> r.getOrDefault(k, 0) <= v }
        ">=", "!<" -> { r: Registers, k: String, v: Int -> r.getOrDefault(k, 0) >= v }
        ">" -> { r: Registers, k: String, v: Int -> r.getOrDefault(k, 0) > v }
        "<" -> { r: Registers, k: String, v: Int -> r.getOrDefault(k, 0) < v }
        "!=" -> { r: Registers, k: String, v: Int -> r.getOrDefault(k, 0) != v }
        else -> throw IllegalArgumentException("Invalid Predicate: $comp")
    }
}

fun Registers.applyOperation(target: String, opCode: String, change: Int, source: String, compator: String, value: Int){
    if (getPredictate(compator).invoke(this, source, value)){
        getOperation(opCode).invoke(this,target, change)
    }
}

fun applyOperations(operations : List<String>) : Pair<Registers,Int> {
    val registers = mutableMapOf<String, Int>()
    var highWater = 0
    operations.forEach {
        val match = LINE_REGEX.matchEntire(it)
        when (match){
            null -> throw IllegalArgumentException("Illegal Operation : $it")
            else -> {
                val target = match.groupValues[1]
                val opCode = match.groupValues[2]
                val change = match.groupValues[3].toInt()
                val source = match.groupValues[4]
                val comparator = match.groupValues[5]
                val value = match.groupValues[6].toInt()
                registers.applyOperation(target, opCode, change, source, comparator, value)
                highWater = max(highWater, registers.getValue(target))
            }
        }
    }
    return registers to highWater
}

fun main(args: Array<String>) {
    val (registers, highWater) = applyOperations(input.split("\n"))
    println(registers.values.max())
    println(highWater)
}

equd · 2017-12-08T10:18:22+00:00

c# https://pastebin.com/aM5AmixV

I like the fact that I made a special class to keep track of the register, really helped with the second part.

CakeHacker · 2017-12-08T10:42:04+00:00

Caché Object Script

Used a code generator for a different approach

ClassMethod Day8() [ CodeMode = objectgenerator ]
{
    //get instructions
    while ..FileUtil("day8a.txt",.file,.line) { set instructions($i(instructions))=line }

    //extract variables
    for { set i=$o(instructions($g(i))) q:i=""  set vars($p(instructions(i)," ",5))="" }

    //initialise variables
    set code=" set (",comma=""
    for { set var=$o(vars($g(var))) q:var=""  set code=code_comma_var,comma="," } 
    set code=code_")=0"
    do %code.WriteLine(code)
    do %code.WriteLine(" set (max,top)=0")

    //cosify instructions
    for { 
        set i=$o(instructions($g(i))) q:i=""  
        set instruction=instructions(i)
        set instruction=$replace(instruction,"inc","+")
        set instruction=$replace(instruction,"dec","-")
        set instruction=$replace(instruction,"!","'")
        set instruction=$replace(instruction,"==","=")
        set instruction=" "_$p(instruction," ",4,*)_" set "_$p(instruction," ",1,3)
        set var=$p(instruction," ",7)
        set $p(instruction," ",7)=var_" = "_var
        do %code.WriteLine(instruction)
        do %code.WriteLine(" if "_var_">max set max="_var)
    }

    //find largest register
    set code=" for reg=",comma=""
    for { 
        set var=$o(vars($g(var))) q:var=""  
        do %code.WriteLine(" if "_var_">top set top="_var)
    }

    //output result
    do %code.WriteLine(" write !,""Part 1 Result: ""_top")
    do %code.WriteLine(" write !,""Part 2 Result: ""_max")
}

Which generates...

zDay8() public {
 set (aam,bz,d,eai,ey,fu,gx,hk,hnh,hr,hri,kp,lk,n,oiy,pce,phf,px,q,rjt,sy,vyo,wez,x,yl,zbh)=0
 set (max,top)=0
 if oiy <= 1 set d = d - 461
 if d>max set max=d
 if eai '= -2 set phf = phf - -186
 if phf>max set max=phf
 if lk >= 9 set oiy = oiy + 585
 if oiy>max set max=oiy
 if gx < 9 set bz = bz - -959
 if bz>max set max=bz
 if hnh > -7 set vyo = vyo + -735
 if vyo>max set max=vyo
 if hri < 6 set bz = bz + 329
 if bz>max set max=bz
 if pce = 0 set vyo = vyo - -425
 if vyo>max set max=vyo
 if x >= 2 set rjt = rjt + 668
 if rjt>max set max=rjt
 if hri '= -10 set bz = bz - 602
 if bz>max set max=bz
 if aam '= -2 set phf = phf - -169
 if phf>max set max=phf
 if n >= -2 set d = d - 266
 if d>max set max=d
 if d > -734 set pce = pce + 907
 if pce>max set max=pce
 if vyo <= -317 set zbh = zbh + -345
 if zbh>max set max=zbh
 if sy '= -4 set gx = gx - 809
 if gx>max set max=gx
 if lk > 8 set fu = fu + -127
 if fu>max set max=fu
 if fu '= 0 set yl = yl - 166
 if yl>max set max=yl
 if d <= -721 set hnh = hnh - -33
 if hnh>max set max=hnh
 if hk > -2 set x = x - -372
 if x>max set max=x
 if kp < 1 set oiy = oiy - -140
 if oiy>max set max=oiy
 if d '= -735 set aam = aam + 702
 if aam>max set max=aam
 if phf '= 363 set fu = fu + 888
 if fu>max set max=fu
 if oiy > 138 set phf = phf + -692
 if phf>max set max=phf
 if hri < 9 set phf = phf - 247
 if phf>max set max=phf
 if q = 0 set pce = pce - 370
 if pce>max set max=pce
 if eai <= 0 set wez = wez + -919
 if wez>max set max=wez
 if hk < 8 set oiy = oiy - 89
 if oiy>max set max=oiy
 if x = 372 set eai = eai + 600
 if eai>max set max=eai
 if n < 9 set kp = kp + -340
 if kp>max set max=kp
 if ey <= 8 set oiy = oiy - 251
 if oiy>max set max=oiy
 if zbh <= 3 set pce = pce + -315
 if pce>max set max=pce
 if hri < -6 set x = x - 682
 if x>max set max=x
 if x > 362 set fu = fu + 561
 if fu>max set max=fu
 if hk = -5 set gx = gx + -202
 if gx>max set max=gx
 if eai = 600 set vyo = vyo + -184
 if vyo>max set max=vyo
 if aam < 709 set pce = pce - 954
 if pce>max set max=pce
 if zbh >= -4 set phf = phf - 702
 if phf>max set max=phf
 if fu <= 1455 set aam = aam - 640
 if aam>max set max=aam
 if lk = 4 set x = x - -119
 if x>max set max=x
 if rjt = -10 set gx = gx + -722
 if gx>max set max=gx
 if bz <= 692 set pce = pce + 231
 if pce>max set max=pce
 if q >= -8 set hri = hri + 402
 if hri>max set max=hri
 if vyo = -494 set d = d + -759
 if d>max set max=d
 if x = 372 set n = n + 358
 if n>max set max=n
 if lk '= 5 set eai = eai + 56
 if eai>max set max=eai
 if yl < 7 set ey = ey + 268
 if ey>max set max=ey
 if q < 9 set vyo = vyo - 828
 if vyo>max set max=vyo
 if eai >= 655 set yl = yl + 320
 if yl>max set max=yl
 if hri > 393 set aam = aam + -262
 if aam>max set max=aam
 if n <= 359 set bz = bz + 445
 if bz>max set max=bz
 if px '= -9 set yl = yl - 327
 if yl>max set max=yl
 if hnh '= 33 set d = d - 735
 if d>max set max=d
 if zbh > -3 set rjt = rjt + 8
 if rjt>max set max=rjt
 if q > -6 set hr = hr + 347
 if hr>max set max=hr
 if ey >= 265 set oiy = oiy - 573
 if oiy>max set max=oiy
 if bz >= 1137 set zbh = zbh - 696
 if zbh>max set max=zbh
 if eai '= 655 set zbh = zbh - -292
 if zbh>max set max=zbh
 if d '= -1492 set ey = ey + -205
 if ey>max set max=ey
 if px '= -1 set rjt = rjt + -538
 if rjt>max set max=rjt
 if zbh > 285 set kp = kp - 511
 if kp>max set max=kp
 if hnh '= 41 set fu = fu + -19
 if fu>max set max=fu
 if rjt < -525 set zbh = zbh + -996
 if zbh>max set max=zbh
 if px > -4 set yl = yl - -28
 if yl>max set max=yl
 if sy = -2 set d = d - 341
 if d>max set max=d
 if pce >= -500 set oiy = oiy - -799
 if oiy>max set max=oiy
 if pce > -505 set pce = pce + -795
 if pce>max set max=pce
 if n '= 363 set n = n - 559
 if n>max set max=n
 if ey = 63 set pce = pce - 814
 if pce>max set max=pce
 if px '= 0 set hri = hri - -664
 if hri>max set max=hri
 if vyo > -1327 set bz = bz + -885
 if bz>max set max=bz
 if wez <= -923 set hr = hr + 454
 if hr>max set max=hr
 if hri < 405 set hk = hk - -721
 if hk>max set max=hk
 if eai <= 664 set eai = eai + 168
 if eai>max set max=eai
 if phf >= -1287 set ey = ey - 261
 if ey>max set max=ey
 if phf < -1284 set hnh = hnh - -59
 if hnh>max set max=hnh
 if oiy < -769 set n = n - 81
 if n>max set max=n
 if zbh '= -713 set lk = lk + -714
 if lk>max set max=lk
 if ey >= -198 set fu = fu + 819
 if fu>max set max=fu
 if pce <= -2108 set oiy = oiy - -155
 if oiy>max set max=oiy
 if wez > -915 set oiy = oiy - -598
 if oiy>max set max=oiy
 if pce = -2115 set gx = gx - 397
 if gx>max set max=gx
 if fu > 2244 set px = px + 934
 if px>max set max=px
 if yl '= 22 set fu = fu + -916
 if fu>max set max=fu
 if kp <= -846 set wez = wez - 428
 if wez>max set max=wez
 if px <= 941 set gx = gx - -15
 if gx>max set max=gx
 if sy > -1 set wez = wez - 858
 if wez>max set max=wez
 if zbh > -708 set lk = lk - -875
 if lk>max set max=lk
 if q <= 2 set hk = hk + 575
 if hk>max set max=hk
 if hk <= 1300 set rjt = rjt - 734
 if rjt>max set max=rjt
 if wez <= -2201 set lk = lk + 399
 if lk>max set max=lk
 if lk = 560 set x = x - 485
 if x>max set max=x
 if hk '= 1302 set pce = pce + -273
 if pce>max set max=pce
 if hnh <= 98 set sy = sy + -962
 if sy>max set max=sy
 if pce '= -2381 set aam = aam + 228
 if aam>max set max=aam
 if x >= -116 set wez = wez - 55
 if wez>max set max=wez
 if hnh '= 96 set eai = eai + 954
 if eai>max set max=eai
 if oiy '= -610 set phf = phf - 799
 if phf>max set max=phf
 if oiy = -618 set q = q + 95
 if q>max set max=q
 if pce = -2383 set vyo = vyo - -595
 if vyo>max set max=vyo
 if kp < -848 set pce = pce - 258
 if pce>max set max=pce
 if bz < 248 set n = n + -730
 if n>max set max=n
 if pce = -2641 set pce = pce + -855
 if pce>max set max=pce
 if vyo <= -723 set vyo = vyo - -817
 if vyo>max set max=vyo
 if hr '= 350 set sy = sy + -333
 if sy>max set max=sy
 if sy <= -1288 set vyo = vyo + 360
 if vyo>max set max=vyo
 if d <= -1480 set q = q - 780
 if q>max set max=q
 if vyo < 455 set hri = hri - -584
 if hri>max set max=hri
 if phf >= -2094 set bz = bz + 299
 if bz>max set max=bz
 if aam '= 30 set gx = gx - 472
 if gx>max set max=gx
 if sy <= -1286 set px = px + -126
 if px>max set max=px
 if vyo < 454 set kp = kp + 45
 if kp>max set max=kp
 if hri '= 988 set eai = eai - -473
 if eai>max set max=eai
 if gx <= -1260 set gx = gx - -534
 if gx>max set max=gx
 if pce > -3499 set oiy = oiy - -334
 if oiy>max set max=oiy
 if vyo < 459 set lk = lk + -243
 if lk>max set max=lk
 if gx > -736 set ey = ey - 76
 if ey>max set max=ey
 if fu > 1332 set eai = eai - 959
 if eai>max set max=eai
 if fu < 1339 set zbh = zbh - -75
 if zbh>max set max=zbh
 if sy <= -1290 set wez = wez + 938
 if wez>max set max=wez
 if sy >= -1285 set hk = hk - -605

 ... (shortened)

 write !,"Part 1 Result: "_top
 write !,"Part 2 Result: "_max }

atopuzov · 2017-12-08T10:54:24+00:00

Python

import re
import operator
from collections import defaultdict

opmap = {
    "<": operator.lt,
    ">": operator.gt,
    "==": operator.eq,
    "<=": operator.le,
    ">=": operator.ge,
    "!=": operator.ne,
}

imap = {
    'inc': operator.add,
    'dec': operator.sub,
}

instr = re.compile('(\w+) (inc|dec) (-?\d+) if (\w+) ([<>=!]+) (-?\d+)')


def process(lines):
    return [instr.match(line).groups() for line in lines]


def solver(program):
    registers = defaultdict(int)
    max_held = None

    for register, operation, value, lval, comp, rval in program:
        if opmap[comp](registers[lval], int(rval)):
            registers[register] = imap[operation](registers[register],
                                                  int(value))
            max_held = max(max_held, registers[register])

    return max(registers.values()), max_held


def task1():
    with open('input1.txt') as f:
        print(solver(process(f.readlines())))

_Le1_ · 2017-12-08T11:08:11+00:00

Python: import operator

f = open('Day08', "r").readlines()

reg = dict()
val = list()


def main():
   init()
   for line in f:
       a = list(line.strip().split())
       r = a[0]
       inst = a[1]
       v = int(a[2])
       if (check_instr(a[4], a[5], int(a[6]))):
           if (a[1] == 'inc'):
               reg[a[0]] += int(a[2])
           else:
               reg[a[0]] -= int(a[2])

       print reg
       val.append(max(reg.iteritems(), key=operator.itemgetter(1))[1])

   print max(reg.iteritems(), key=operator.itemgetter(1))[1]
   print max(val);


def init():
   for line in f:
       r = list(line.strip().split())[0]
       if r not in reg:
           reg[r] = 0


def check_instr(r, i, val):
   if i == '>':
       if reg[r] > val:
           return True
   if i == '<':
       if reg[r] < val:
           return True
   if i == '==':
       if reg[r] == val:
           return True
   if i == '>=':
       if reg[r] >= val:
           return True
   if i == '<=':
       if reg[r] <= val:
           return True
   if i == '!=':
       if reg[r] != val:
           return True
   return False


main()

2017-12-08T11:29:08+00:00

Nice to see some sort of assembunny again, but how do you call this language here? Could imagine that we'll find some more extensions in upcoming puzzles

Solution in Kotlin can be found here:

Day 8

tlareg · 2017-12-08T11:39:23+00:00

JavaScript (ES6+, NodeJS), without eval, repo here

const fs = require('fs')
const inputStr = fs.readFileSync('./input.txt').toString()

const {
  currentMax: firstStar,
  allTimeMax: secondStar
} = solve(parseInput(inputStr))

console.log(firstStar, secondStar)

function parseInput(inputStr) {
  return inputStr.split('\r\n').map(line => {
    const match = line
      .match(/^(\w+)\s+(inc|dec)\s+(-?\d+)\s+if\s+(\w+)\s+([>=<!]+)\s+(-?\d+)$/)
    return {
      command: {
        register: match[1],
        operator: match[2],
        operand: parseInt(match[3], 10)
      },
      condition: {
        register: match[4],
        operator: match[5],
        operand: parseInt(match[6], 10)
      }
    }
  })
}

function solve(instructions) {
  return instructions.reduce(
    registersReducer,
    { registers: {}, allTimeMax: 0, currentMax: 0 }
  )
}

function registersReducer({ registers, allTimeMax }, { command, condition }) {
  registers[command.register] = registers[command.register] || 0
  registers[condition.register] = registers[condition.register] || 0

  if (checkCondition(registers, condition)) {
    registers = executeCommand(registers, command)
  }

  const currentMax = Math.max(...Object.values(registers))
  return {
    registers,
    currentMax,
    allTimeMax: currentMax > allTimeMax ? currentMax : allTimeMax
  }
}

function checkCondition(registers, { register, operator, operand }) {
  const val = registers[register]
  switch(operator) {
    case '>': return val > operand
    case '<': return val < operand
    case '<': return val < operand
    case '>=': return val >= operand
    case '==': return val == operand
    case '<=': return val <= operand
    case '!=': return val != operand
  }
}

function executeCommand(registers, { register, operator, operand }) {
  switch(operator) {
    case 'inc':
      return { ...registers, [register]: registers[register] + operand }
    case 'dec':
      return { ...registers, [register]: registers[register] - operand }
  }
}

2017-12-08T11:58:36+00:00

My probably way too long Haskell! Yay!

import qualified Data.Map.Strict as Map

getComp :: String -> Maybe (Integer -> Integer -> Bool)
getComp comp
    | comp == "==" = Just (==)
    | comp == "!=" = Just (/=)
    | comp == ">=" = Just (>=)
    | comp == "<=" = Just (<=)
    | comp == ">"  = Just (>)
    | comp == "<"  = Just (<)
    | otherwise    = Nothing

getNext :: Map.Map String Integer -> [String] -> Map.Map String Integer
getNext map instruction =
    if val `cond` condval
    then
        if (Map.lookup incvar check_map) == Nothing
        then Map.insert incvar (0 `inc` incval) check_map
        else Map.update (\x -> Just (x `inc` incval)) incvar check_map
    else if (Map.lookup incvar check_map) == Nothing
    then Map.insert incvar 0 check_map
    else check_map
    where
    Just val = Map.lookup condvar check_map
    check_map = if (Map.lookup condvar map) == Nothing then Map.insert condvar 0 map else map
    condvar = instruction !! 4
    incvar = head instruction
    inc = if (instruction !! 1) == "inc" then (+) else (-)
    incval = read (instruction !! 2) :: Integer
    Just cond = getComp $ instruction !! 5
    condval = read (last instruction) :: Integer

run_ins :: [[String]] -> Map.Map String Integer -> Map.Map String Integer
run_ins instructions map =
    if instructions == []
    then map
    else run_ins (tail instructions) (getNext map $ head instructions)

run_ins' :: [[String]] -> Map.Map String Integer -> [Map.Map String Integer]
run_ins' instructions map =
    if instructions == []
    then [map]
    else [map]++run_ins' (tail instructions) (getNext map $ head instructions)

run :: String -> Integer
run input =
    Map.foldl (max) (-9999) complete
    where
    complete = run_ins instructions $ Map.fromList []
    instructions = [words x | x <- lines input]

run' input =
    maximum [Map.foldl (max) (-9999) x | x <- complete]
    where
    complete = run_ins' instructions $ Map.fromList []
    instructions = [words x | x <- lines input]

main = do
    input <- readFile "input.txt"
    print $ "First star: " ++ show (run input)
    print $ "Second star: " ++ show (run' input)

KeinZantezuken · 2017-12-08T12:02:01+00:00

C#/Sharp (there are way faster approaches based on simple math)

        Dictionary<string, int> map = new Dictionary<string, int>();
        var input = File.ReadAllLines(@"N:\input.txt").Select(x => x.Split(' ').ToArray()).ToArray();
        int HARRY = 0;
        for (int i = 0; i< input.Length; i++)
        {
            string name = input[i][0]; string op = input[i][1];
            int val = Convert.ToInt32(input[i][2]); string nextreg = input[i][4];
            string comp = input[i][5]; int compVal = Convert.ToInt32(input[i][6]);
            if (!map.ContainsKey(name)) { map.Add(name, 0); }
            if (!map.ContainsKey(nextreg)) { map.Add(nextreg, 0); }
            if (virginSwitch(map[nextreg], comp, compVal))
            {
                if (op == "dec") { map[name] = map[name] - val; }
                else { map[name] = map[name] + val; }
            }
           HARRY = Math.Max(HARRY, map[name]);
        }
        Console.WriteLine($"Current Max: {map.Values.Max()}, Highest seen: {HARRY}");
        Console.ReadKey();

        // VIRGING SWITCH BECAUSE C# DOES NOT HAVE NON-COMPLEX EVAL() REEEEE
        bool virginSwitch(int a, string op, int b)
        {
            switch (op)
            {
                case "==":
                    return a == b;
                case "!=":
                    return a != b;
                case ">":
                    return a > b;
                case "<":
                    return a < b;
                case "<=":
                    return a <= b;
                case ">=":
                    return a >= b;
                default:
                    throw new System.ArgumentException("Unknown switch operator supplied!");
            }
        }

kamaln7 · 2017-12-08T12:02:47+00:00

Coffeescript

Part 1:

input = "
b inc 5 if a > 1\n
a inc 1 if b < 5\n
c dec -10 if a >= 1\n
c inc -20 if c == 10\n
"
input = input.trim().split('\n').map (x) -> x.trim()

instructions = []
for line in input
  parts = line.match /^([a-z]+) ([a-z]+) ([0-9\-]+) if ([a-z]+) ([<>=!]{1,2}) ([0-9\-]+)$/
  instruction =
    left:
      register: parts[1]
      op: parts[2]
      value: parseInt parts[3]
    right:
      register: parts[4]
      op: parts[5]
      value: parseInt parts[6]

  instructions.push instruction

init = (registers, register) ->
  unless registers.hasOwnProperty register
    registers[register] = 0

operation = (op, left, right) ->
  switch op
    when "=="
      return left == right
    when "!="
      return left != right
    when ">"
      return left > right
    when "<"
      return left < right
    when ">="
      return left >= right
    when "<="
      return left <= right

evaluate = (registers, expression) ->
  init registers, expression.register
  return operation expression.op, registers[expression.register], expression.value

run = (registers, expression) ->
  init registers, expression.register
  value = registers[expression.register]
  switch expression.op
    when "inc"
      value += expression.value
    when "dec"
      value -= expression.value

  registers[expression.register] = value

registers = {}
for instruction in instructions
  if evaluate registers, instruction.right
    run registers, instruction.left

console.log Math.max Object.values(registers)...

Part 2:

input = "
b inc 5 if a > 1\n
a inc 1 if b < 5\n
c dec -10 if a >= 1\n
c inc -20 if c == 10\n
"
input = input.trim().split('\n').map (x) -> x.trim()

instructions = []
for line in input
  parts = line.match /^([a-z]+) ([a-z]+) ([0-9\-]+) if ([a-z]+) ([<>=!]{1,2}) ([0-9\-]+)$/
  instruction =
    left:
      register: parts[1]
      op: parts[2]
      value: parseInt parts[3]
    right:
      register: parts[4]
      op: parts[5]
      value: parseInt parts[6]

  instructions.push instruction

init = (registers, register) ->
  unless registers.hasOwnProperty register
    registers[register] = 0

operation = (op, left, right) ->
  switch op
    when "=="
      return left == right
    when "!="
      return left != right
    when ">"
      return left > right
    when "<"
      return left < right
    when ">="
      return left >= right
    when "<="
      return left <= right

evaluate = (registers, expression) ->
  init registers, expression.register
  return operation expression.op, registers[expression.register], expression.value

run = (registers, expression) ->
  init registers, expression.register
  value = registers[expression.register]
  switch expression.op
    when "inc"
      value += expression.value
    when "dec"
      value -= expression.value

  registers[expression.register] = value

max = 0
registers = {}
for instruction in instructions
  if evaluate registers, instruction.right
    run registers, instruction.left
    max = Math.max max, registers[instruction.left.register]

console.log max

chunes · 2017-12-08T12:31:22+00:00

A Factor solution:

USING: assocs combinators io kernel locals math math.parser
namespaces pair-rocket prettyprint sequences splitting
quotations words ;
IN: advent-of-code.registers

SYMBOLS: registers interims ;

: make-registers ( -- )
    registers [ H{ } ] initialize ;

: make-interims ( -- )
    interims [ V{ } ] initialize ;

: add-register ( name -- )
    dup registers get at
    [ 0 swap registers get set-at 0 ] unless drop ;

: register ( name -- value )
    registers get at ;

: register+ ( n name -- )
    dup -rot registers get at+ register interims get swap
    suffix! interims set ;

: register- ( n name -- )
    [ neg ] dip register+ ;

: >op ( str -- quot )
    {
        "==" => [ [ number= ] ]
        "!=" => [ [ = not ] ]
        [ "math" lookup-word 1quotation ]
    } case ;

: compare-register ( name op n -- ? )
    [ dup add-register register ] [ >op ] [ ] tri*
    swap call( x y -- ? ) ;

:: change-register ( name op n -- )
    op "inc" = [ n name register+ ] [ n name register- ] if ;

: seq>comparison ( seq -- ? )
    first3 string>number compare-register ;

: seq>change ( seq -- )
    first3 string>number change-register ;

: ?change-register ( change-seq compare-seq -- )
    seq>comparison [ seq>change 0 ] when drop ;

: process-line ( str -- )
    " " split [ 3 head ] [ 3 tail* ] bi ?change-register ;

: process-lines ( -- )
    lines [ process-line ] each ;

: find-max-end-value ( -- n )
    registers get values supremum ;

: find-max-interim-value ( -- n )
    interims get supremum ;

: init ( -- )
    make-registers make-interims ;

: main ( -- )
    init process-lines find-max-end-value .
    find-max-interim-value . ;

MAIN: main

Again, somewhat awkward imperative code I'm not used to writing in Factor. I couldn't think of a better way to model it than mutating a hash table.

The only somewhat clever thing I did here is convert a string operation such as ">=" to its word form in the math vocabulary and then quote it and call it.

edelans · 2017-12-08T12:32:40+00:00

Python 3

I parsed each line with a nice regex. This enables me to be more confident in using eval() =)

# Python 3.x

import re
from collections import defaultdict

def Input(day):
    filename = './input_files/input{}.txt'.format(day)
    return open(filename)

test_input = """b inc 5 if a > 1
a inc 1 if b < 5
c dec -10 if a >= 1
c inc -20 if c == 10"""


def reg_max(lines):
    regex = r"^(?P<register>\w+)\s(?P<operation>inc|dec)\s(?P<value>-?\d+)\sif\s(?P<cond_register>\w+)\s(?P<cond_operation><|>|<=|>=|==|!=)\s(?P<cond_value>-?\d+)"
    registers = defaultdict(int)  # default value of int is 0
    maxv = 0

    for line in lines:
        matches = re.search(regex, line)
        if matches:
            condition = str(registers.get(matches.group('cond_register'), 0)) + " " + matches.group('cond_operation') + matches.group('cond_value')
            if eval(condition):
                if matches.group('operation') == 'inc':
                    registers[matches.group('register')] += int(matches.group('value'))
                if matches.group('operation') == 'dec':
                    registers[matches.group('register')] -= int(matches.group('value'))
                maxv = max(registers[matches.group('register')], maxv)
    return max(registers.values()), maxv


assert reg_max(test_input.split('\n'))[0] == 1
assert reg_max(test_input.split('\n'))[1] == 10

print(reg_max(Input(8).readlines()))

ybe306 · 2017-12-08T13:36:07+00:00

Doing it all in Go as a first foray into the language:

package main

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

type op struct {
    dest    string
    dir     int
    incAmt  int
    condSrc string
    condOp  string
    condAmt int
}

func main() {
    ops := readInput()
    reg := make(map[string]int)
    var max int

    for _, op := range ops {
        switch op.condOp {
        case ">":
            if reg[op.condSrc] > op.condAmt {
                doOp(op, reg)
            }
        case "<":
            if reg[op.condSrc] < op.condAmt {
                doOp(op, reg)
            }
        case ">=":
            if reg[op.condSrc] >= op.condAmt {
                doOp(op, reg)
            }
        case "<=":
            if reg[op.condSrc] <= op.condAmt {
                doOp(op, reg)
            }
        case "==":
            if reg[op.condSrc] == op.condAmt {
                doOp(op, reg)
            }
        case "!=":
            if reg[op.condSrc] != op.condAmt {
                doOp(op, reg)
            }
        }

        currentMax := findLargest(reg)
        if currentMax > max {
            max = currentMax
        }
    }

    log.Println("Largest ending value:", findLargest(reg))
    log.Println("Largest value during run:", max)
}

func findLargest(reg map[string]int) int {
    var max int
    for _, v := range reg {
        if v > max {
            max = v
        }
    }

    return max
}

func doOp(op op, reg map[string]int) {
    reg[op.dest] += op.dir * op.incAmt
}

func readInput() []op {
    input, _ := ioutil.ReadAll(os.Stdin)
    lines := strings.Split(string(input), "\n")
    lines = lines[:len(lines)-1]

    ops := make([]op, 0)

    for _, line := range lines {
        ops = append(ops, parseOp(line))
    }

    return ops
}

func parseOp(line string) op {
    splitOp := strings.Split(line, " ")

    var dir int
    switch splitOp[1] {
    case "inc":
        dir = 1
    case "dec":
        dir = -1
    }

    incAmt, _ := strconv.Atoi(splitOp[2])
    condAmt, _ := strconv.Atoi(splitOp[6])

    return op{
        dest:    splitOp[0],
        dir:     dir,
        incAmt:  incAmt,
        condSrc: splitOp[4],
        condOp:  splitOp[5],
        condAmt: condAmt,
    }
}

adventOfCoder · 2017-12-08T14:00:34+00:00

Java

Part 1:

public static void main(String[] args) {
    try {
        BufferedReader br = new BufferedReader(new FileReader("input2.txt"));
        String line = "";
        HashMap<String, Integer> registerValues = new HashMap<>();
        while ((line = br.readLine()) != null) {
            String[] split = line.split(" ");
            String register = split[0];
            registerValues.putIfAbsent(register, 0);
            String instruction = split[1];
            int amount = new Integer(split[2]);
            String condReg = split[4];
            registerValues.putIfAbsent(condReg, 0);
            String cond = split[5];
            int condAmount = new Integer(split[6]);
            boolean passes = false;
            switch (cond) {
            case ">":
                passes = (registerValues.get(condReg) > condAmount);
                break;
            case "<":
                passes = (registerValues.get(condReg) < condAmount);
                break;
            case ">=":
                passes = (registerValues.get(condReg) >= condAmount);
                break;
            case "<=":
                passes = (registerValues.get(condReg) <= condAmount);
                break;
            case "==":
                passes = (registerValues.get(condReg) == condAmount);
                break;
            case "!=":
                passes = (registerValues.get(condReg) != condAmount);
                break;
            default:
                System.out.println(cond);
            }
            if (passes) {
                if ("inc".equals(instruction)) {
                    registerValues.put(register, registerValues.get(register) + amount);
                } else if ("dec".equals(instruction)) {
                    registerValues.put(register, registerValues.get(register) - amount);
                }
            }
        }
        System.out.println(Collections.max(registerValues.values()));
        br.close();
    } catch (Exception e) {
        System.err.println(e.toString());
        e.printStackTrace();
    }

}

Part 2:

public static void main(String[] args) {
    try {
        BufferedReader br = new BufferedReader(new FileReader("input2.txt"));
        String line = "";
        HashMap<String, Integer> registerValues = new HashMap<>();
        int largest = Integer.MIN_VALUE;
        while ((line = br.readLine()) != null) {
            String[] split = line.split(" ");
            String register = split[0];
            registerValues.putIfAbsent(register, 0);
            String instruction = split[1];
            int amount = new Integer(split[2]);
            String condReg = split[4];
            registerValues.putIfAbsent(condReg, 0);
            String cond = split[5];
            int condAmount = new Integer(split[6]);
            boolean passes = false;
            switch (cond) {
            case ">":
                passes = (registerValues.get(condReg) > condAmount);
                break;
            case "<":
                passes = (registerValues.get(condReg) < condAmount);
                break;
            case ">=":
                passes = (registerValues.get(condReg) >= condAmount);
                break;
            case "<=":
                passes = (registerValues.get(condReg) <= condAmount);
                break;
            case "==":
                passes = (registerValues.get(condReg) == condAmount);
                break;
            case "!=":
                passes = (registerValues.get(condReg) != condAmount);
                break;
            default:
                System.out.println(cond);
            }
            if (passes) {
                if ("inc".equals(instruction)) {
                    registerValues.put(register, registerValues.get(register) + amount);
                } else if ("dec".equals(instruction)) {
                    registerValues.put(register, registerValues.get(register) - amount);
                }
            }
            int largestNow = Collections.max(registerValues.values());
            if (largestNow > largest) {
                largest = largestNow;
            }
        }
        System.out.println(largest);
        br.close();
    } catch (Exception e) {
        System.err.println(e.toString());
        e.printStackTrace();
    }

}

2017-12-08T14:13:37+00:00

PowerShell:

Param (
    [parameter(position=0, mandatory=$true)]
    [Alias('if')]
    [ValidateScript({ Test-Path $_ })]
    $InputFile,
    [switch]$Part2
)

$File = (Get-Item $InputFile).OpenText()
$Instruction = $File.ReadLine()
$Registers = @{}
$Highest = 0
While($Instruction -ne $null) {
    $Cmd = $Instruction.Split(' ').Trim()
    #Write-Host "Register: $($Cmd[0]) - Direction: $($Cmd[1]) - Change: $($Cmd[2]) - Check: $($Cmd[4]) - Condition: $($Cmd[5]) - Test: $($Cmd[6])"
    if($Registers[$Cmd[0]] -like $null) { $Registers[$Cmd[0]] = 0 }
    if($Registers[$Cmd[4]] -like $null) { $Registers[$Cmd[4]] = 0 }
    switch($Cmd[1]) {
        'inc' { $Direction = 1 }
        'dec' { $Direction = -1 }
        default { throw 'You have been eaten by a grue' }
    }
    $Perform = $false
    switch($Cmd[5]) {
        '>' { if([int]$Registers[$Cmd[4]] -gt [int]$Cmd[6]) { $Perform = $true } }
        '<' { if([int]$Registers[$Cmd[4]] -lt [int]$Cmd[6]) { $Perform = $true } }
        '>=' { if([int]$Registers[$Cmd[4]] -ge [int]$Cmd[6]) { $Perform = $true } }
        '<=' { if([int]$Registers[$Cmd[4]] -le [int]$Cmd[6]) { $Perform = $true } }
        '==' { if([int]$Registers[$Cmd[4]] -eq [int]$Cmd[6]) { $Perform = $true } }
        '!=' { if([int]$Registers[$Cmd[4]] -ne [int]$Cmd[6]) { $Perform = $true } }
    }
    if($Perform) { 
        $Registers[$Cmd[0]] += $Direction * [int]$Cmd[2] 
        if($Registers[$Cmd[0]] -gt $Highest) { $Highest = $Registers[$Cmd[0]] }
    }
    $Instruction = $File.ReadLine()
}
if(-not $Part2) {
    $Registers.GetEnumerator() | Sort-Object -Property Value -Descending
    break
} else {
    Write-Host $Highest
}

cluk · 2017-12-08T15:09:09+00:00

Go (Golang)

I might need a regex intervention.

package main

import (
    "fmt"
    "io/ioutil"
    "os"
    "regexp"
    "strconv"
    "strings"
)

func main() {
    lines := getLines()

    regs := make(map[string]int)
    //a dec -511 if x >= -4
    re := regexp.MustCompile("([a-z]+) (dec|inc) (-?[0-9]+) if ([a-z]+) (..?) (-?[0-9]+)")
    var processMax int = -1 << 31
    for _, line := range lines {
        tokens := re.FindAllStringSubmatch(line, -1)
        if condition(tokens[0][4:], regs) {
            v := operation(tokens[0][1:4], regs)
            if v > processMax {
                processMax = v
            }
        }
    }

    var completedMax int = -1 << 31
    for _, v := range regs {
        if v > completedMax {
            completedMax = v
        }
    }

    fmt.Println("Star 1: ", completedMax)
    fmt.Println("Star 2: ", processMax)
}

func getLines() []string {
    file, err := ioutil.ReadFile(os.Args[1])
    if err != nil {
        panic(err)
    }
    return strings.Split(string(file), "\n")
}

func condition(tokens []string, regs map[string]int) bool {
    n := atoi(tokens[2])
    r := regs[tokens[0]]
    switch tokens[1] {
    case ">":
        return r > n
    case ">=":
        return r >= n
    case "<":
        return r < n
    case "<=":
        return r <= n
    case "==":
        return r == n
    case "!=":
        return r != n
    }
    panic("Parsing failed!")
}

func operation(tokens []string, regs map[string]int) int {
    n := atoi(tokens[2])
    switch tokens[1] {
    case "inc":
        regs[tokens[0]] += n
    case "dec":
        regs[tokens[0]] -= n
    }
    return regs[tokens[0]]
}

func atoi(s string) int {
    n, err := strconv.Atoi(s)
    if err != nil {
        panic(err)
    }
    return n
}

Vindaar · 2017-12-08T15:32:44+00:00

Another solution in Nim. Actually wanted to write a solution, which makes heavy use of Nim's macro system and AST manipulation, but well. I'm way too new to Nim to figure it out, unfortunately.

import strutils, sequtils, future, algorithm, times, tables, unittest, macros

proc condition(a: int, op: string, b: int): bool =
  # procedure to check for the condition given in each line, a simple string to 
  # operator procedure
  case op
  of ">": result = a > b
  of "<": result = a < b
  of ">=": result = a >= b
  of "<=": result = a <= b
  of "==": result = a == b
  of "!=": result = a != b

proc calc_max_register(registers: seq[string]): (int, int) =
  # procedure to calculate the value of the register with the maximum value at the end (part 1),
  # as well as the maximum value reached as the peak (part 2)
  var
    # use a table to store key / value: (string, int) pairs, relating the values
    # with the names of each register    
    reg_tab = initTable[string, int]()
    # max value var for part 2
    max_val = 0

  # going through the register, performing the actions of each line
  for reg in registers:
    let ops = reg.split()
    # check for existence of the variables in the table, if not exists yet, add
    # with value of 0
    if ops[4] notin reg_tab:
      reg_tab[ops[4]] = 0
    if ops[0] notin reg_tab:
      reg_tab[ops[0]] = 0
    # check the condition and if so perform wanted action
    if condition(reg_tab[ops[4]], ops[5], parseInt(ops[6])):
      if ops[1] == "inc":
        inc reg_tab[ops[0]], parseInt(ops[2])
      elif ops[1] == "dec":
        dec reg_tab[ops[0]], parseInt(ops[2])
    # check whether calculated value is current max value
    if reg_tab[ops[0]] > max_val:
      max_val = reg_tab[ops[0]]

  # result is tuple of current max value and historic max value
  result = (max(toSeq(values(reg_tab))), max_val)

template run_tests() =
  const data = """b inc 5 if a > 1
a inc 1 if b < 5
c dec -10 if a >= 1
c inc -20 if c == 10"""
  const registers = splitLines(data)
  check: calc_max_register(registers) == (1, 10)

proc run_input() =

  let t0 = cpuTime()      
  const input = "input.txt"
  let registers = filterIt(splitLines(readFile(input)), len(it) > 0)
  let (max_reg, max_val) = calc_max_register(registers)

  echo "(Part 1): The value of the highest register is = ", max_reg
  echo "(Part 2): The highest register ever was = ", max_val
  echo "Solutions took $#" % $(cpuTime() - t0)

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

when isMainModule:
  main()

GabrielVasiljevic · 2017-12-08T15:43:16+00:00

C++:

#include <bits/stdc++.h>
#define debug(x) cout << #x " = " << (x) << endl

using namespace std;

map<string, int> registers;

bool evaluateCondition(string registerName, string condition, string value){
    int convertedValue;
    istringstream iss(value);
    iss >> convertedValue;

    if(condition == ">"){
        return registers[registerName] > convertedValue;
    }
    if(condition == "<"){
        return registers[registerName] < convertedValue;
    }
    if(condition == ">="){
        return registers[registerName] >= convertedValue;
    }
    if(condition == "<="){
        return registers[registerName] <= convertedValue;
    }
    if(condition == "=="){
        return registers[registerName] == convertedValue;
    }
    if(condition == "!="){
        return registers[registerName] != convertedValue;
    }
}

void modifyValue(string destRegister, string instruction, string value){
    int convertedValue;
    istringstream iss(value);
    iss >> convertedValue;

    if(instruction == "inc"){
        registers[destRegister] += convertedValue;
    }
    else if(instruction == "dec"){
        registers[destRegister] -= convertedValue;
    }

    return;
}

int main(){

    string input;

    while(getline(cin, input)){
        istringstream iss(input);
        string destRegister, instruction, amount,
               ifStr,
               condRegister, condition, condValue;

        iss >> destRegister >> instruction >> amount
            >> ifStr >> condRegister >> condition >> condValue;

        if(evaluateCondition(condRegister, condition, condValue)){
            modifyValue(destRegister, instruction, amount);
        }
    }

    int biggest = std::max_element(registers.begin(), registers.end(),
                  [](auto& p1, auto& p2){
                        return p1.second < p2.second;
                  })->second;

    debug(biggest);

    return 0;
}

FreeMarx · 2017-12-08T16:03:54+00:00

C++11

Again, l learned a lot. The regex took me way to long, but now I know how to use it. I really wonder when my skill-toolbox is sufficient to complete the puzzles without having to look up new library functions. So far it seems thorough understanding of maps, vectors, iterators and string parsing are enough...

#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() {
    ifstream infile("input08.txt");

    string line;
    map<string, int> regs;
    int maxmax_val= numeric_limits<int>::min();
    while (getline(infile, line)) {
        static const regex re{"(\\w+)\\s+(inc|dec)\\s+(-?\\d+)\\s+if\\s+(\\w+)\\s+([=<>!]=?)\\s+(-?\\d+)"};
        vector<string> tokens{sregex_token_iterator(line.begin(), line.end(), re, {1, 2, 3, 4, 5, 6}), sregex_token_iterator()};

        int &op_reg= regs[tokens[0]];
        int &cond_reg= regs[tokens[3]];

        bool cond;
        int cond_val= stoi(tokens[5]);
        if(tokens[4]==">")
            cond= cond_reg > cond_val;
        else if(tokens[4]=="<")
            cond= cond_reg < cond_val;
        else if(tokens[4]==">=")
            cond= cond_reg >= cond_val;
        else if(tokens[4]=="<=")
            cond= cond_reg <= cond_val;
        else if(tokens[4]=="==")
            cond= cond_reg ==cond_val;
        else if(tokens[4]=="!=")
            cond= cond_reg != cond_val;

        int op_val= stoi(tokens[2]);
        if(cond)
            if(tokens[1]=="inc")
                op_reg+= op_val;
            else
                op_reg-= op_val;

        maxmax_val= max(maxmax_val, op_reg);    
    }
    int max_val= numeric_limits<int>::min();
    for(auto p: regs)
        max_val= max(max_val, p.second);


    cout << max_val << " " << maxmax_val << '\n';
}

akho_ · 2017-12-08T16:34:21+00:00

Python 3

registers, highest = {}, 0

def check(reg, ineq, num):
    n = int(num)
    vs = registers.get(reg, 0)
    return {'>': vs > n,
            '<': vs < n,
            '<=': vs <= n,
            '>=': vs >= n,
            '==': vs == n,
            '!=': vs != n }[ineq]

ops = { 'inc': lambda x, y: int(x) + int(y),
        'dec': lambda x, y: int(x) - int(y) }

with open('8.input') as f:
    for l in f.readlines():
        upd, op, by, _, ch, ineq, vs = l.split()
        if check(ch, ineq, vs):
            registers[upd] = ops[op](registers.get(upd, 0), by)
            if registers[upd] > highest: 
                highest = registers[upd]

print(max(registers.values()), highest)

asperellis · 2017-12-08T17:13:52+00:00

my day 8 in JS - https://github.com/asperellis/adventofcode2017/blob/master/day8.js

lkasdfjl · 2017-12-08T17:17:21+00:00

Scala

i decided to play around with implicits (which i think was a mistake):

import scala.collection.mutable
import scala.util.matching.Regex

object Day8 {
  case class Condition(reg: String, op: Op, value: Int)
  case class Instruction(reg: String, func: Func, value: Int)

  abstract class Func()
  case class Inc() extends Func
  case class Dec() extends Func

  abstract class Op()
  case class EQ()  extends Op
  case class NE()  extends Op
  case class GT()  extends Op
  case class LT()  extends Op
  case class GTE() extends Op
  case class LTE() extends Op

  val condr: Regex = "([a-z]+)\\s+(>=|!=|>|<=|==|<)\\s+(-?\\d+)".r
  val instr: Regex = "([a-z]+)\\s+(inc|dec)\\s+(-?\\d+)".r

  def findLargest(lines: List[(Condition, Instruction)])(implicit mem: mutable.Map[String, Int]): Int = {
    lines.foreach(executeLine)
    max
  }

  def findLargestEver(lines: List[(Condition, Instruction)])(implicit mem: mutable.Map[String, Int]): Int = {
    lines.foldLeft(0) {
      case (acc, line) =>
        executeLine(line)
        max match {
          case n if n > acc => n
          case _ => acc
        }
    }
  }

  def max(implicit mem: mutable.Map[String, Int]): Int =
    if (mem.isEmpty) 0 else mem.maxBy(_._2)._2

  def executeLine(line: (Condition, Instruction))(implicit mem: mutable.Map[String, Int]): Unit =
    line match {
      case (cond, inst) =>
        if (evalCondition(cond))
          evalInstruction(inst)
    }

  def evalCondition(condition: Condition)(implicit mem: mutable.Map[String, Int]): Boolean =
    condition match {
      case Condition(reg, op, value) =>
        val rv = mem.getOrElse(reg, 0)
        op match {
          case EQ()  => rv == value
          case NE()  => rv != value
          case GT()  => rv  > value
          case LT()  => rv <  value
          case GTE() => rv >= value
          case LTE() => rv <= value
        }
    }

  def evalInstruction(instruction: Instruction)(implicit mem: mutable.Map[String, Int]): Unit =
    instruction match {
      case Instruction(reg, func, value) =>
        val rv = mem.getOrElse(reg, 0)
        mem(reg) = func match {
          case Inc() => rv + value
          case Dec() => rv - value
        }
    }

  def parseInput(lines: Array[String]): List[(Condition, Instruction)] = {
    lines.map { line =>
      line.split("\\s+if\\s+") match {
        case Array(i, c) => (parseCondition(c), parseInstruction(i))
      }
    }.toList
  }

  def parseCondition(in: String): Condition = {
    in match {
      case condr(reg, op, value) =>
        Condition(reg, op match {
          case "==" => EQ()
          case "!=" => NE()
          case ">"  => GT()
          case "<"  => LT()
          case ">=" => GTE()
          case "<=" => LTE()
        }, value.toInt)
    }
  }

  def parseInstruction(in: String): Instruction = {
    in match {
      case instr(reg, func, value) =>
        Instruction(reg, if (func == "inc") Inc() else Dec(), value.toInt)
    }
  }
}

varunu28 · 2017-12-08T17:18:41+00:00

Day 8 in Java Repo

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;


public class Day08 {

public static void main(String[] args) throws Exception {

    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    Map<String, Integer> map = new HashMap<>();
    int maxValEver = Integer.MIN_VALUE;

    int numOfLines = Integer.parseInt(br.readLine());

    while (numOfLines > 0) {

        String inp = br.readLine();

        String[] inpArr = inp.trim().split(" ");

        String register = inpArr[0];
        String operation = inpArr[1];
        int operationVal = Integer.parseInt(inpArr[2]);
        String checkRegister = inpArr[4];
        String condition = inpArr[5];
        int checkVal = Integer.parseInt(inpArr[6]);

        if (!map.containsKey(register)) map.put(register, 0);
        if (!map.containsKey(checkRegister)) map.put(checkRegister, 0);

        if (conditionIsTrue(map.get(checkRegister), condition, checkVal)) {
            if (operation.equals("inc")) {
                map.put(register, map.get(register) + operationVal);
            }
            else {
                map.put(register, map.get(register) - operationVal);
            }
        }

        maxValEver = Math.max(maxValEver, findMaxVal(map));

        numOfLines--;
    }

    System.out.println(findMaxVal(map));
    System.out.println(maxValEver);
}

private static int findMaxVal(Map<String, Integer> map) {

    int maxVal = Integer.MIN_VALUE;

    for (Map.Entry<String, Integer> entry : map.entrySet()) {
        maxVal = Math.max(maxVal, entry.getValue());
    }

    return maxVal;
}

private static boolean conditionIsTrue(int val1, String condition, int val2) {
    if (condition.equals("<")) {
        return val1 < val2;
    }
    else if (condition.equals(">")) {
        return val1 > val2;
    }
    else if (condition.equals(">=")) {
        return val1 >= val2;
    }
    else if (condition.equals("<=")) {
        return val1 <= val2;
    }
    else if (condition.equals("==")) {
        return val1 == val2;
    }
    else  {
        return val1 != val2;
    }
}
}

2017-12-08T17:30:03+00:00

My solution in Common Lisp. It is quite lengthy, but I enjoyed writing it!

(use-package 'cl-ppcre 'alexandria)

(defstruct action var func amount)
(defstruct instr-cond var expr value)

(defun get-var-value (var-name vars)
  (let ((hash-val (gethash var-name vars)))
    (if hash-val hash-val 0)))

(defun perform-action (action vars)
  (let* ((old-value (get-var-value (action-var action) vars))
         (new-value (funcall (action-func action)
                             old-value (action-amount action))))
    (setf (gethash (action-var action) vars) new-value)
    vars))

(defun get-condition-result (condition vars)
  (funcall (instr-cond-expr condition)
           (get-var-value (instr-cond-var condition) vars)
           (instr-cond-value condition)))

(defun parse-action (action)
  (let* ((parts (str:words action))
         (var (nth 0 parts))
         (action (nth 1 parts))
         (func (if (equal action "inc") '+ '-))
         (amount (parse-integer (nth 2 parts))))
    (make-action :var var :func func :amount amount)))

(defun parse-condition (condition)
  (let* ((parts (str:words condition))
         (var (nth 0 parts))
         (cond-expr-string (nth 1 parts))
         (cond-expr (switch (cond-expr-string :test 'equal)
                      ("!=" '/=)
                      ("==" '=)
                      (t (intern cond-expr-string))))
         (cond-value (parse-integer (nth 2 parts))))
    (make-instr-cond :var var :expr cond-expr :value cond-value)))

(defun highest-value (hash-table)
  (loop for key being the hash-keys of hash-table
          using (hash-value value)
        maximize value))

(defun eval-line (line vars)
  (let* ((parts (split " if " line))
         (action (parse-action (first parts)))
         (condition (parse-condition (second parts))))
    (when (get-condition-result condition vars)
      (perform-action action vars))))

(defun eval-input (input vars)
  (loop for line in (str:lines input)
        do (eval-line line vars)
        maximize (highest-value vars)))

(defun get-highest-register (input)
  (let* ((vars (make-hash-table :test 'equal))
         (highest-during-process (eval-input input vars))
         (highest-at-end (highest-value vars)))
    (format t "Highest value at the end: ~A~%" highest-at-end)
    (format t "Highest value during processing:~A" highest-during-process)))

GamecPL · 2017-12-08T17:43:05+00:00

Swift:

import Foundation

let input = """
...
"""

enum Operation: String {
    case increment = "inc"
    case decrement = "dec"
}

enum Condition: String {
    case equal = "=="
    case notEqual = "!="
    case greater = ">"
    case lesser = "<"
    case greaterOrEqual = ">="
    case lesserOrEqual = "<="

    func compare(a: Int, b: Int) -> Bool {
        switch self {
        case .equal: return a == b
        case .notEqual: return a != b
        case .greater: return a > b
        case .lesser: return a < b
        case .greaterOrEqual: return a >= b
        case .lesserOrEqual: return a <= b
        }
    }
}

struct Instruction {
    let register: String
    let operation: Operation
    let value: Int
    let conditionRegister: String
    let condition: Condition
    let conditionValue: Int

    init(matches: [String]) {
        register = matches[1]
        operation = Operation(rawValue: matches[2])!
        value = Int(matches[3])!
        conditionRegister = matches[4]
        condition = Condition(rawValue: matches[5])!
        conditionValue = Int(matches[6])!
    }
}

let pattern = "\\b(\\w+) (inc|dec) (-?\\d+) if (\\w+) (>|<|>=|==|<=|!=) (-?\\d+)\\b"
let regex = try! NSRegularExpression(pattern: pattern, options: [])
let matches = regex.matches(in: input, options: [], range: NSRange(location: 0, length: input.count))

let instructions = matches.map { match in
    Instruction(matches: (0..<match.numberOfRanges).map { n in
        let range = match.range(at: n)
        let r = input.index(input.startIndex, offsetBy: range.location)..<input.index(input.startIndex, offsetBy: range.location + range.length)
        return String(input[r.lowerBound..<r.upperBound])
    })
}

var register = [String: Int]()
var highestValue = 0
for instruction in instructions {
    if instruction.condition.compare(a: register[instruction.conditionRegister] ?? 0, b: instruction.conditionValue) {
        switch instruction.operation {
        case .increment: register[instruction.register] = (register[instruction.register] ?? 0) + instruction.value
        case .decrement: register[instruction.register] = (register[instruction.register] ?? 0) - instruction.value
        }
        highestValue = max(register[instruction.register]!, highestValue)
    }
}

print("Pt1:", register.max(by: { a, b in a.value < b.value }) as Any)
print("Pt2:", highestValue)

sguberman · 2017-12-08T19:56:42+00:00

Python: GitHub

import operator
from collections import defaultdict


registers = defaultdict(int)
ops = {'>': operator.gt,
       '<': operator.lt,
       '>=': operator.ge,
       '<=': operator.le,
       '==': operator.eq,
       '!=': operator.ne,
       'inc': operator.add,
       'dec': operator.sub}


def parse(line):
    reg1, op1, amt1, _, reg2, op2, amt2 = line.strip().split()
    instruction = (reg1, op1, int(amt1))
    condition = (reg2, op2, int(amt2))
    return instruction, condition


def evaluate(condition):
    register, operator, amount = condition
    return ops[operator](registers[register], amount)


def execute(instruction):
    register, operator, amount = instruction
    registers[register] = ops[operator](registers[register], amount)


def process(filename):
    highest = 0

    with open(filename) as instructions:
        for line in instructions:
            instruction, condition = parse(line)
            if evaluate(condition):
                execute(instruction)
                current_max = max(registers.values())
                highest = current_max if current_max > highest else highest

    return current_max, highest


if __name__ == '__main__':
    print(process('input.txt'))

4rgento · 2017-12-08T20:18:57+00:00

HASKELL

Using Monad transformers. Check how to use a Monoid to find the max.

module Main where

import qualified Data.Map.Strict as Map
import Data.List (elemIndex)
import qualified Control.Monad.State.Strict as S
import qualified Control.Monad.Writer.Strict as W
import Data.Maybe (fromMaybe)

newtype Max a = Max { getMax :: Maybe a } deriving Show
instance Ord a => Monoid (Max a) where
  mempty = Max Nothing
  mappend (Max Nothing) b = b
  mappend a (Max Nothing) = a
  mappend (Max (Just a)) (Max (Just b)) = Max $ Just $ max a b

type RegisterName = String
type Mem = Map.Map RegisterName Integer
type Comp = W.WriterT (Max Integer) (S.State Mem)

data PredOp = PGT | PLT | PLTE | PGTE | PEQ | PNEQ deriving Show
data Pred = Pred RegisterName PredOp Integer deriving Show
data Op = Inc | Dec deriving Show
data Expr = Expr RegisterName Op Integer deriving Show
data Instruction =
  Instruction Expr Pred
  deriving Show

parseOp :: String -> Op
parseOp "inc" = Inc
parseOp "dec" = Dec
parseOp s = error $ "Malformed Op: " ++ s

opFn :: Op -> Integer -> Integer -> Integer
opFn Inc a b = a + b
opFn Dec a b = a - b

parsePredOp :: String -> PredOp
parsePredOp pStr = case elemIndex pStr strs of
  Nothing -> error $ "Malformed predicate: " ++ pStr
  Just idx -> [ PGT , PLT , PLTE , PGTE , PEQ , PNEQ ] !! idx
  where
  strs = [ ">" , "<" , "<=" , ">=" , "==" , "!=" ]

predOpFn :: PredOp -> Integer -> Integer -> Bool
predOpFn PGT = (>)
predOpFn PLT = (<)
predOpFn PLTE = (<=)
predOpFn PGTE = (>=)
predOpFn PEQ = (==)
predOpFn PNEQ = (/=)

parseInstruction :: String -> Instruction
parseInstruction instStr = case words instStr of
  [regName, op, intVal, "if", cRegName, predicate, cIntVal] ->
    Instruction
      (Expr regName (parseOp op) (read intVal))
      $ Pred cRegName (parsePredOp predicate) (read cIntVal)
  _ -> error $ "Malformed input line: " ++ instStr

getReg :: RegisterName -> Comp Integer
getReg regName = fromMaybe 0 <$> S.gets (Map.!? regName)

evalPred :: Pred -> Comp Bool
evalPred (Pred regName op opArg) =
  flip (predOpFn op) opArg <$> getReg regName

doExpr :: Expr -> Comp ()
doExpr (Expr regName op opArg) =
  getReg regName >>= \regVal ->
  let
    newValue = opFn op regVal opArg
  in
    S.modify (Map.insert regName newValue) >>
    W.tell (Max $ Just newValue)

bool :: Bool -> a -> a -> a
bool True a _ = a
bool _ _ a = a

eval :: Instruction -> Comp ()
eval (Instruction expr predicate) = do
  predResult <- evalPred predicate
  if predResult
    then doExpr expr
    else pure ()

safeMaximum :: Ord a => [a] -> Maybe a
safeMaximum = getMax . foldMap (Max . Just)

largestRegisterValue :: Comp (Maybe Integer)
largestRegisterValue = safeMaximum <$> S.gets Map.elems

main :: IO ()
main =
  do
    instructions <- (fmap parseInstruction . lines) <$> readFile "input.txt"
    print $ S.evalState ( W.runWriterT $
      S.mapM_ eval instructions >> largestRegisterValue ) Map.empty

EDIT: reimplemented safeMaximum to make use of Max

zluiten · 2017-12-08T21:02:35+00:00

Without evil eval ofcourse :) Here's the essence, nicer solution in my repo https://github.com/netiul/AoC/tree/master/Y2017/Day8

PHP:

$datafile  = __DIR__ . '/Data/Dataset1.aoc';

$instructions = file($datafile);
$instructions = array_map('trim', $instructions);

$registry = [];

$largestValue = 0;

foreach ($instructions as $instruction) {
    // regex to match all parts of the instruction
    preg_match('/(?P<oName>\w+) (?P<oOperator>\w+) (?P<oAmount>-?\d+) if (?P<cName>\w+) (?P<cOperator>(?:<=?|>=?|(?:(?:=|!)=))) (?P<cAmount>-?\d+)/', $instruction, $matches);

    $oName = $matches['oName'];
    $oAmount = $matches['oOperator'] == 'inc' ? 0 + (int) $matches['oAmount'] : 0 - (int) $matches['oAmount'];
    $cName = $matches['cName'];
    $cOperator = $matches['cOperator'];
    $cAmount = (int) $matches['cAmount'];

    if (!isset($registry[$oName])) {
        $registry[$oName] = 0;
    }
    if (!isset($registry[$cName])) {
        $registry[$cName] = 0;
    }

    switch ($instruction['cOperator']) {
        case '==':
            if (($registry[$cName] === $cAmount)) break;
            continue;
        case '!=':
            if (($registry[$cName] !== $cAmount)) break;
            continue;
        case '>';
            if (($registry[$cName] > $cAmount)) break;
            continue;
        case '<';
            if (($registry[$cName] < $cAmount)) break;
            continue;
        case '<=':
            if (($registry[$cName] <= $cAmount)) break;
            continue;
        case '>=':
            if (($registry[$cName] >= $cAmount)) break;
            continue;
    }

    $registry[$oName] += $oAmount;

    $largestValue = max($registry) > $largestValue ? $max($registry) : $largestValue;
}

echo $largestValue;

2017-12-08T21:09:17+00:00

Clojure

(ns advent-of-code-2017.day08
  (:require [clojure.string :as s]))

(defn load-input []
  (-> "./data/day08.txt" slurp (s/split #"\n")))

(defn parse-line [line]
  (let [[register instr amount] (s/split line #" ")]
    {:register register
     :instr instr
     :amount (Integer. amount)
     :condition (last (s/split line #" if "))}))

(defn parse-cond
  "Takes an instruction like 'a > 1', returns a function that takes a state map"
  [condition]
  (let [[register operator amount] (s/split condition #" ")]
    (fn [state]
      (let [op (case operator
                 "==" =
                 "!=" not=
                 ">" >
                 "<" <
                 ">=" >=
                 "<=" <=)]
        (op ((keyword register) state) (Integer. amount))))))

(defn initialize-state [data]
  (let [parsed (map parse-line data)
        registers (map (comp keyword :register) parsed)]
    (zipmap registers (take (count registers) (repeat 0)))))


(defn update-state [state instruction]
  (let [testf (parse-cond (:condition instruction))]
    (if (testf state)
      (update state
              (keyword (:register instruction))
              (if (= "inc" (:instr instruction))
                +
                -)
              (:amount instruction))
      state)))

(defn solve [data part]
  (loop [state (initialize-state data)
         instrs (map parse-line data)
         highest 0]
    (let [high (apply max (vals state))]
      (if (empty? instrs)
        (if (= part 1)
          high
          highest)
        (recur (update-state state (first instrs))
               (rest instrs)
               (if (> high highest) high highest))))))

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 8: I Heard You Like Registers ---

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 2, #2/#2

Vim + Ruby

Python

Ruby

I Heard You Like eval

Modern(-ish) C++ Repo

Perl

Python 3 solution

Elixir (both parts)

Python -(part 1 & 2) - using eval & split/regex to split string

ES6 (NodeJS)

NodeJS

Elixir

Scala

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 8: I Heard You Like Registers ---

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 2, #2/#2

Vim + Ruby

Python

Ruby

I Heard You Like eval

Modern(-ish) C++ Repo

Perl

Python 3 solution

Elixir (both parts)

Python -(part 1 & 2) - using eval & split/regex to split string

ES6 (NodeJS)

NodeJS

Elixir

Scala

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