initial commit

34 files changed, 726 insertions, 0 deletions

diff --git a/python/1-multiples35.py b/python/1-multiples35.py
new file mode 100644
index 0000000..6a92369
--- /dev/null
+++ b/python/1-multiples35.py
@@ -0,0 +1,9 @@
+# -*- coding:utf-8 -*-
+
+sum35 = 0
+i = 0
+while i < 1000:
+    if i % 3 == 0 or i % 5 == 0:
+        sum35 += i
+    i += 1
+print(sum35)
diff --git a/python/10-summation_of_primes.py b/python/10-summation_of_primes.py
new file mode 100644
index 0000000..e637c9c
--- /dev/null
+++ b/python/10-summation_of_primes.py
@@ -0,0 +1,10 @@
+from helper.prime import is_prime
+
+prime_numbers = []
+for num in range(2, 2_000_000):
+    if is_prime(num, prime_numbers):
+        prime_numbers.append(num)
+    num += 1
+
+summation = sum(prime_numbers)
+print(summation)
diff --git a/python/11-largest_product_in_a_grid.py b/python/11-largest_product_in_a_grid.py
new file mode 100644
index 0000000..c98a41e
--- /dev/null
+++ b/python/11-largest_product_in_a_grid.py
@@ -0,0 +1,80 @@
+from functools import reduce
+
+grid = [
+    [8, 2, 22, 97, 38, 15, 0, 40, 0, 75, 4, 5, 7, 78, 52, 12, 50, 77, 91, 8],
+    [49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 4, 56, 62, 0],
+    [81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 3, 49, 13, 36, 65],
+    [52, 70, 95, 23, 4, 60, 11, 42, 69, 24, 68, 56, 1, 32, 56, 71, 37, 2, 36, 91],
+    [22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80],
+    [24, 47, 32, 60, 99, 3, 45, 2, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50],
+    [32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70],
+    [67, 26, 20, 68, 2, 62, 12, 20, 95, 63, 94, 39, 63, 8, 40, 91, 66, 49, 94, 21],
+    [24, 55, 58, 5, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72],
+    [21, 36, 23, 9, 75, 0, 76, 44, 20, 45, 35, 14, 0, 61, 33, 97, 34, 31, 33, 95],
+    [78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 3, 80, 4, 62, 16, 14, 9, 53, 56, 92],
+    [16, 39, 5, 42, 96, 35, 31, 47, 55, 58, 88, 24, 0, 17, 54, 24, 36, 29, 85, 57],
+    [86, 56, 0, 48, 35, 71, 89, 7, 5, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58],
+    [19, 80, 81, 68, 5, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 4, 89, 55, 40],
+    [4, 52, 8, 83, 97, 35, 99, 16, 7, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66],
+    [88, 36, 68, 87, 57, 62, 20, 72, 3, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69],
+    [4, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 8, 46, 29, 32, 40, 62, 76, 36],
+    [20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 4, 36, 16],
+    [20, 73, 35, 29, 78, 31, 90, 1, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 5, 54],
+    [1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 1, 89, 19, 67, 48]
+]
+
+
+def isCorrectIndex(x, y):
+    if 0 <= x < 20 and 0 <= y < 20:
+        return True
+    return False
+
+
+def getAdjacentNumbers(x, y):
+    adjacent = {
+        'vertical': [],
+        'horizontal': [],
+        'diagonal': [],
+        'anti-diagonal': []
+    }
+
+    for i in range(4):
+        # vertical list
+        modifiedX = x + i
+        if isCorrectIndex(modifiedX, y):
+            adjacent['vertical'].append(grid[modifiedX][y])
+
+        # horizontal list
+        modifiedY = y + i
+        if isCorrectIndex(x, modifiedY):
+            adjacent['horizontal'].append(grid[x][modifiedY])
+
+        # diagonal list
+        if isCorrectIndex(modifiedX, modifiedY):
+            adjacent['diagonal'].append(grid[modifiedX][modifiedY])
+
+    # anti-diagonal list
+    for i, j in zip(range(4), range(4)):
+        AntiDiagModifiedX = x - j
+        modifiedY = y + i
+        if isCorrectIndex(AntiDiagModifiedX, modifiedY):
+            adjacent['anti-diagonal'].append(grid[AntiDiagModifiedX][modifiedY])
+
+    # filtering
+    for key in adjacent.keys():
+        if len(adjacent[key]) != 4:
+            adjacent[key] = []
+
+    return adjacent
+
+
+largest_sum = 0
+positions = ((x, y) for x in range(20) for y in range(20))
+for x, y in positions:
+    adjacent = getAdjacentNumbers(x, y)
+    for key in adjacent.keys():
+        multiplied = reduce(lambda acc, val: acc * val, adjacent[key], 1)
+        if multiplied > largest_sum:
+            largest_sum = multiplied
+
+print(largest_sum)
diff --git a/python/13-large_sum.py b/python/13-large_sum.py
new file mode 100644
index 0000000..2548228
--- /dev/null
+++ b/python/13-large_sum.py
@@ -0,0 +1,108 @@
+large_numbers = [
+    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
+]
+
+large_numbers_sum = sum(large_numbers)
+
+first_ten_digits_of_sum = str(large_numbers_sum)[:10]
+
+print(first_ten_digits_of_sum)
diff --git a/python/14-longest_collatz_sequence.py b/python/14-longest_collatz_sequence.py
new file mode 100644
index 0000000..e3c3caa
--- /dev/null
+++ b/python/14-longest_collatz_sequence.py
@@ -0,0 +1,16 @@
+from itertools import count
+
+
+def collatz_sequence_size(nb):
+    for i in count(1):
+        if nb == 1:
+            return i
+        nb = (nb / 2) if nb % 2 == 0 else (nb * 3 + 1)
+
+max_nb = (1, 0)
+for nb in range(1, 1_000_000):
+    col_seq_size = collatz_sequence_size(nb)
+    if col_seq_size > max_nb[1]:
+        max_nb = nb, col_seq_size
+
+print(max_nb)
diff --git a/python/15-lattice_paths.py b/python/15-lattice_paths.py
new file mode 100644
index 0000000..90d9531
--- /dev/null
+++ b/python/15-lattice_paths.py
@@ -0,0 +1,17 @@
+def build_pascal_triangle(rows):
+    triangle = [[0, 1, 0]]
+    for i in range(1, rows + 1):
+        next_row = [0, 0]
+        previous_row = triangle[i - 1]
+        for j in range(len(previous_row) - 1):
+            next_row.insert(j + 1, previous_row[j] + previous_row[j + 1])
+        triangle.append(next_row)
+    return triangle
+
+
+lattice_len = 20
+print([
+        x[len(x) // 2]
+        for i, x in enumerate(build_pascal_triangle(lattice_len * 2))
+        if i % 4 == 0
+    ][-1])
diff --git a/python/16-power_digit_sum.py b/python/16-power_digit_sum.py
new file mode 100644
index 0000000..584ba67
--- /dev/null
+++ b/python/16-power_digit_sum.py
@@ -0,0 +1,5 @@
+two_power_thousand = 2 ** 1000
+
+list_of_digits = [int(dgt) for dgt in list(str(two_power_thousand))]
+
+print(sum(list_of_digits))
diff --git a/python/17-number_letter_count.py b/python/17-number_letter_count.py
new file mode 100644
index 0000000..9998831
--- /dev/null
+++ b/python/17-number_letter_count.py
@@ -0,0 +1,56 @@
+w_nums = {
+    '0': '',
+    '00': '',
+    '1': 'one',
+    '2': 'two',
+    '3': 'three',
+    '4': 'four',
+    '5': 'five',
+    '6': 'six',
+    '7': 'seven',
+    '8': 'eight',
+    '9': 'nine',
+    '10': 'ten',
+    '11': 'eleven',
+    '12': 'twelve',
+    '13': 'thirteen',
+    '14': 'fourteen',
+    '15': 'fifteen',
+    '16': 'sixteen',
+    '17': 'seventeen',
+    '18': 'eighteen',
+    '19': 'nineteen',
+    '20': 'twenty',
+    '30': 'thirty',
+    '40': 'forty',
+    '50': 'fifty',
+    '60': 'sixty',
+    '70': 'seventy',
+    '80': 'eighty',
+    '90': 'ninety',
+    '100': 'hundred',
+    '1000': 'thousand'
+}
+w_nums = {key: len(val) for (key, val) in w_nums.items()}
+
+def two_digit_num(num):
+    if num[0] == '1':
+        return w_nums[num]
+    else:
+        return w_nums[num[0] + '0'] + w_nums[num[1]]
+
+
+c = 0
+for num in [str(n) for n in range(1, 1001)]:
+    c += [
+        lambda: w_nums[num],
+        lambda: two_digit_num(num),
+        lambda: (
+            w_nums[num[0]] + w_nums['100']
+            + (len('and') if num[1:] != '00' else 0)
+            + two_digit_num(num[1:])
+        ),
+        lambda: len('onethousand')
+    ][len(num)-1]()
+    
+print(c)
diff --git a/python/18-max_path_sum_I.py b/python/18-max_path_sum_I.py
new file mode 100644
index 0000000..f091782
--- /dev/null
+++ b/python/18-max_path_sum_I.py
@@ -0,0 +1,36 @@
+triangle = [
+                                [75],
+                              [95, 64],
+                            [17, 47, 82],
+                          [18, 35, 87, 10],
+                        [20,  4, 82, 47, 65],
+                      [19,  1, 23, 75,  3, 34],
+                    [88,  2, 77, 73,  7, 63,  67],
+                  [99, 65, 4 , 28,  6, 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,  4, 68, 89, 53,  67, 30, 73, 16, 69, 87, 40, 31],
+    [ 4, 62, 98, 27, 23,  9,  70, 98, 73, 93, 38, 53, 60,  4, 23]
+]
+
+# très mauvaise récursion
+def walk_through(triangle, paths=[], x=0, y=0, path=[]):
+    if x == len(triangle):
+        if y+1 == len(triangle[-1]):
+            return paths
+        return [*paths, path]
+        
+    new_path = [*path, triangle[x][y]]
+    return [
+        *walk_through(triangle, paths, x+1, y, new_path),
+        *walk_through(triangle, paths, x+1, y+1, new_path)
+    ]
+
+    
+paths = walk_through(triangle)
+max_path_sum = max([sum(x) for x in paths])
+
+print(max_path_sum)
diff --git a/python/19-counting_sundays.py b/python/19-counting_sundays.py
new file mode 100644
index 0000000..f018e05
--- /dev/null
+++ b/python/19-counting_sundays.py
@@ -0,0 +1,34 @@
+def month_days(index, leap_year):
+    if index == 2:
+        if leap_year:
+            return 29
+        return 28
+    if index in [4, 6, 9, 11]:
+        return 30
+    return 31
+
+
+def is_leap_year(year):
+    if str(year)[2:] == '00' and year % 400 != 0:
+        return False
+    if year % 4 == 0:
+        return True
+    return False
+
+def next_day(current):
+    if current == 7:
+        return 1
+    return current + 1
+
+months = [x for x in range(1, 13)]
+day = 1
+sundays_counter = 0
+
+for year in range(1900, 2001):
+    for month in months:
+        for d in range(month_days(month, is_leap_year(year))):
+            if day == 7 and d == 0 and year >= 1901:
+                sundays_counter += 1
+            day = next_day(day)
+
+print(sundays_counter)
diff --git a/python/2-fibo_even.py b/python/2-fibo_even.py
new file mode 100644
index 0000000..14991c9
--- /dev/null
+++ b/python/2-fibo_even.py
@@ -0,0 +1,10 @@
+a, b, c = 1, 1, 0
+result = 0
+while b < 4000000:
+    c = a
+    a = b
+    b = b + c
+    if b < 4000000 and b % 2 == 0:
+        result += b
+
+print(result)
diff --git a/python/20-factorial_digit_sum.py b/python/20-factorial_digit_sum.py
new file mode 100644
index 0000000..a76b4ae
--- /dev/null
+++ b/python/20-factorial_digit_sum.py
@@ -0,0 +1,9 @@
+import math
+
+one_hundred_factorial = math.factorial(100)
+
+to_list_of_int = [int(dgt) for dgt in list(str(one_hundred_factorial))]
+
+sum_of_all_digits = sum(to_list_of_int)
+
+print(sum_of_all_digits)
diff --git a/python/21-amicable_numbers.py b/python/21-amicable_numbers.py
new file mode 100644
index 0000000..6f89986
--- /dev/null
+++ b/python/21-amicable_numbers.py
@@ -0,0 +1,13 @@
+from helper.numbers import proper_divisors
+
+
+amicable_nums = []
+for a in range(1, 10_000):
+    if a in amicable_nums:
+        continue
+
+    b = sum(proper_divisors(a))
+    if a != b and sum(proper_divisors(b)) == a:
+        amicable_nums.extend([a, b])
+
+print(sum(amicable_nums))
diff --git a/python/22-names_scores.py b/python/22-names_scores.py
new file mode 100644
index 0000000..7bba853
--- /dev/null
+++ b/python/22-names_scores.py
@@ -0,0 +1,9 @@
+names = []
+with open('./helper/data/names.txt', 'r') as file:
+    names = sorted([n[1:-1] for n in file.read().split(',')])
+
+total = 0
+for i, name in enumerate(names):
+    total += sum([ord(s) - 64 for s in name]) * (i + 1)
+
+print(total)
diff --git a/python/24-lexicographic_permutations.py b/python/24-lexicographic_permutations.py
new file mode 100644
index 0000000..d24eb7c
--- /dev/null
+++ b/python/24-lexicographic_permutations.py
@@ -0,0 +1,6 @@
+from helper.other import n_digits_pandigital
+
+nine_digits_perm = n_digits_pandigital(10, True)
+
+print(nine_digits_perm[999_999])
+# print(nine_digits_perm)
diff --git a/python/25-1000_digits_fibonacci_number.py b/python/25-1000_digits_fibonacci_number.py
new file mode 100644
index 0000000..5ee37b6
--- /dev/null
+++ b/python/25-1000_digits_fibonacci_number.py
@@ -0,0 +1,8 @@
+a, b, c = 1, 1, 0
+i = 2
+while len(str(c)) != 1000:
+    c = a + b
+    a, b = b, c
+    i += 1
+
+print(i)
diff --git a/python/28-number_spiral_diagonals.py b/python/28-number_spiral_diagonals.py
new file mode 100644
index 0000000..ca657d5
--- /dev/null
+++ b/python/28-number_spiral_diagonals.py
@@ -0,0 +1,46 @@
+from itertools import count
+
+size = 1001
+center = (size-1) // 2
+grid = [[None for _ in range(size)] for _ in range(size)]
+
+i = 1
+x, y = center, center
+for cycle_nb in count():
+    grid[x][y] = i
+    y += 1
+    i += 1
+
+    if grid[0][-1] != None:
+        break
+
+    for _ in range(cycle_nb * 2 - 1):
+        grid[x][y] = i
+        x += 1
+        i += 1
+    
+    for _ in range(cycle_nb * 2):
+        grid[x][y] = i
+        y -= 1
+        i += 1
+
+    for _ in range(cycle_nb * 2):
+        grid[x][y] = i
+        x -= 1
+        i += 1
+
+    for _ in range(cycle_nb * 2):
+        grid[x][y] = i
+        y += 1
+        i += 1
+
+
+diag_sum = 0
+for x, y in zip(range(size), range(size)):
+    diag_sum += grid[x][y]
+
+adiag_sum = 0
+for x, y in zip(reversed(range(size)), range(size)):
+    adiag_sum += grid[x][y]
+
+print(diag_sum + adiag_sum - 1)
diff --git a/python/29-distinct_powers.py b/python/29-distinct_powers.py
new file mode 100644
index 0000000..8957e43
--- /dev/null
+++ b/python/29-distinct_powers.py
@@ -0,0 +1,8 @@
+nums_range = range(2, 101)
+
+combinations = []
+for a in nums_range:
+    for b in nums_range:
+        combinations.append(a ** b)
+
+print(len(set(combinations)))
diff --git a/python/3-prime_fact.py b/python/3-prime_fact.py
new file mode 100644
index 0000000..6f73c10
--- /dev/null
+++ b/python/3-prime_fact.py
@@ -0,0 +1,19 @@
+# It work but la flemme de couper la boucle quand on a atteint le dernier facteur.
+number = 600851475143
+prime_factors = []
+
+end = False
+while not end:
+
+    for divisor in range(2, number + 1):
+
+        if number % divisor == 0:
+            prime_factors.append(divisor)
+            number = int(number / divisor)
+            print(prime_factors)
+            if divisor == number:
+                end = True
+            break
+
+
+print(prime_factors)
diff --git a/python/34-digit_factorials.py b/python/34-digit_factorials.py
new file mode 100644
index 0000000..c94b0d2
--- /dev/null
+++ b/python/34-digit_factorials.py
@@ -0,0 +1,11 @@
+from itertools import count
+from math import factorial
+
+
+def is_sum_factorial_digit(num):
+    return sum([factorial(int(d)) for d in str(num)]) == num
+
+# il n'y en a que deux, je ne sais pas quelle est la limite
+for i in count(3):
+    if is_sum_factorial_digit(i):
+        print(i)
diff --git a/python/35-circular_primes.py b/python/35-circular_primes.py
new file mode 100644
index 0000000..5d5243b
--- /dev/null
+++ b/python/35-circular_primes.py
@@ -0,0 +1,19 @@
+from helper.prime import primes_until, is_prime
+
+def rotate_num(l, x):
+    l = str(l)
+    return int(l[-x:] + l[:-x])
+
+c_nb_list = []
+for p in primes_until(1_000_000):
+    circular = True
+    for k in range(1, len(str(p))):
+        if not is_prime(rotate_num(p, k)):
+            circular = False
+            break
+    
+    if circular:
+        c_nb_list.append(p)
+
+print(c_nb_list)
+print(len(c_nb_list))
diff --git a/python/36-double_base_palindrome.py b/python/36-double_base_palindrome.py
new file mode 100644
index 0000000..758ad1b
--- /dev/null
+++ b/python/36-double_base_palindrome.py
@@ -0,0 +1,8 @@
+# https://projecteuler.net/problem=36
+
+sum = 0
+for nb in range(1_000_000):
+    if str(nb) == str(nb)[::-1] and f'{nb:b}' == f'{nb:b}'[::-1]:
+        sum += nb
+
+print(sum)
diff --git a/python/4-largest_palindrome.py b/python/4-largest_palindrome.py
new file mode 100644
index 0000000..096de7a
--- /dev/null
+++ b/python/4-largest_palindrome.py
@@ -0,0 +1,12 @@
+threeDigitsReversedList = list(reversed(range(100, 1000)))
+
+palindrome_num = 0
+for a in threeDigitsReversedList:
+    for b in threeDigitsReversedList:
+        num = a * b
+        if str(num) == str(num)[::-1]:
+            if num > palindrome_num:
+                palindrome_num = num
+                break
+
+print(palindrome_num)
diff --git a/python/41-pandigital_prime.py b/python/41-pandigital_prime.py
new file mode 100644
index 0000000..7229e29
--- /dev/null
+++ b/python/41-pandigital_prime.py
@@ -0,0 +1,10 @@
+from helper.other import n_digits_pandidital
+from helper.prime import is_prime
+
+maximum = 0
+for i in range(1, 10):
+    for nb in n_digits_pandidital(i):
+        if is_prime(nb) and nb > maximum:
+            maximum = nb
+
+print(maximum)
diff --git a/python/42-coded_triangle_numbers.py b/python/42-coded_triangle_numbers.py
new file mode 100644
index 0000000..3a90945
--- /dev/null
+++ b/python/42-coded_triangle_numbers.py
@@ -0,0 +1,17 @@
+from helper.numbers import is_triangular
+
+
+def letter_alph_ord(l):
+    return ord(l) - 64
+
+def sum_letter_ord(word):
+    return sum([letter_alph_ord(l) for l in word])
+
+counter = 0
+with open('helper/data/words.txt', 'r') as file:
+    words = [w[1:-1] for w in file.read().split(',')]
+    for w in words:
+        if is_triangular(sum_letter_ord(w)):
+            counter += 1
+
+print(counter)
diff --git a/python/43-sub_string_divisibility.py b/python/43-sub_string_divisibility.py
new file mode 100644
index 0000000..16164c1
--- /dev/null
+++ b/python/43-sub_string_divisibility.py
@@ -0,0 +1,24 @@
+from itertools import permutations
+
+
+first_primes = [2, 3, 5, 7, 11, 13, 17]
+all_pandigital = [int(''.join(map(lambda n: str(n), x))) for x in permutations(range(10)) if x[0] != 0]
+
+
+def property_check(nb):
+    str_nb = str(nb)
+    indexs = [1, 2, 3]
+    for i in range(7):
+        if int(''.join([str_nb[i] for i in indexs])) % first_primes[i] != 0:
+            return False
+        indexs = [x + 1 for x in indexs]
+
+    return True
+
+
+nb_sum = 0
+for nb in all_pandigital:
+    if property_check(nb):
+        nb_sum += nb
+
+print(nb_sum)
diff --git a/python/48-self_powers.py b/python/48-self_powers.py
new file mode 100644
index 0000000..6d12141
--- /dev/null
+++ b/python/48-self_powers.py
@@ -0,0 +1 @@
+print(str(sum([i ** i for i in range(1, 1001)]))[-10:])
diff --git a/python/52-permuted_multiples.py b/python/52-permuted_multiples.py
new file mode 100644
index 0000000..c7711e2
--- /dev/null
+++ b/python/52-permuted_multiples.py
@@ -0,0 +1,16 @@
+from itertools import count
+
+
+found = False
+for i in count(1):
+    foo = [sorted(str(i * x)) for x in range(1, 7)]
+    
+    for w in foo[1:]:
+        found = True
+        if w != foo[0]:
+            found = False
+            break
+
+    if found:
+        print(i)
+        break
diff --git a/python/55-lychrel_numbers.py b/python/55-lychrel_numbers.py
new file mode 100644
index 0000000..efdf31d
--- /dev/null
+++ b/python/55-lychrel_numbers.py
@@ -0,0 +1,19 @@
+from helper.palindrome import is_palindrome
+
+
+def reverse_and_add(num):
+    return num + int(str(num)[::-1])
+
+def is_lychrel_number(num):
+    for _ in range(50):
+        num = reverse_and_add(num)
+        if is_palindrome(num):
+            return False
+    return True
+
+counter = 0
+for i in range(10_000):
+    if is_lychrel_number(i):
+        counter += 1
+
+print(counter)
diff --git a/python/56-powerful_digit_sum.py b/python/56-powerful_digit_sum.py
new file mode 100644
index 0000000..a12ebe4
--- /dev/null
+++ b/python/56-powerful_digit_sum.py
@@ -0,0 +1,10 @@
+from helper.numbers import sum_digits
+
+max_sum = 0
+for a in range(100):
+    for b in range(100):
+        s = sum_digits(a ** b)
+        if s > max_sum:
+            max_sum = s
+
+print(max_sum)
diff --git a/python/6-sum_square_difference.py b/python/6-sum_square_difference.py
new file mode 100644
index 0000000..9b5b1c7
--- /dev/null
+++ b/python/6-sum_square_difference.py
@@ -0,0 +1,8 @@
+a = 0
+b = 0
+
+for i in range(1, 101):
+    a += i ** 2
+    b += i
+
+print(b ** 2 - a)
diff --git a/python/7-10001st_prime.py b/python/7-10001st_prime.py
new file mode 100644
index 0000000..19793f3
--- /dev/null
+++ b/python/7-10001st_prime.py
@@ -0,0 +1,26 @@
+import math
+
+
+prime_numbers = []
+
+num = 2
+end = False
+while not end:
+    num_sqrt = math.ceil(math.sqrt(num))
+
+    is_prime = True
+    for prime_num in prime_numbers:
+        if prime_num < num_sqrt + 1:
+            if num % prime_num == 0:
+                is_prime = False
+        else:
+            break
+
+    if is_prime:
+        prime_numbers.append(num)
+    num += 1
+
+    if len(prime_numbers) == 10001:
+        break
+
+print(prime_numbers[-1])
diff --git a/python/8-largest_product_in_a_series.py b/python/8-largest_product_in_a_series.py
new file mode 100644
index 0000000..133461c
--- /dev/null
+++ b/python/8-largest_product_in_a_series.py
@@ -0,0 +1,37 @@
+number = "73167176531330624919225119674426574742355349194934" +\
+         "96983520312774506326239578318016984801869478851843" +\
+         "85861560789112949495459501737958331952853208805511" +\
+         "12540698747158523863050715693290963295227443043557" +\
+         "66896648950445244523161731856403098711121722383113" +\
+         "62229893423380308135336276614282806444486645238749" +\
+         "30358907296290491560440772390713810515859307960866" +\
+         "70172427121883998797908792274921901699720888093776" +\
+         "65727333001053367881220235421809751254540594752243" +\
+         "52584907711670556013604839586446706324415722155397" +\
+         "53697817977846174064955149290862569321978468622482" +\
+         "83972241375657056057490261407972968652414535100474" +\
+         "82166370484403199890008895243450658541227588666881" +\
+         "16427171479924442928230863465674813919123162824586" +\
+         "17866458359124566529476545682848912883142607690042" +\
+         "24219022671055626321111109370544217506941658960408" +\
+         "07198403850962455444362981230987879927244284909188" +\
+         "84580156166097919133875499200524063689912560717606" +\
+         "05886116467109405077541002256983155200055935729725" +\
+         "71636269561882670428252483600823257530420752963450"
+
+highest_products = []
+
+number = list(number)
+for i, n in enumerate(number):
+    number[i] = int(number[i])
+
+for i, n in enumerate(number):
+    product = n
+    try:
+        for j in range(1, 13):
+            product *= number[i + j]
+    except IndexError:
+        product = 0
+    highest_products.append(product)
+
+print(max(highest_products))
diff --git a/python/9-pythagorean_triplet.py b/python/9-pythagorean_triplet.py
new file mode 100644
index 0000000..a1f3708
--- /dev/null
+++ b/python/9-pythagorean_triplet.py
@@ -0,0 +1,9 @@
+import math
+
+for a in range(0, 1000):
+    for b in range(1, 1000):
+        c = math.sqrt(a ** 2 + b ** 2)
+        if a < b < c and a + b + c == 1000:
+            print(f'{a} + {b} + {int(c)} = 1000')
+            print(f'a × b × c = {int(a * b * c)}')
+            break