Moved problems till e045.py to Python 2.

python/e037.py

@@ -0,0 +1,28 @@
+from lib_prime import primes
+
+
+def get_truncatable_numbers(n):
+    s = str(n)
+    ts = []
+    for i in range(1, len(s)):
+        ts.append(int(s[:i]))
+        ts.append(int(s[-i:]))
+    return ts
+
+
+def euler_037():
+    ps = primes(1000000)
+    ps_set = set(ps)
+    s = []
+    for p in ps[4:]:
+        for t in get_truncatable_numbers(p):
+            if t not in ps_set:
+                break
+        else:
+            s.append(p)
+    return sum(s)
+
+
+if __name__ == "__main__":
+    print("e037.py: " + str(euler_037()))
+    assert(euler_037() == 748317)

python/e038.py

@@ -0,0 +1,36 @@
+
+def is_concatenated_product_9_pandigital(n):
+    validation_array = [0 for _ in range(9)]
+    result = ""
+    total_length = 0
+    for i in range(1, 10):
+        current_product = str(i * n)
+        for d in current_product:
+            if d == "0":
+                return False
+            index = ord(d) - 49
+            validation_array[index] += 1
+            if validation_array[index] > 1:
+                return False
+        total_length += len(current_product)
+        result += current_product
+        if total_length == 9:
+            return result
+
+        if total_length > 9:
+            return False
+    raise Exception("We should not get here.")
+
+
+def euler_038():
+    r = []
+    for i in range(10000):
+        p = is_concatenated_product_9_pandigital(i)
+        if p:
+            r.append(int(p))
+    return max(r)
+
+
+if __name__ == "__main__":
+    print("e038.py: " + str(euler_038()))
+    assert(euler_038() == 932718654)

python/e039.py

@@ -0,0 +1,16 @@
+
+def get_triplets_for_perimter(p):
+    return [(a, b, p - a - b)
+            for b in range(1, p // 2 + 1)
+            for a in range(1, b)
+            if a * a + b * b == (p - a - b) * (p - a - b)]
+
+
+def euler_039():
+    return max([(len(get_triplets_for_perimter(p)), p)
+                for p in range(1, 1001)])[1]
+
+
+if __name__ == "__main__":
+    assert(euler_039() == 840)
+    print("e039.py: " + str(euler_039()))

python/e040.py

@@ -0,0 +1,22 @@
+from lib_misc import product
+
+
+def get_irrational_fraction(digits_max):
+    s = []
+    n = 1
+    digits = 0
+    while digits < digits_max:
+        s.append(str(n))
+        digits += len(str(n))
+        n += 1
+    return "".join(s)
+
+
+def euler_040():
+    f = get_irrational_fraction(1000001)
+    return product(map(int, [f[10**i - 1] for i in range(7)]))
+
+
+if __name__ == "__main__":
+    print("e040.py: " + str(euler_040()))
+    assert(euler_040() == 210)

python/e041.py

@@ -0,0 +1,14 @@
+from lib_misc import permutations
+from lib_prime import is_prime
+
+
+def euler_041():
+    for pandigital in permutations("7654321"):
+        p = int("".join(pandigital))
+        if is_prime(p):
+            return p
+
+
+if __name__ == "__main__":
+    print("e041.py: " + str(euler_041()))
+    assert(euler_041() == 7652413)

python/e042.py

@@ -0,0 +1,26 @@
+def get_words():
+    with open("../txt/EulerProblem042.txt", "r") as f:
+        s = f.read()
+    words = [w.strip('"') for w in s.split(",")]
+    return words
+
+
+def calculate_word_value(word):
+    word = word.upper()
+    return sum([ord(letter) - 64 for letter in word])
+
+
+def get_triangle_numbers(n):
+    return {n * (n + 1) // 2 for n in range(1, 101)}
+
+
+def euler_042():
+    triangle_numbers = get_triangle_numbers(100)
+    return len([word for word in get_words()
+                if calculate_word_value(word) in triangle_numbers])
+
+
+if __name__ == "__main__":
+    assert(calculate_word_value("sky") == 55)
+    print("e042.py: " + str(euler_042()))
+    assert(euler_042() == 162)

python/e043.py

@@ -0,0 +1,31 @@
+from lib_misc import permutations
+
+
+def is_sub_string_divisible(s):
+    s = "".join(s)
+    if int(s[1:4]) % 2 != 0:
+        return False
+    if int(s[2:5]) % 3 != 0:
+        return False
+    if int(s[3:6]) % 5 != 0:
+        return False
+    if int(s[4:7]) % 7 != 0:
+        return False
+    if int(s[5:8]) % 11 != 0:
+        return False
+    if int(s[6:9]) % 13 != 0:
+        return False
+    if int(s[7:10]) % 17 != 0:
+        return False
+    return True
+
+
+def euler_043():
+    return sum([int("".join(p))
+                for p in permutations("0123456789")
+                if is_sub_string_divisible(p)])
+
+
+if __name__ == "__main__":
+    print("e043.py: " + str(euler_043()))
+    assert(euler_043() == 16695334890)

python/e044.py

@@ -0,0 +1,20 @@
+def pentagonal(n):
+    return n * (3 * n - 1) // 2
+
+
+def euler_044():
+    n = 10000
+    p = [pentagonal(n) for n in range(1, n)]
+    p_set = set(p)
+    for i in range(1, n):
+        for j in range(i + 1, n):
+            if p[i - 1] + p[j - 1] in p_set and p[j - 1] - p[i - 1] in p_set:
+                d = pentagonal(j) - pentagonal(i)
+                s = d
+                # print("i = {}, j = {}, d = {}.".format(i, j, d))
+    return s
+
+
+if __name__ == "__main__":
+    print("e044.py: " + str(euler_044()))
+    assert(euler_044() == 5482660)

python/e045.py

@@ -0,0 +1,31 @@
+def t(n):
+    return n * (n + 1) // 2
+
+
+def p(n):
+    return n * (3 * n - 1) // 2
+
+
+def h(n):
+    return n * (2 * n - 1)
+
+
+def euler_045():
+    n_max = 100000
+    s = 0
+
+    t_list = [t(n) for n in range(1, n_max + 1)]
+    p_set = {p(n) for n in range(1, n_max + 1)}
+    h_set = {h(n) for n in range(1, n_max + 1)}
+
+    for n in range(1, n_max + 1):
+        if t_list[n - 1] in p_set and t_list[n - 1] in h_set:
+            t_ = t_list[n - 1]
+            if t_ > 40755:
+                s = t_
+    return s
+
+
+if __name__ == "__main__":
+    print("e045.py: " + str(euler_045()))
+    assert(euler_045() == 1533776805)

python/e046.py

@@ -0,0 +1,8 @@
+
+def euler_046():
+    return 0
+
+
+if __name__ == "__main__":
+    print("e046.py: " + str(euler_046()))
+    assert(euler_046() == 0)

python/e047.py

@@ -0,0 +1,8 @@
+
+def euler_047():
+    return 0
+
+
+if __name__ == "__main__":
+    print("e047.py: " + str(euler_047()))
+    assert(euler_047() == 0)

python/e048.py

@@ -0,0 +1,8 @@
+
+def euler_048():
+    return 0
+
+
+if __name__ == "__main__":
+    print("e048.py: " + str(euler_048()))
+    assert(euler_048() == 0)

python/e049.py

@@ -0,0 +1,8 @@
+
+def euler_049():
+    return 0
+
+
+if __name__ == "__main__":
+    print("e049.py: " + str(euler_049()))
+    assert(euler_049() == 0)

python/e050.py

@@ -0,0 +1,8 @@
+
+def euler_050():
+    return 0
+
+
+if __name__ == "__main__":
+    print("e050.py: " + str(euler_050()))
+    assert(euler_050() == 0)

python/e051.py

@@ -0,0 +1,8 @@
+
+def euler_051():
+    return 0
+
+
+if __name__ == "__main__":
+    print("e051.py: " + str(euler_051()))
+    assert(euler_051() == 0)

python/e052.py

@@ -0,0 +1,8 @@
+
+def euler_052():
+    return 0
+
+
+if __name__ == "__main__":
+    print("e052.py: " + str(euler_052()))
+    assert(euler_052() == 0)

python/e053.py

@@ -0,0 +1,8 @@
+
+def euler_053():
+    return 0
+
+
+if __name__ == "__main__":
+    print("e053.py: " + str(euler_053()))
+    assert(euler_053() == 0)

python/e054.py

@@ -0,0 +1,8 @@
+
+def euler_054():
+    return 0
+
+
+if __name__ == "__main__":
+    print("e054.py: " + str(euler_054()))
+    assert(euler_054() == 0)

python/e055.py

@@ -0,0 +1,8 @@
+
+def euler_055():
+    return 0
+
+
+if __name__ == "__main__":
+    print("e055.py: " + str(euler_055()))
+    assert(euler_055() == 0)

python/lib_create_templates.py

@@ -0,0 +1,20 @@
+FROM = 56
+TILL = 66
+
+template = """
+def euler_XXX():
+    return 0
+
+
+if __name__ == "__main__":
+    print("eXXX.py: " + str(euler_XXX()))
+    assert(euler_XXX() == 0)
+"""
+
+
+for i in range(FROM, TILL):
+    e = "0" + str(i)
+    filename = "e" + e + ".py"
+    with open(filename, "w") as f:
+        s = template.replace("XXX", e)
+        f.write(s)