diff options
Diffstat (limited to 'python')
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 |