Add solutions

Author: jrmanrique

dailycodingproblem/day_7.py

@@ -0,0 +1,50 @@
+from collections import deque
+from random import randint
+
+
+def generate_input(width):
+    inp = str(randint(1, 9))
+    for _ in range(width - 1):
+        if inp[-1] in ['1', '2']:
+            inp += str(randint(0, 9))
+        else:
+            inp += str(randint(1, 9))
+    return inp
+
+
+def encode(string):
+    return ''.join([str(ord(c) - 96) for c in string])
+
+
+def decode(string):
+    solutions = []
+    queue = deque([[[], string]])
+    while queue:
+        path, rem = queue.popleft()
+        if rem:
+            if 10 <= int(rem[:2]) <= 26:
+                if len(rem[:3]) == 3 and int(rem[:3]) % 10 == 0:
+                    queue.append([path + [int(rem[0])], rem[1:]])
+                    continue
+                queue.append([path + [int(rem[:2])], rem[2:]])
+                if int(rem[:2]) % 10 == 0:
+                    continue
+            queue.append([path + [int(rem[0])], rem[1:]])
+        else:
+            solutions.append(path)
+    return solutions
+
+
+def main():
+    # inp = generate_input(randint(5, 15))
+    inp = encode('dailycoding')
+
+    sol = decode(inp)
+    print('"{}" has {} way{} of being decoded.'.format(inp, len(sol), '' if len(sol) == 1 else 's'))
+    decodes = [''.join([chr(o + 96) for o in s]) for s in sol]
+    print(decodes)
+    assert all([char.isalpha() for char in ''.join(decodes)])
+
+
+if __name__ == '__main__':
+    main()

projecteuler/README.md

@@ -78,3 +78,8 @@
 | 74 | Digit factorial chains | :small_blue_diamond: [Python](../projecteuler/python/p074.py)
 | 75 | Singular integer right triangles | :small_blue_diamond: [Python](../projecteuler/python/p075.py)
 | 76 | Counting summations | :small_blue_diamond: [Python](../projecteuler/python/p076.py)
+| 81 | Path sum: two ways | :small_blue_diamond: [Python](../projecteuler/python/p081.py)
+| 87 | Prime power triples | :small_blue_diamond: [Python](../projecteuler/python/p087.py)
+| 92 | Square digit chains | :small_orange_diamond: [Python](../projecteuler/python/p092.py)
+| 97 | Large non-Mersenne prime | :small_blue_diamond: [Python](../projecteuler/python/p097.py)
+| 206 | Concealed square | :small_blue_diamond: [Python](../projecteuler/python/p206.py)

projecteuler/inputs/p081.in

@@ -0,0 +1,67 @@
+# https://projecteuler.net/problem=81
+
+
+def load_file(file):
+    with open(file) as f:
+        data = f.read()
+    return data
+
+
+def backtrack(start, goal, matrix):
+    def get_moves(x, y, height, width):
+        ACTIONS = {
+            'U': (x - 1, y),
+            'L': (x, y - 1),
+        }
+        moves = []
+        for (nx, ny) in ACTIONS.values():
+            if 0 <= nx <= height and 0 <= ny <= width:
+                moves.append((nx, ny))
+        return moves
+
+    def get_best_move(matrix, moves):
+        children = [(matrix[nx][ny], (nx, ny)) for (nx, ny) in moves]
+        return sorted(children)[0][1]
+
+    def get_values(path):
+        return [matrix[x][y] for (x, y) in path]
+
+    gx, gy = goal
+    height, width = gx + 1, gy + 1
+
+    path = [(gx, gy)]
+    while path[-1] != start:
+        ox, oy = path[-1]
+        move = get_best_move(matrix, get_moves(ox, oy, height, width))
+        path.append(move)
+
+    return sum(get_values(path)), path
+
+
+def djikstra(matrix):
+    out = matrix
+    width, height = len(matrix), len(matrix[-1])
+    for r in range(height):
+        for c in range(width):
+            if r == 0 and c == 0:
+                out[r][c] = matrix[r][c]
+            elif r == 0:
+                out[r][c] = matrix[r][c] + out[r][c - 1]
+            elif c == 0:
+                out[r][c] = matrix[r][c] + out[r - 1][c]
+            else:
+                out[r][c] = matrix[r][c] + min([out[r][c - 1], out[r - 1][c]])
+    return out[-1][-1]
+
+
+def main():
+    inp = load_file('inputs/p081.in')
+    inp = [list(map(int, line.split(','))) for line in inp.splitlines()]
+
+    score = djikstra(inp)
+    print(score)
+    print('CORRECT ANSWER:', score == 427337)
+
+
+if __name__ == '__main__':
+    main()

projecteuler/python/p081.py

@@ -0,0 +1,35 @@
+# https://projecteuler.net/problem=87
+
+from itertools import product
+
+
+def sieve(limit):
+    sieve = {n: True for n in range(2, limit + 1)}
+    for n in range(2, limit + 1):
+        if sieve[n]:
+            for a in range(2, limit // n + 1):
+                sieve[n * a] = False
+    return [k for k, v in sieve.items() if v]
+
+
+def main():
+    limit = 50 * 10 ** 6
+    powers = {2: {}, 3: {}, 4: {}}
+    seen = set()
+    for a, b, c in product(sieve(7072), sieve(369), sieve(85)):
+        if a not in powers[2]:
+            powers[2][a] = a ** 2
+        if b not in powers[3]:
+            powers[3][b] = b ** 3
+        if c not in powers[4]:
+            powers[4][c] = c ** 4
+        num = powers[2][a] + powers[3][b] + powers[4][c]
+        if num > limit:
+            continue
+        if num not in seen:
+            seen.add(num)
+    print(len(seen))
+
+
+if __name__ == '__main__':
+    main()

projecteuler/python/p087.py

@@ -0,0 +1,65 @@
+# https://projecteuler.net/problem=92
+
+from collections import Counter
+from functools import lru_cache, reduce
+from math import factorial as f
+from operator import mul
+
+
+@lru_cache()
+def ss_digits(num):
+    return sum(map(lambda x: pow(int(x), 2), str(num)))
+
+
+def multinomial(num, width=None):
+    def _get_digits(num):
+        return map(int, str(num))
+
+    if width is None:
+        width = len(str(num))
+    c = Counter(_get_digits(num))
+    return f(width) // reduce(mul, [f(v) for v in c.values()])
+
+
+def generate_multisets(width):
+    def _ltoi(seq):
+        return int(''.join([str(d) for d in seq]))
+
+    num = [0] * width
+    ptr = width - 1
+    while True:
+        if ptr == 0 and num[ptr] == 9:
+            break
+        if ptr == width - 1 and num[ptr] < 9:
+            num[ptr] += 1
+            yield _ltoi(num)
+        elif num[ptr] == 9:
+            ptr -= 1
+        else:
+            num[ptr] += 1
+            for i in range(ptr + 1, width):
+                num[i] = num[ptr]
+            ptr = width - 1
+            yield _ltoi(num)
+
+
+def main():
+    limit = 7
+
+    counter = 0
+    cache = {}
+    for i in generate_multisets(limit):
+        num = i
+        while num not in (1, 89):
+            if num not in cache:
+                cache[num] = ss_digits(num)
+            num = cache[num]
+        if num == 89:
+            counter += multinomial(i, limit)
+
+    print(counter)
+    print('CORRECT ANSWER:', counter == 8581146)
+
+
+if __name__ == '__main__':
+    main()

projecteuler/python/p092.py

@@ -0,0 +1,12 @@
+# https://projecteuler.net/problem=97
+
+def main():
+    num = 1
+    for _ in range(7830457):
+        num = (num * 2) % (10 ** 10)
+    num = 28433 * num + 1
+    print(str(num)[-10:])
+
+
+if __name__ == '__main__':
+    main()

projecteuler/python/p097.py

@@ -0,0 +1,16 @@
+# https://projecteuler.net/problem=206
+
+def match(num):
+    return all([str(num)[i * 2] == str(i + 1) for i in range(9)])
+
+
+def main():
+    start = int(19293949596979899 ** 0.5) + 1
+    for n in range(start, 0, -2):
+        if match(n ** 2):
+            print(n * 10)
+            break
+
+
+if __name__ == '__main__':
+    main()

projecteuler/python/p206.py

@@ -1,5 +1,8 @@
 # Stacking Boxes
 
+from collections import deque
+
+
 def load_file(file):
     with open(file) as f:
         data = f.read()
@@ -38,7 +41,7 @@ def isfit(boxa, boxb):
 def find_path(boxes):
     best = []
     boxes = set(boxes)
-    stack = [[[box], boxes - set(box)] for box in sorted(boxes, reverse=True)]
+    stack = deque([[[box], boxes - set(box)] for box in sorted(boxes, reverse=True)])
     while stack:
         path, remaining = stack.pop()
         if len(path) >= len(best):

uvaonlinejudge/python/p103.py

@@ -1,5 +1,6 @@
 # Arbitrage
 
+from collections import deque
 from functools import reduce
 from operator import mul
 
@@ -47,18 +48,18 @@ def convert(table, seq):
 
 def find_arbitrage(table, starting=0):
     denoms = set([d for d, _ in enumerate(table)])
-    queue = [[starting, starting]]
+    stack = deque([[starting, starting]])
     best = ([], 1)
-    while queue:
-        path = queue.pop()
+    while stack:
+        path = stack.pop()
         if len(path) >= len(denoms):
             continue
         for child in denoms - set([path[-2]]):
             new = path[:-1] + [child] + path[-1:]
             cash = convert(table, new)
             if cash >= best[1]:
                 best = (new, cash)
-            queue.append(new)
+            stack.append(new)
     if best[0]:
         return [i + 1 for i in best[0]]
     return None