Moved more problems to Python.

python/e012.py

@@ -0,0 +1,12 @@
+from lib_prime import get_divisors_count
+from lib_misc import triangle_numbers
+
+
+def euler_012():
+    for tn in triangle_numbers():
+        if get_divisors_count(tn) > 500:
+            return tn
+
+
+assert(euler_012() == 76576500)
+print("e012.py: {}".format(euler_012()))

python/e013.py

@@ -0,0 +1,112 @@
+numbers_string = """
+37107287533902102798797998220837590246510135740250
+46376937677490009712648124896970078050417018260538
+74324986199524741059474233309513058123726617309629
+91942213363574161572522430563301811072406154908250
+23067588207539346171171980310421047513778063246676
+89261670696623633820136378418383684178734361726757
+28112879812849979408065481931592621691275889832738
+44274228917432520321923589422876796487670272189318
+47451445736001306439091167216856844588711603153276
+70386486105843025439939619828917593665686757934951
+62176457141856560629502157223196586755079324193331
+64906352462741904929101432445813822663347944758178
+92575867718337217661963751590579239728245598838407
+58203565325359399008402633568948830189458628227828
+80181199384826282014278194139940567587151170094390
+35398664372827112653829987240784473053190104293586
+86515506006295864861532075273371959191420517255829
+71693888707715466499115593487603532921714970056938
+54370070576826684624621495650076471787294438377604
+53282654108756828443191190634694037855217779295145
+36123272525000296071075082563815656710885258350721
+45876576172410976447339110607218265236877223636045
+17423706905851860660448207621209813287860733969412
+81142660418086830619328460811191061556940512689692
+51934325451728388641918047049293215058642563049483
+62467221648435076201727918039944693004732956340691
+15732444386908125794514089057706229429197107928209
+55037687525678773091862540744969844508330393682126
+18336384825330154686196124348767681297534375946515
+80386287592878490201521685554828717201219257766954
+78182833757993103614740356856449095527097864797581
+16726320100436897842553539920931837441497806860984
+48403098129077791799088218795327364475675590848030
+87086987551392711854517078544161852424320693150332
+59959406895756536782107074926966537676326235447210
+69793950679652694742597709739166693763042633987085
+41052684708299085211399427365734116182760315001271
+65378607361501080857009149939512557028198746004375
+35829035317434717326932123578154982629742552737307
+94953759765105305946966067683156574377167401875275
+88902802571733229619176668713819931811048770190271
+25267680276078003013678680992525463401061632866526
+36270218540497705585629946580636237993140746255962
+24074486908231174977792365466257246923322810917141
+91430288197103288597806669760892938638285025333403
+34413065578016127815921815005561868836468420090470
+23053081172816430487623791969842487255036638784583
+11487696932154902810424020138335124462181441773470
+63783299490636259666498587618221225225512486764533
+67720186971698544312419572409913959008952310058822
+95548255300263520781532296796249481641953868218774
+76085327132285723110424803456124867697064507995236
+37774242535411291684276865538926205024910326572967
+23701913275725675285653248258265463092207058596522
+29798860272258331913126375147341994889534765745501
+18495701454879288984856827726077713721403798879715
+38298203783031473527721580348144513491373226651381
+34829543829199918180278916522431027392251122869539
+40957953066405232632538044100059654939159879593635
+29746152185502371307642255121183693803580388584903
+41698116222072977186158236678424689157993532961922
+62467957194401269043877107275048102390895523597457
+23189706772547915061505504953922979530901129967519
+86188088225875314529584099251203829009407770775672
+11306739708304724483816533873502340845647058077308
+82959174767140363198008187129011875491310547126581
+97623331044818386269515456334926366572897563400500
+42846280183517070527831839425882145521227251250327
+55121603546981200581762165212827652751691296897789
+32238195734329339946437501907836945765883352399886
+75506164965184775180738168837861091527357929701337
+62177842752192623401942399639168044983993173312731
+32924185707147349566916674687634660915035914677504
+99518671430235219628894890102423325116913619626622
+73267460800591547471830798392868535206946944540724
+76841822524674417161514036427982273348055556214818
+97142617910342598647204516893989422179826088076852
+87783646182799346313767754307809363333018982642090
+10848802521674670883215120185883543223812876952786
+71329612474782464538636993009049310363619763878039
+62184073572399794223406235393808339651327408011116
+66627891981488087797941876876144230030984490851411
+60661826293682836764744779239180335110989069790714
+85786944089552990653640447425576083659976645795096
+66024396409905389607120198219976047599490197230297
+64913982680032973156037120041377903785566085089252
+16730939319872750275468906903707539413042652315011
+94809377245048795150954100921645863754710598436791
+78639167021187492431995700641917969777599028300699
+15368713711936614952811305876380278410754449733078
+40789923115535562561142322423255033685442488917353
+44889911501440648020369068063960672322193204149535
+41503128880339536053299340368006977710650566631954
+81234880673210146739058568557934581403627822703280
+82616570773948327592232845941706525094512325230608
+22918802058777319719839450180888072429661980811197
+77158542502016545090413245809786882778948721859617
+72107838435069186155435662884062257473692284509516
+20849603980134001723930671666823555245252804609722
+53503534226472524250874054075591789781264330331690
+"""
+
+
+def euler_013():
+    numbers = [int(n) for n in numbers_string.split('\n') if n]
+    numbers_sum = sum(numbers)
+    return int(str(numbers_sum)[:10])
+
+
+assert(euler_013() == 5537376230)
+print("e013.py: {}".format(euler_013()))

python/e014.py

@@ -0,0 +1,9 @@
+from lib_misc import collatz_sequence_length
+
+
+def euler_014():
+    return max([(collatz_sequence_length(n), n) for n in range(1, 1000000)])[1]
+
+
+assert(euler_014() == 837799)
+print("e014.py: {}".format(euler_014()))

python/e015.py

@@ -0,0 +1,21 @@
+from math import factorial
+
+
+def get_number_of_routes(n):
+    """
+    There are n down and n right moves which means 2 * n moves
+    in total. All permutations are calculated with (2n)!. Next redundant
+    moves have to be canceled out. The combinations for only down moves
+    or only right moves would (if they were different symbols) be n!.
+    Hence, the denominator is (n!)^2.
+    """
+    return factorial(2 * n) // (factorial(n) * factorial(n))
+
+
+def euler_015():
+    return get_number_of_routes(20)
+
+
+assert(get_number_of_routes(2) == 6)
+assert(euler_015() == 137846528820)
+print("e015.py: {}".format(euler_015()))

python/e016.py

@@ -0,0 +1,7 @@
+def euler_016():
+    s = sum(map(int, str(2**1000)))
+    return s
+
+
+assert(euler_016() == 1366)
+print("e016.py: {}".format(euler_016()))

python/e017.py

@@ -0,0 +1,71 @@
+def single_digit_integer_to_spoken_language(n):
+    if n == 0:
+        return ""
+    assert(n > 0 and n < 10)
+    return {1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five',
+            6: 'six', 7: 'seven', 8: 'eight', 9: 'nine'}[n]
+
+
+def double_digit_integer_to_spoken_language(n):
+    assert(n > 9 and n < 100)
+    try:
+        return {
+            10: 'ten', 11: 'eleven', 12: 'twelve', 13: 'thirteen',
+            14: 'fourteen', 15: 'fifteen', 16: 'sixteen',
+            17: 'seventeen', 18: 'eighteen', 19: 'nineteen'}[n]
+    except KeyError:
+        pass
+    a, b = str(n)
+    a = {2: 'twenty', 3: 'thirty', 4: 'forty', 5: 'fifty',
+         6: 'sixty', 7: 'seventy', 8: 'eighty', 9: 'ninety'}[int(a)]
+    b = integer_to_spoken_language(int(b))
+    return a + '-' + b
+
+
+def triple_digit_integer_to_spoken_language(n):
+    a, b = str(n)[0], str(n)[1:]
+    a = single_digit_integer_to_spoken_language(int(a))
+    b = integer_to_spoken_language(int(b))
+    if not b:
+        return a + " hundred"
+    return a + " hundred and " + b
+
+
+def four_digit_integer_to_spoken_language(n):
+    a, b = str(n)[0], str(n)[1:]
+    a = single_digit_integer_to_spoken_language(int(a))
+    b = integer_to_spoken_language(int(b))
+    return a + " thousand " + b
+
+
+def integer_to_spoken_language(n):
+    length = len(str(n))
+    if length == 1:
+        return single_digit_integer_to_spoken_language(n)
+    elif length == 2:
+        return double_digit_integer_to_spoken_language(n)
+    elif length == 3:
+        return triple_digit_integer_to_spoken_language(n)
+    elif length == 4:
+        return four_digit_integer_to_spoken_language(n)
+    else:
+        raise Exception("Length not supported.")
+
+
+assert(integer_to_spoken_language(5) == 'five')
+assert(integer_to_spoken_language(19) == 'nineteen')
+assert(integer_to_spoken_language(21) == 'twenty-one')
+assert(integer_to_spoken_language(210) == 'two hundred and ten')
+assert(integer_to_spoken_language(3000) == 'three thousand ')
+assert(integer_to_spoken_language(8333) ==
+       'eight thousand three hundred and thirty-three')
+
+
+def euler_017():
+    s = "".join([integer_to_spoken_language(i) for i in range(1, 1001)])
+    s = s.replace(" ", "").replace("-", "")
+    return len(s)
+
+
+assert(euler_017() == 21124)
+print("e017.py: {}".format(euler_017()))

python/e018.py

@@ -0,0 +1,37 @@
+t = """
+75
+95 64
+17 47 82
+18 35 87 10
+20 04 82 47 65
+19 01 23 75 03 34
+88 02 77 73 07 63 67
+99 65 04 28 06 16 70 92
+41 41 26 56 83 40 80 70 33
+41 48 72 33 47 32 37 16 94 29
+53 71 44 65 25 43 91 52 97 51 14
+70 11 33 28 77 73 17 78 39 68 17 57
+91 71 52 38 17 14 91 43 58 50 27 29 48
+63 66 04 68 89 53 67 30 73 16 69 87 40 31
+04 62 98 27 23 09 70 98 73 93 38 53 60 04 23
+"""
+
+
+def find_greatest_path_sum_in_triangle_string(ts):
+    from functools import reduce
+    xss = [list(map(int, xs.split())) for xs in ts.split("\n") if xs]
+    xss.reverse()
+
+    def r(xs, ys):
+        return [max([xs[i] + ys[i], xs[i + 1] + ys[i]])
+                for i in range(len(ys))]
+    return reduce(r, xss[1:], xss[0])[0]
+
+
+def euler_018():
+    return find_greatest_path_sum_in_triangle_string(t)
+
+
+if __name__ == "__main__":
+    assert(euler_018() == 1074)
+    print("e018.py: {}".format(euler_018()))

python/e019.py

@@ -0,0 +1,55 @@
+def weekday_generator_function():
+    while True:
+        yield 'Monday'
+        yield 'Tuesday'
+        yield 'Wednesday'
+        yield 'Thursday'
+        yield 'Friday'
+        yield 'Saturday'
+        yield 'Sunday'
+
+
+def day_of_month_generator_function():
+    day, month, year = 1, 1, 1901
+    while year < 2001:
+        yield day
+        day += 1
+        if month == 2:
+            if year % 4 == 0 and (not year % 100 == 0 or year % 400 == 0):
+                if day == 30:
+                    month += 1
+                    day = 1
+            elif day == 29:
+                month += 1
+                day = 1
+        elif month in [9, 4, 6, 11] and day == 31:
+            day = 1
+            month += 1
+        elif month in [1, 3, 5, 7, 8, 10] and day == 32:
+            day = 1
+            month += 1
+        elif month == 12 and day == 32:
+            day = 1
+            month = 1
+            year += 1
+
+
+def euler_019():
+    wds = weekday_generator_function()
+    next(wds)  # get rid of first Monday
+    ds = zip(wds, day_of_month_generator_function())
+    s = len([1 for weekday, date in ds if weekday == "Sunday" and date == 1])
+    return s
+
+
+def euler_019_brain():
+    """ We have 100 years which means
+    1200 months. Every months starts with a day
+    and 1/7 of all days are Sundays. """
+    return 1200 // 7
+
+
+if __name__ == "__main__":
+    assert(euler_019() == 171)
+    assert(euler_019() == euler_019_brain())
+    print("e019.py: {}".format(euler_019()))

python/e020.py

@@ -0,0 +1,7 @@
+def euler_020():
+    return 0
+
+
+if __name__ == "__main__":
+    assert(euler_020() == 1074)
+    print("e020.py: {}".format(euler_020()))

python/e067.py

@@ -0,0 +1,11 @@
+from e018 import find_greatest_path_sum_in_triangle_string
+
+
+def euler_067():
+    with open("../txt/EulerProblem067.txt") as f:
+        return find_greatest_path_sum_in_triangle_string(f.read())
+
+
+if __name__ == "__main__":
+    assert(euler_067() == 7273)
+    print("e067.py: {}".format(euler_067()))

python/lib_misc.py

@@ -1,3 +1,6 @@
+from functools import lru_cache
+
+
 def get_digits_reversed(n):
     """
     Returns a list of digits for n.
@@ -76,3 +79,59 @@ def product(l):
     from functools import reduce
     import operator
     return reduce(operator.mul, l, 1)
+
+
+def triangle_numbers():
+    c = 0
+    i = 1
+    while True:
+        c += i
+        yield c
+        i += 1
+
+
+def even(n):
+    """
+    Returns true if a number is even.
+    """
+    return n % 2 == 0
+
+
+def odd(n):
+    """
+    Returns true if a number is odd.
+    """
+    return n % 2 != 0
+
+
+def collatz_sequence(n):
+    """
+    Returns collatz sequence for n.
+
+    :param n: collatz sequence
+    """
+    cs = []
+    while n != 1:
+        cs.append(n)
+        n = n // 2 if n % 2 == 0 else 3 * n + 1
+    cs.append(n)
+    return cs
+
+
+@lru_cache(maxsize=1000000)
+def collatz_sequence_length(n):
+    """
+    Returns length of collatz sequence for n.
+
+    :param n: collatz sequence
+    """
+    if n == 1:
+        return 1
+    length = 1
+    while odd(n):
+        n = 3 * n + 1
+        length += 1
+    return length + collatz_sequence_length(n // 2)
+
+
+

python/lib_misc_tests.py

@@ -5,12 +5,20 @@ try:
     from .lib_misc import get_digits_reversed
     from .lib_misc import get_item_counts
     from .lib_misc import product
+    from .lib_misc import triangle_numbers
+    from .lib_misc import even, odd
+    from .lib_misc import collatz_sequence
+    from .lib_misc import collatz_sequence_length
 except ModuleNotFoundError:
     from lib_misc import is_palindrome_integer
     from lib_misc import is_palindrome_string
     from lib_misc import get_digits_reversed
     from lib_misc import get_item_counts
     from lib_misc import product
+    from lib_misc import triangle_numbers
+    from lib_misc import even, odd
+    from lib_misc import collatz_sequence
+    from lib_misc import collatz_sequence_length
 
 
 class TestPrimeMethods(unittest.TestCase):
@@ -42,6 +50,26 @@ class TestPrimeMethods(unittest.TestCase):
         self.assertEqual(product([2, 4, 8]), 64)
         self.assertEqual(product([]), 1)
 
+    def test_triangle_numbers(self):
+        f = triangle_numbers()
+        self.assertEqual(next(f), 1)
+        self.assertEqual(next(f), 3)
+        self.assertEqual(next(f), 6)
+        self.assertEqual(next(f), 10)
+        self.assertEqual(next(f), 15)
+        self.assertEqual(next(f), 21)
+
+    def test_even_odd(self):
+        self.assertTrue(odd(3))
+        self.assertTrue(even(4))
+        self.assertFalse(even(3))
+        self.assertFalse(odd(4))
+
+    def test_collatz(self):
+        self.assertEqual(collatz_sequence(13),
+                         [13, 40, 20, 10, 5, 16, 8, 4, 2, 1])
+        self.assertEqual(collatz_sequence_length(13), 10)
+
 
 if __name__ == '__main__':
     unittest.main()

python/lib_prime.py

@@ -1,7 +1,9 @@
 try:
     from lib_misc import get_item_counts
+    from lib_misc import product
 except ModuleNotFoundError:
     from .lib_misc import get_item_counts
+    from .lib_misc import product
 
 
 def prime_factors(n):
@@ -107,3 +109,36 @@ def primes(n_max):
         if b[i - 1]:
             ps.append(i)
     return ps
+
+
+def get_divisors_count(n):
+    """
+    Returns the number of divisors for n.
+    The numbers 1 and n count as a divisor.
+
+    >>> get_divisors_count(1)
+    1
+    >>> get_divisors_count(3)
+    2 # 1, 3
+    >>> get_divisors_count(4)
+    3 # 1, 2, 4
+
+    Getting the number of divisors is a combinatorial
+    problem that can be solved by using the counts
+    for each prime factor. For example, consider
+
+    2 * 2 * 7 = 28
+
+    We have 3 options for 2 (1, 1 * 2, 2 * 2)
+    and 2 options for 7 (1, 1 * 7).
+
+    By multiplying those options we get the number
+    of combinations:
+
+    2 * 3 = 6
+    """
+    if n == 1:
+        return 1
+    factors = prime_factors_count(n)
+    count = product([v + 1 for v in factors.values()])
+    return count

python/lib_prime_tests.py

@@ -5,12 +5,14 @@ try:
     from .lib_prime import is_prime
     from .lib_prime import prime_nth
     from .lib_prime import primes
+    from .lib_prime import get_divisors_count
 except ModuleNotFoundError:
     from lib_prime import prime_factors
     from lib_prime import prime_factors_count
     from lib_prime import is_prime
     from lib_prime import prime_nth
     from lib_prime import primes
+    from lib_prime import get_divisors_count
 
 
 class TestPrimeMethods(unittest.TestCase):
@@ -23,6 +25,7 @@ class TestPrimeMethods(unittest.TestCase):
         self.assertEqual(prime_factors(147), [3, 7, 7])
 
     def test_prime_factors_count(self):
+        self.assertEqual(prime_factors_count(1), {})
         self.assertEqual(prime_factors_count(2), {2: 1})
         self.assertEqual(prime_factors_count(147), {3: 1, 7: 2})
 
@@ -59,6 +62,15 @@ class TestPrimeMethods(unittest.TestCase):
         self.assertEqual(primes(25), [2, 3, 5, 7, 11, 13, 17, 19, 23])
         self.assertEqual(primes(1), [])
 
+    def test_get_divisors_count(self):
+        self.assertEqual(get_divisors_count(1), 1)
+        self.assertEqual(get_divisors_count(3), 2)
+        self.assertEqual(get_divisors_count(6), 4)
+        self.assertEqual(get_divisors_count(10), 4)
+        self.assertEqual(get_divisors_count(15), 4)
+        self.assertEqual(get_divisors_count(21), 4)
+        self.assertEqual(get_divisors_count(28), 6)
+
 
 if __name__ == '__main__':
     unittest.main()