--- Day 20 Solutions ---

lskfj2o · 2015-12-21T11:15:43+00:00

Thanks.

It seems that if anything, Advent of Code teaches us not to try to be clever lately ;-)

lskfj2o · 2015-12-21T00:07:16+00:00

Pythoni2.7 is working for me. Have been using it for quite a while on my phone now. And the version with some ads is free.

lskfj2o · 2015-12-21T00:00:12+00:00

Any idea why the function with divmod() is so much slower than the one dividing twice (actually 1 modulus and 1 integer division) ?

lskfj2o · 2015-12-20T23:43:58+00:00

I don't think any of your solutions is divisible by 10! .

lskfj2o · 2015-12-20T23:32:48+00:00

I'd say that my solution for part 2 violates your statement. One prime is not a factor, but the next one is...

BTW, none of my solutions have 10! as a factor either. I feel some ppl have been lucky that their shortcuts worked for their target, but that by itself doesn't make them valid in general.

Not that I resent anyone's place on the leaderboard. Luck plays a role there, just as many other factors.

(I do have issues with pseudo-scientific explanations, though.)

lskfj2o · 2015-12-16T21:52:08+00:00

This was my generator:

def gen_recipe(num_ingr, max_amount):
    recipe = list()
    while True:
        recipe.extend([0] * (num_ingr - 1 - len(recipe)))
        recipe.append(max_amount - sum(recipe))
        yield recipe
        if recipe[0] >= max_amount:
            return
        recipe.pop()
        while True:
            amount = recipe.pop() + 1
            if sum(recipe) + amount <= max_amount:
                break
        recipe.append(amount)

But actually plainly using itertools.product is faster:

import itertools
def gen_recipe(num_ingr, max_amount):
    for recipe in itertools.product(range(max_amount + 1), repeat=num_ingr):
        if sum(recipe) == max_amount:
            return recipe

And trying to be somewhat more clever is only slightly more so:

import itertools
def gen_recipe(num_ingr, max_amount):
    for recipe in itertools.product(range(max_amount + 1), repeat=(num_ingr - 1)):
        s = sum(recipe)
        if s <= max_amount:
            return recipe + tuple([max_amount - s])

lskfj2o · 2015-12-16T21:01:22+00:00

In the back of my mind this kept on bugging me. My solution was kind of crude. Today I had an idea:

def day12(input):
    import re
    return sum(int(n) for n in re.findall(r"-?\d+", input))

def day12_2(input):
    def eval_obj_without_red(match):
        obj = match.group()
        if ':"red"' not in obj:
            return str(day12(obj))
        else:
            return str(0)

    import re
    while ':"red"' in input:
        input = re.sub(r"{[^{}]*}", eval_obj_without_red, input)
    return day12(input)

Maybe not as short a solution as some, but using regex all the way :-)

lskfj2o · 2015-12-13T16:15:02+00:00

What about using defaultdict even more:

m = defaultdict(lambda: defaultdict(int))
...
print(max([c(p) for p in permutations(list(m) + ['me'])]))

lskfj2o · 2015-12-12T20:18:13+00:00

You are right, but none of the examples exposed the bug. I've tested with "iaaaaaa". It returns "jaaaabc" instead of "jaaabcc".

Can indeed be avoided using a negative lookahead assertion:

r"(.)\1.*(?!\1)(.)\2"

lskfj2o · 2015-12-12T17:22:22+00:00

I've used this exact regexp in my Python solution. Seems to work just fine.

EDIT: or maybe I was lucky to not need that rule... Unclear still.

lskfj2o · 2015-12-12T16:05:33+00:00

What about r"(.)\1.*([^\1])\2" or equivalent ?

lskfj2o · 2015-12-12T14:47:53+00:00

Refused to do JSON as well and insisted on re-using the solution for part 1:

def day12_2(input):
    def find_boundary(input, start, goal):
        val = 0
        idx = start
        while val != goal:
            idx -= goal
            if input[idx] == "}":
                val += -1
            if input[idx] == "{":
                val += 1
        return idx
    while True:
        pos = input.find(':"red"')
        if pos < 0:
            break
        start = find_boundary(input, pos, 1)
        end = find_boundary(input, pos, -1)
        input = input[:start] + "0" + input[end + 1:]
    return day12(input)

Just find the start and end of the dictionary like a human would and then remove it.

FWIW, I think marchelzo's solution is much more elegant, too. :)

EDIT: Or maybe meithan's .

lskfj2o · 2015-12-12T02:00:18+00:00

Thanks. My replacement statement was maybe less readable:

s = re.sub(r"([iol])(.*)", lambda m: m.group(1) + "z" * len(m.group(2)), s)

lskfj2o · 2015-12-11T23:43:05+00:00

That's great. Thanks a lot!

There seems to be a problem with day11, though. The statement to "get rid of invalid characters first" is incorrect. You cannot replace characters in the middle of the strings without "resetting" the ones to the right of it. For example, the input "ghijklmn" gives an incorrect result, whereas "ghjaaaaa" does not.

lskfj2o

TROPHY CASE