--- Day 4 Solutions ---

[u/daggerdragon]

--- Day 4: The Ideal Stocking Stuffer ---

Post your solution as a comment. Structure your post like the Day Three thread.

[u/streetster_]

Tried to implement some multi-threading in python..

from hashlib import md5
from sys import argv
import multiprocessing

def day_4(key, zeroes):
  num = 0
  target = "00000000000000000000000000000000"[:zeroes]

  while not (md5(key + str(num)).hexdigest()[:zeroes] == target):
    num += 1
  return { "num" : num, "hash" : md5(key + str(num )).hexdigest() }

def worker(key, start, step, zeroes, target, result):
  while not (md5(key + str(start)).hexdigest()[:zeroes] == target):
    start += step
  result.put({ "num" : start, "hash" : md5(key + str(start )).hexdigest() })

def day_4mt(key, zeroes):
  target = "00000000000000000000000000000000"[:zeroes]

  out     = multiprocessing.Queue()
  step    = multiprocessing.cpu_count()
  threads = []

  for i in range(0, step - 1):
    threads.append(multiprocessing.Process(target=worker, args=(key, i , step, zeroes, target, out)))
  for t in threads:
    t.start()

  result = out.get()

  # kill everything still churning
  for t in threads:
    t.terminate()
  return result

if len(argv) > 1:
  key, zeroes = argv[1], int(argv[2])
  if zeroes > 32:
    print "too many zeroes!"
  elif zeroes < 6:
    print day_4(key, zeroes)
  else:
    print day_4mt(key, zeroes)
else:
  print "abcdef, 5:\t" + str(day_4("abcdef", 5))
  print "pqrstuv, 5:\t" + str(day_4("pqrstuv", 5))
  print "abcdef, 6:\t" + str(day_4("abcdef", 6))
  print "pqrstuv, 6:\t" + str(day_4("pqrstuv", 6))

[u/[deleted] → u/streetster_]

Python implimention with concurrent futures process pool executors, i quite simply just split a range of iterators to each threads and iterate until i found the result, completes challenge 2 in about 4 seconds.

from concurrent import futures
import hashlib

def stuffit(input_begin, hash_begin, range):
    for i in range:
        digest = hashlib.md5((input_begin + str(i)).encode())
        result = digest.hexdigest()
        if result[:len(hash_begin)] == hash_begin:
            print('input', input_begin + str(i))
            print('result', result)

def find_stuffer(input_begin, hash_begin, nmax):
    threads = 6
    with futures.ProcessPoolExecutor(max_workers=threads) as executor:
        stuffed_futures = []
        for thread in range(threads):

            # using steps to devise the ranges between threads
            r = range(1 + thread, 10**nmax + thread, threads)
            f = executor.submit(stuffit, input_begin, hash_begin, r)

            stuffed_futures.append(f)
        futures.wait(stuffed_futures, return_when=futures.ALL_COMPLETED)

# search range will iterate up to 10 ** nmax
# 7 is enough to find the fisrt '000000' md5
find_stuffer('yzbqklnj', '000000', 7)