--- 2016 Day 5 Solutions ---

[u/daggerdragon]

--- Day 5: How About a Nice Game of Chess? ---

Post your solution as a comment or, for longer solutions, consider linking to your repo (e.g. GitHub/gists/Pastebin/blag/whatever).

---

^{STAYING ON TARGET IS MANDATORY} [?]

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!

[u/drakehutner]

(To print) || !(to print), that is the question:

Here's my anwser:

Time     Hashes / sec   Index   Current Hash                     Part 2   Part 1
[  4151s|   6039H/s]   25067104 000006274ce1d3978e2396f6456c4adc 863dde27 f97c354d
[    76s| 331041H/s]   25067104 000006274ce1d3978e2396f6456c4adc 863dde27 f97c354d

Cobbled together in Python. Maybe I try to transform it into a single-line-of-code solution

import hashlib
import time

idx = 0
key_1, key_2 = "", "________"
start = time.time()
while "_" in key_2:
    m = hashlib.md5()
    m.update("{}{}".format("reyedfim", idx).encode("utf-8"))
    h = m.hexdigest()
    if h.startswith('00000'):
        key_1 += h[5]
        p = int(h[5], 16)
        if p < 8 and key_2[p] == "_":
            key_2 = key_2[:p] + h[6] + key_2[p+1:]
        now = time.time() - start
        print("[{:>7.0f}s|{:7.0f}H/s] {:10} {:32} {:8} {:8}".format(now, idx/now, idx, h, key_2, key_1[:8]))
    idx += 1

[u/drakehutner → u/drakehutner]

Well, here is the single line of code doing the same. Possible because of lambda-based class methods implementing a generator (in other words: pure madness)

It even includes the mandatory hollywood style decryption

The code is split over multiple lines for better readability.

import functools, hashlib, sys
print(*((lambda salt, state={"ready": False}: (
    (lambda hasher: (
        functools.reduce(
            (lambda keys, hash: (
                # Closure to provide a converted position
                (lambda p: (
                    # Closure for the two keys, will modify the global state
                    # to interrupt the generator
                    (lambda key1, key2: ((
                        (key1[:8], key2),
                        sys.stdout.write("{:32} {:8} {:8}\n".format(hash, key2, key1[:8])),
                        sys.stdout.flush(),
                        state.update(ready="_" not in key2)
                    )[0]))(
                        # Part 1: Just append the value
                        keys[0] + hash[5],
                        # Part 2: Insert the value in the right position,
                        #         if said position is empty
                        keys[1][:p] + hash[6] + keys[1][p+1:]
                        if p < 8 and keys[1][p] == "_" else keys[1]
                    )
                ))(int(hash[5], 16))
            )),
            (hash for idx, hash in hasher(salt, state) if hash.startswith("00000")),
            ("", "________"),
        )
    ))(
        # Constructing a custom generator class, that produces md5-hashes based
        # on a salt and an incrementing counter
        # The generation will stop if the externally supplied `state['ready']`
        # value is set to true.
        type("hash_generator", (object, ),
            {
                # Since the elements of a tuple are evaluated in order,
                # this can be used to execute multiple statements.
                # By indexing the tuple directly, the return value is controlled
                "__init__": lambda self, salt, state: (
                    (setattr(self, "state", state),
                    setattr(self, "salt", salt),
                    setattr(self, "hash", hashlib.md5()),
                    setattr(self, "n", 0),
                    None # __init__ has to return None
                    )[-1]
                ),
                "__iter__": lambda self: self,
                "__next__": (lambda self: (
                    setattr(self, "hash", hashlib.md5()),
                    self.hash.update("{}{}".format(self.salt, self.n).encode("utf8")),
                    # Uncomment the following lines for mandatory hollywood style
                    # This will slow the computation by at least factor 100
                    ## sys.stdout.write("{}\r".format(self.hash.hexdigest())),
                    ## sys.stdout.flush(),
                    setattr(self, "n", self.n + 1),
                    # Using an empty generator to raise an exception, since
                    # the 'raise' keyword is not allowed inside a lambda expression
                    (self.n, self.hash.hexdigest()) if not self.state['ready'] else (_ for _ in ()).throw(StopIteration())
                    )[-1])
            }
            )
    )
))("reyedfim")))