From 3ffc76713f6db4c33f20588ce6896ea3c2bae2a7 Mon Sep 17 00:00:00 2001 From: Charles Date: Sat, 17 Aug 2019 21:39:43 +0200 Subject: wip directory for each language --- .gitignore | 3 + README.md | 5 +- c/wip/053-combinatoric-selections.c | 43 ++++++++++ c/wip/092-square_digit_chains.c | 89 +++++++++++++++++++++ haskell/wip/011-largest_product_in_a_grid.hs | 72 +++++++++++++++++ .../wip/012-highly_divisible_triangular_number.hs | 44 ++++++++++ haskell/wip/021-amicable_numbers.hs | 31 +++++++ haskell/wip/023-non_abundant_sum.hs | 57 +++++++++++++ haskell/wip/030-digit_fifth_powers.hs | 30 +++++++ haskell/wip/044-pentagonal_numbers.hs | 19 +++++ python/helper/__pycache__/prime.cpython-37.pyc | Bin 1054 -> 0 bytes python/wip/023-non_abudant_sums.py | 16 ++++ python/wip/026-reciprocal_cycles.py | 5 ++ python/wip/027-quadratic_primes.py | 17 ++++ python/wip/031-coin_sums.py | 12 +++ python/wip/037-truncatable_primes.py | 25 ++++++ .../wip/045-triangular_pentagonal_and_hexagonal.py | 9 +++ python/wip/047-distinct_primes_factors.py | 20 +++++ python/wip/049-prime_permutations.py | 23 ++++++ wip/023-non_abudant_sums.py | 16 ---- wip/026-reciprocal_cycles.py | 5 -- wip/027-quadratic_primes.py | 17 ---- wip/031-coin_sums.py | 12 --- wip/037-truncatable_primes.py | 25 ------ wip/045-triangular_pentagonal_and_hexagonal.py | 9 --- wip/047-distinct_primes_factors.py | 20 ----- wip/049-prime_permutations.py | 23 ------ wip/053-combinatoric-selections.c | 43 ---------- wip/092-square_digit_chains.c | 89 --------------------- 29 files changed, 519 insertions(+), 260 deletions(-) create mode 100644 c/wip/053-combinatoric-selections.c create mode 100644 c/wip/092-square_digit_chains.c create mode 100644 haskell/wip/011-largest_product_in_a_grid.hs create mode 100644 haskell/wip/012-highly_divisible_triangular_number.hs create mode 100644 haskell/wip/021-amicable_numbers.hs create mode 100644 haskell/wip/023-non_abundant_sum.hs create mode 100644 haskell/wip/030-digit_fifth_powers.hs create mode 100644 haskell/wip/044-pentagonal_numbers.hs delete mode 100644 python/helper/__pycache__/prime.cpython-37.pyc create mode 100644 python/wip/023-non_abudant_sums.py create mode 100644 python/wip/026-reciprocal_cycles.py create mode 100644 python/wip/027-quadratic_primes.py create mode 100644 python/wip/031-coin_sums.py create mode 100644 python/wip/037-truncatable_primes.py create mode 100644 python/wip/045-triangular_pentagonal_and_hexagonal.py create mode 100644 python/wip/047-distinct_primes_factors.py create mode 100644 python/wip/049-prime_permutations.py delete mode 100644 wip/023-non_abudant_sums.py delete mode 100644 wip/026-reciprocal_cycles.py delete mode 100644 wip/027-quadratic_primes.py delete mode 100644 wip/031-coin_sums.py delete mode 100644 wip/037-truncatable_primes.py delete mode 100644 wip/045-triangular_pentagonal_and_hexagonal.py delete mode 100644 wip/047-distinct_primes_factors.py delete mode 100644 wip/049-prime_permutations.py delete mode 100644 wip/053-combinatoric-selections.c delete mode 100644 wip/092-square_digit_chains.c diff --git a/.gitignore b/.gitignore index cf20380..cf793cd 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,7 @@ *.o a.out +__pycache__ haskell/* !haskell/*.hs +haskell/wip/ +!haskell/wip/*.hs diff --git a/README.md b/README.md index 94ceaea..8f467e6 100644 --- a/README.md +++ b/README.md @@ -2,4 +2,7 @@ My attempt at solving some of the [Project Euler](https://projecteuler.net/) problems. -This is a mess btw but the solutions are in [c/](c/), [python/](python/) and [haskell/](haskell/). +I try to solve each problem in multiple languages: +- [haskell/](haskell/), beauty +- [python/](python/), simplicity +- [C](c/), just used to bruteforce stuff diff --git a/c/wip/053-combinatoric-selections.c b/c/wip/053-combinatoric-selections.c new file mode 100644 index 0000000..9006f5a --- /dev/null +++ b/c/wip/053-combinatoric-selections.c @@ -0,0 +1,43 @@ +#include +#include + + +typedef long long unsigned int Natural; + +Natural factorial(Natural n) +{ + if (n == 1 || n == 0) return 1; + else return n * factorial(n - 1); +} + +Natural combination(Natural n, Natural r) +{ + if (r > n) exit(1); + Natural num = 0; + /* for (Natural i = 0; i < r - 1; i++) */ + /* num *= n - i; */ + /* return num / factorial(r); */ + /* if (factorial(r) * factorial(n - r) == 0) return 0; */ + return (factorial(n) / (factorial(r) * factorial(n - r))); + /* return (factorial(r) * factorial(n - r)); */ +} + +int main(void) +{ + printf("10! = %llu\n", factorial(10)); + printf("23! = %llu\n", factorial(23)); + printf("(23 - 10)! = %llu\n", factorial(23 - 10)); + int counter = 0; + Natural comb = 0, n, r; + /* for (n = 1; n <= 24; n++) */ + /* for (r = 1; r <= n; r++) { */ + /* comb = combination(n, r); */ + /* if (comb > 1000000) { */ + /* counter++; */ + /* comb = combination(23, 10); */ + printf("%llu C %llu = %llu\n", n, r, comb); + /* } */ + /* } */ + printf("counter = %d", counter); + return 0; +} diff --git a/c/wip/092-square_digit_chains.c b/c/wip/092-square_digit_chains.c new file mode 100644 index 0000000..7029ccd --- /dev/null +++ b/c/wip/092-square_digit_chains.c @@ -0,0 +1,89 @@ +#include +#include +#include + + +int lenHelper(int x) +{ + if (x >= 10000000) return 8; + if (x >= 1000000) return 7; + if (x >= 100000) return 6; + if (x >= 10000) return 5; + if (x >= 1000) return 4; + if (x >= 100) return 3; + if (x >= 10) return 2; + return 1; +} + +int get_digit(int nb, int digit_index) +{ + if (digit_index == 1) + return nb % 10; + + return (int)(nb / pow(10.0, (double)(digit_index-1))) % 10; +} + +int next_iteration(int nb) +{ + int i, sum = 0; + for (i = 0; i < lenHelper(nb); i++) { + sum += pow(get_digit(nb, i), 2); + } + return sum; +} + +bool end_of_square_digit_chain_is_89(int nb) +{ + bool once = false; + int next_nb; + for (int i = 0; i < 10; i++) { + // printf("%d", next_nb); + next_nb = next_iteration(nb); + if (next_nb == 89 || next_nb == 1) { + if (once) { + return next_nb == 89 ? true : false; + } + once = true; + } + nb = next_nb; + } + return false; +} + + +int main(void) +{ + int i, counter = 0; + for (i = 1; i < 10000000; i++) { + // printf("%d\n", i); + if (end_of_square_digit_chain_is_89(i)) + counter++; + if (i % 1000000 == 0) + printf("%d\n", counter); + } + + printf("%d\n", counter); + + return 0; +} + + + +// def end_of_square_digit_chain_is_89(nb): +// once = False +// while True: +// next_nb = sum([int(x)**2 for x in str(nb)]) +// if next_nb == 89 or next_nb == 1: +// if once: +// return True if next_nb == 89 else False +// once = True +// nb = next_nb + +// counter = 0 +// for i in range(1, 10_000_000): +// if end_of_square_digit_chain_is_89(i): +// counter += 1 +// if i % 1000_000 == 0: +// print(counter) +// pass +// print(counter) diff --git a/haskell/wip/011-largest_product_in_a_grid.hs b/haskell/wip/011-largest_product_in_a_grid.hs new file mode 100644 index 0000000..75f1db0 --- /dev/null +++ b/haskell/wip/011-largest_product_in_a_grid.hs @@ -0,0 +1,72 @@ +-- Largest product in a grid +-- +-- Problem 11 +-- In the 20×20 grid below, four numbers along a diagonal line have been marked in red. +-- +-- 08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08 +-- 49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00 +-- 81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65 +-- 52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 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 03 45 02 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 02 62 12 20 95 _63 94 39 63 08 40 91 66 49 94 21 +-- 24 55 58 05 66 73 99 26 97 17 _78 78 96 83 14 88 34 89 63 72 +-- 21 36 23 09 75 00 76 44 20 45 35 _14 00 61 33 97 34 31 33 95 +-- 78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92 +-- 16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57 +-- 86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58 +-- 19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40 +-- 04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66 +-- 88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69 +-- 04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36 +-- 20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16 +-- 20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54 +-- 01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48 +-- +-- The product of these numbers is 26 × 63 × 78 × 14 = 1788696. +-- +-- What is the greatest product of four adjacent numbers in the same direction +-- (up, down, left, right, or diagonally) in the 20×20 grid? + + +main = do + -- print (largest_product grid) + print grid + +largest_product :: [[Int]] -> Int +largest_product g = maximum [largest_row, largest_col, largest_diag] + where largest_row = 3 + largest_col = 3 + largest_diag = 3 + +max4 :: [Int] -> Int +max4 [x] = x +max4 (x:xs) = max (sum (take 4 (x:xs))) (max4 xs) + + + + + +grid :: [[Int]] +grid = map (map read) (map words (lines grid_str)) +grid_str = "08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08\n\ + \49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00\n\ + \81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65\n\ + \52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91\n\ + \22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80\n\ + \24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50\n\ + \32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70\n\ + \67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21\n\ + \24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72\n\ + \21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95\n\ + \78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92\n\ + \16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57\n\ + \86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58\n\ + \19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40\n\ + \04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66\n\ + \88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69\n\ + \04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36\n\ + \20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16\n\ + \20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54\n\ + \01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48" diff --git a/haskell/wip/012-highly_divisible_triangular_number.hs b/haskell/wip/012-highly_divisible_triangular_number.hs new file mode 100644 index 0000000..ad621b0 --- /dev/null +++ b/haskell/wip/012-highly_divisible_triangular_number.hs @@ -0,0 +1,44 @@ +-- Highly divisible triangular number + +-- Problem 12 +-- The sequence of triangle numbers is generated by adding the natural numbers. +-- So the 7th triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. +-- The first ten terms would be: + +-- 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ... + +-- Let us list the factors of the first seven triangle numbers: + +-- 1: 1 +-- 3: 1,3 +-- 6: 1,2,3,6 +-- 10: 1,2,5,10 +-- 15: 1,3,5,15 +-- 21: 1,3,7,21 +-- 28: 1,2,4,7,14,28 +-- We can see that 28 is the first triangle number to have over five divisors. + +-- What is the value of the first triangle number to have over five hundred divisors? + + +main = do + print (trial_division 2 10) + print (find_triangular 1) + + +find_triangular :: Int -> Int +find_triangular n + | trial_division 2 nth_triangular > 100 = nth_triangular + | otherwise = find_triangular (n + 1) + where nth_triangular = (n * (n + 1)) `div` 2 + +trial_division :: Int -> Int -> Int +trial_division by x + | x == 0 || by > x = 2 + | x `mod` by == 0 = 1 + trial_division by (x `div` by) + | otherwise = trial_division (by + 1) x + +-- naive +-- triangulars :: Int -> [Int] +-- triangulars 0 = [] +-- triangulars i = sum [1..i] : triangulars (i - 1) diff --git a/haskell/wip/021-amicable_numbers.hs b/haskell/wip/021-amicable_numbers.hs new file mode 100644 index 0000000..867765d --- /dev/null +++ b/haskell/wip/021-amicable_numbers.hs @@ -0,0 +1,31 @@ +-- Amicable numbers +-- +-- Problem 21 +-- Let d(n) be defined as the sum of proper divisors of n +-- (numbers less than n which divide evenly into n). +-- If d(a) = b and d(b) = a, where a ≠ b, then a and b are an amicable +-- pair and each of a and b are called amicable numbers. +-- +-- For example, the proper divisors of 220 are 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 and 110; +-- therefore d(220) = 284. The proper divisors of 284 are 1, 2, 4, 71 and 142; so d(284) = 220. +-- +-- Evaluate the sum of all the amicable numbers under 10000. + + +-- 5s isnt pretty, divSum is probably the root of evil +main = print (sum $ map fst (filterAmicable [2..10000])) + +filterAmicable :: [Int] -> [(Int, Int)] +filterAmicable xs = filter (\(n, s) -> n /= s && any ((==)(s, n)) sums) sums + where sums = [(x, divSum x) | x <- xs] + +divSum :: Int -> Int +divSum n = factorise 2 + where factorise d + | d > nSqrt = 1 + | rest == 0 && d /= quotient = d + quotient + factorise (d + 1) + | rest == 0 && d == quotient = quotient + factorise (d + 1) + | otherwise = factorise (d + 1) + where quotient = n `div` d + rest = n `mod` d + nSqrt = floor $ sqrt $ fromIntegral n diff --git a/haskell/wip/023-non_abundant_sum.hs b/haskell/wip/023-non_abundant_sum.hs new file mode 100644 index 0000000..d519eb6 --- /dev/null +++ b/haskell/wip/023-non_abundant_sum.hs @@ -0,0 +1,57 @@ +-- Non-abundant sums +-- +-- Problem 23 +-- A perfect number is a number for which the sum of its proper divisors is exactly equal +-- to the number. For example, the sum of the proper divisors of 28 would be +-- 1 + 2 + 4 + 7 + 14 = 28, which means that 28 is a perfect number. +-- +-- A number n is called deficient if the sum of its proper divisors is less than n and +-- it is called abundant if this sum exceeds n. +-- +-- As 12 is the smallest abundant number, 1 + 2 + 3 + 4 + 6 = 16, the smallest number +-- that can be written as the sum of two abundant numbers is 24. By mathematical analysis, +-- it can be shown that all integers greater than 28123 can be written as the sum of two +-- abundant numbers. However, this upper limit cannot be reduced any further by analysis +-- even though it is known that the greatest number that cannot be expressed as the sum +-- of two abundant numbers is less than this limit. +-- +-- Find the sum of all the positive integers which cannot be written as the sum of two +-- abundant numbers. + + +import Data.List(nub) + +main = do + -- print (nub [n | n <- [1..28123], a <- abundants, a < n, n - a `notElem` abundants]) + -- print ([n | n <- [1..2812], notAbundantSum n]) + print (length filteredMultiples) + -- print ([n | n <- filteredMultiples, notAbundantSum n]) + -- print (combkk + + + +filteredMultiples = filter (\n -> n `notElem` abundantsMultiples) [1..20161] +abundantsMultiples = [a * x | a <- abundants, x <- [2..1700], a * x < 20161] + +notAbundantSum :: Int -> Bool +notAbundantSum x + | x > 28123= False + | otherwise = findAbSum 0 + where findAbSum i + | curr > x - 12 || i == length abundants = True + | (x - curr) `elem` abundants = False + | otherwise = findAbSum (i + 1) + where curr = abundants !! i + +abundants = [n | n <- [1..28123], divSum n > n] + +divSum :: Int -> Int +divSum n = factorise 2 + where factorise d + | d > nSqrt = 1 + | rest == 0 && d /= quotient = d + quotient + factorise (d + 1) + | rest == 0 && d == quotient = quotient + factorise (d + 1) + | otherwise = factorise (d + 1) + where quotient = n `div` d + rest = n `mod` d + nSqrt = floor $ sqrt $ fromIntegral n diff --git a/haskell/wip/030-digit_fifth_powers.hs b/haskell/wip/030-digit_fifth_powers.hs new file mode 100644 index 0000000..6cc8a49 --- /dev/null +++ b/haskell/wip/030-digit_fifth_powers.hs @@ -0,0 +1,30 @@ +-- Digit fifth powers +-- +-- Problem 30 +-- Surprisingly there are only three numbers that can be written as the sum of fourth +-- powers of their digits: +-- +-- 1634 = 14 + 64 + 34 + 44 +-- 8208 = 84 + 24 + 04 + 84 +-- 9474 = 94 + 44 + 74 + 44 +-- As 1 = 14 is not a sum it is not included. +-- +-- The sum of these numbers is 1634 + 8208 + 9474 = 19316. +-- +-- Find the sum of all the numbers that can be written as the sum of fifth powers of +-- their digits. + + +main = do + print ( [x0 + x1 * 10 + x2 * 100 + x3 * 1000 | + x0 <- [0..9], x1 <- [0..9], x2 <- [0..9], x3 <- [1..9], + (sum $ map (^4) [x0, x1, x2, x3]) + == x0 + x1 * 10 + x2 * 100 + x3 * 1000]) + + print ( [x0 + x1 * 10 + x2 * 100 + x3 * 1000 + x4 * 10000 | + x0 <- [0..9], x1 <- [0..9], x2 <- [0..9], x3 <- [0..9], x4 <- [1..9], + (sum $ map (^5) [x0, x1, x2, x3, x4]) + == x0 + x1 * 10 + x2 * 100 + x3 * 1000 + x4 * 10000]) + +-- allPower :: Int -> [Int] +-- allPower diff --git a/haskell/wip/044-pentagonal_numbers.hs b/haskell/wip/044-pentagonal_numbers.hs new file mode 100644 index 0000000..966cc13 --- /dev/null +++ b/haskell/wip/044-pentagonal_numbers.hs @@ -0,0 +1,19 @@ +-- Pentagonal numbers are generated by the formula, Pn=n(3n−1)/2. +-- The first ten pentagonal numbers are: +-- +-- 1, 5, 12, 22, 35, 51, 70, 92, 117, 145, ... +-- +-- It can be seen that P4 + P7 = 22 + 70 = 92 = P8. However, their difference, +-- 70 − 22 = 48, is not pentagonal. +-- +-- Find the pair of pentagonal numbers, Pj and Pk, for which their sum and difference +-- are pentagonal and D = |Pk − Pj| is minimised; what is the value of D? + + +main = do + -- print (take 10 pentagonals) + let isPentagonal n = n `elem` takeWhile (<=n) pentagonals + pentagonals = [(3 * n ^ 2 - n) `div` 2 | n <- [1..]] + print (head [j + k| k <- pentagonals, j <- pentagonals, + isPentagonal (j + k)]) --, isPentagonal (abs (j - k))]) + diff --git a/python/helper/__pycache__/prime.cpython-37.pyc b/python/helper/__pycache__/prime.cpython-37.pyc deleted file mode 100644 index bf9e3d6..0000000 Binary files a/python/helper/__pycache__/prime.cpython-37.pyc and /dev/null differ diff --git a/python/wip/023-non_abudant_sums.py b/python/wip/023-non_abudant_sums.py new file mode 100644 index 0000000..6e3eea2 --- /dev/null +++ b/python/wip/023-non_abudant_sums.py @@ -0,0 +1,16 @@ +# def getAllDivisorOf(num): +# divisor_list = [] +# for i in range(1, num): +# if num % i == 0: +# divisor_list.append(i) +# return divisor_list + + +# for num in range(1, 28123 + 1): +# pass + +# for i in range(3): +# for j in range(3): +# for k in range(3): +# if i != j and i != k and j != k: +# print(i, j, k) diff --git a/python/wip/026-reciprocal_cycles.py b/python/wip/026-reciprocal_cycles.py new file mode 100644 index 0000000..b502c9a --- /dev/null +++ b/python/wip/026-reciprocal_cycles.py @@ -0,0 +1,5 @@ +from decimal import Decimal + +for i in range(1, 11): + # decimals = int(str(1/i)[2:]) + print(d) diff --git a/python/wip/027-quadratic_primes.py b/python/wip/027-quadratic_primes.py new file mode 100644 index 0000000..8b21cc6 --- /dev/null +++ b/python/wip/027-quadratic_primes.py @@ -0,0 +1,17 @@ +from itertools import count +from helper.prime import is_prime + + +ab_iter = [(a, b) for b in range(1_001) for a in range(1_000)] + +max_product = 0 +max_prime_seq = 0 +for a, b in ab_iter: + for n in count(): + if (not is_prime(n**2 + a*n + b)) and n > max_prime_seq: + max_prime_seq = n + max_product = a * b + print(max_product) + break + + diff --git a/python/wip/031-coin_sums.py b/python/wip/031-coin_sums.py new file mode 100644 index 0000000..c9a823d --- /dev/null +++ b/python/wip/031-coin_sums.py @@ -0,0 +1,12 @@ +coins = [200, 100, 50, 20, 10, 5, 2, 1] + +TOTAL = 200 +coin_index = 0 +combinations = [200] +combination_nb = 1 +while True: + if sum(combinations) == 200: + coin_index += 1 + combinations[0] = coins[coin_index] + + diff --git a/python/wip/037-truncatable_primes.py b/python/wip/037-truncatable_primes.py new file mode 100644 index 0000000..1ad7d29 --- /dev/null +++ b/python/wip/037-truncatable_primes.py @@ -0,0 +1,25 @@ +from helper.prime import primes_loop, is_prime + + +def is_truncatable(prime): + p_str = str(prime) + for i in range(1, len(p_str)): + if not is_prime(int(p_str[i:])): + return False + for i in range(1, len(p_str)): + if not is_prime(int(p_str[:-i])): + return False + if prime in [2, 3, 5, 7]: + return False + return True + + +trunc_p_list = [] +for p in primes_loop(): + if is_truncatable(p): + trunc_p_list.append(p) + if len(trunc_p_list) == 11: + break + +print(trunc_p_list) +print(sum(trunc_p_list)) diff --git a/python/wip/045-triangular_pentagonal_and_hexagonal.py b/python/wip/045-triangular_pentagonal_and_hexagonal.py new file mode 100644 index 0000000..5fba8f8 --- /dev/null +++ b/python/wip/045-triangular_pentagonal_and_hexagonal.py @@ -0,0 +1,9 @@ +from itertools import count +from helper.numbers import triangular, is_pentagonal, is_hexagonal + + +for i in count(286): + t = triangular(i) + if is_pentagonal(t) and is_hexagonal(t): + print(t) + break diff --git a/python/wip/047-distinct_primes_factors.py b/python/wip/047-distinct_primes_factors.py new file mode 100644 index 0000000..ac09b9a --- /dev/null +++ b/python/wip/047-distinct_primes_factors.py @@ -0,0 +1,20 @@ +from itertools import count +from helper.prime import get_prime_factors, primes_loop + +# TROP LENT + +def as_four_distinct_prime_factors(num): + return len(set(get_prime_factors(num))) == 3 + +def check_next_three(num): + for i in range(1, 3): + if not as_four_distinct_prime_factors(num + i): + return False + return True + + +for num in primes_loop(): + if as_four_distinct_prime_factors(num): + if check_next_three(num): + print(num) + break diff --git a/python/wip/049-prime_permutations.py b/python/wip/049-prime_permutations.py new file mode 100644 index 0000000..d90754e --- /dev/null +++ b/python/wip/049-prime_permutations.py @@ -0,0 +1,23 @@ +from itertools import permutations +from helper.prime import is_prime + + +def constant_inscrease(perms): + + + +def get_prime_permutations(nb): + return sorted([ + int(''.join(x)) + for x in permutations(str(nb), 4) + if (is_prime(int(''.join(x))) + and len(str(int(''.join(x)))) == 4) + ]) + +# print(get_prime_permutations(1487)) +for i in range(1000, 10_000): + if not is_prime(i): + continue + print(get_prime_permutations(i)) +# if all([is_prime(p) for p in permutations]): +# print(sorted(permutations)) diff --git a/wip/023-non_abudant_sums.py b/wip/023-non_abudant_sums.py deleted file mode 100644 index 6e3eea2..0000000 --- a/wip/023-non_abudant_sums.py +++ /dev/null @@ -1,16 +0,0 @@ -# def getAllDivisorOf(num): -# divisor_list = [] -# for i in range(1, num): -# if num % i == 0: -# divisor_list.append(i) -# return divisor_list - - -# for num in range(1, 28123 + 1): -# pass - -# for i in range(3): -# for j in range(3): -# for k in range(3): -# if i != j and i != k and j != k: -# print(i, j, k) diff --git a/wip/026-reciprocal_cycles.py b/wip/026-reciprocal_cycles.py deleted file mode 100644 index b502c9a..0000000 --- a/wip/026-reciprocal_cycles.py +++ /dev/null @@ -1,5 +0,0 @@ -from decimal import Decimal - -for i in range(1, 11): - # decimals = int(str(1/i)[2:]) - print(d) diff --git a/wip/027-quadratic_primes.py b/wip/027-quadratic_primes.py deleted file mode 100644 index 8b21cc6..0000000 --- a/wip/027-quadratic_primes.py +++ /dev/null @@ -1,17 +0,0 @@ -from itertools import count -from helper.prime import is_prime - - -ab_iter = [(a, b) for b in range(1_001) for a in range(1_000)] - -max_product = 0 -max_prime_seq = 0 -for a, b in ab_iter: - for n in count(): - if (not is_prime(n**2 + a*n + b)) and n > max_prime_seq: - max_prime_seq = n - max_product = a * b - print(max_product) - break - - diff --git a/wip/031-coin_sums.py b/wip/031-coin_sums.py deleted file mode 100644 index c9a823d..0000000 --- a/wip/031-coin_sums.py +++ /dev/null @@ -1,12 +0,0 @@ -coins = [200, 100, 50, 20, 10, 5, 2, 1] - -TOTAL = 200 -coin_index = 0 -combinations = [200] -combination_nb = 1 -while True: - if sum(combinations) == 200: - coin_index += 1 - combinations[0] = coins[coin_index] - - diff --git a/wip/037-truncatable_primes.py b/wip/037-truncatable_primes.py deleted file mode 100644 index 1ad7d29..0000000 --- a/wip/037-truncatable_primes.py +++ /dev/null @@ -1,25 +0,0 @@ -from helper.prime import primes_loop, is_prime - - -def is_truncatable(prime): - p_str = str(prime) - for i in range(1, len(p_str)): - if not is_prime(int(p_str[i:])): - return False - for i in range(1, len(p_str)): - if not is_prime(int(p_str[:-i])): - return False - if prime in [2, 3, 5, 7]: - return False - return True - - -trunc_p_list = [] -for p in primes_loop(): - if is_truncatable(p): - trunc_p_list.append(p) - if len(trunc_p_list) == 11: - break - -print(trunc_p_list) -print(sum(trunc_p_list)) diff --git a/wip/045-triangular_pentagonal_and_hexagonal.py b/wip/045-triangular_pentagonal_and_hexagonal.py deleted file mode 100644 index 5fba8f8..0000000 --- a/wip/045-triangular_pentagonal_and_hexagonal.py +++ /dev/null @@ -1,9 +0,0 @@ -from itertools import count -from helper.numbers import triangular, is_pentagonal, is_hexagonal - - -for i in count(286): - t = triangular(i) - if is_pentagonal(t) and is_hexagonal(t): - print(t) - break diff --git a/wip/047-distinct_primes_factors.py b/wip/047-distinct_primes_factors.py deleted file mode 100644 index ac09b9a..0000000 --- a/wip/047-distinct_primes_factors.py +++ /dev/null @@ -1,20 +0,0 @@ -from itertools import count -from helper.prime import get_prime_factors, primes_loop - -# TROP LENT - -def as_four_distinct_prime_factors(num): - return len(set(get_prime_factors(num))) == 3 - -def check_next_three(num): - for i in range(1, 3): - if not as_four_distinct_prime_factors(num + i): - return False - return True - - -for num in primes_loop(): - if as_four_distinct_prime_factors(num): - if check_next_three(num): - print(num) - break diff --git a/wip/049-prime_permutations.py b/wip/049-prime_permutations.py deleted file mode 100644 index d90754e..0000000 --- a/wip/049-prime_permutations.py +++ /dev/null @@ -1,23 +0,0 @@ -from itertools import permutations -from helper.prime import is_prime - - -def constant_inscrease(perms): - - - -def get_prime_permutations(nb): - return sorted([ - int(''.join(x)) - for x in permutations(str(nb), 4) - if (is_prime(int(''.join(x))) - and len(str(int(''.join(x)))) == 4) - ]) - -# print(get_prime_permutations(1487)) -for i in range(1000, 10_000): - if not is_prime(i): - continue - print(get_prime_permutations(i)) -# if all([is_prime(p) for p in permutations]): -# print(sorted(permutations)) diff --git a/wip/053-combinatoric-selections.c b/wip/053-combinatoric-selections.c deleted file mode 100644 index 9006f5a..0000000 --- a/wip/053-combinatoric-selections.c +++ /dev/null @@ -1,43 +0,0 @@ -#include -#include - - -typedef long long unsigned int Natural; - -Natural factorial(Natural n) -{ - if (n == 1 || n == 0) return 1; - else return n * factorial(n - 1); -} - -Natural combination(Natural n, Natural r) -{ - if (r > n) exit(1); - Natural num = 0; - /* for (Natural i = 0; i < r - 1; i++) */ - /* num *= n - i; */ - /* return num / factorial(r); */ - /* if (factorial(r) * factorial(n - r) == 0) return 0; */ - return (factorial(n) / (factorial(r) * factorial(n - r))); - /* return (factorial(r) * factorial(n - r)); */ -} - -int main(void) -{ - printf("10! = %llu\n", factorial(10)); - printf("23! = %llu\n", factorial(23)); - printf("(23 - 10)! = %llu\n", factorial(23 - 10)); - int counter = 0; - Natural comb = 0, n, r; - /* for (n = 1; n <= 24; n++) */ - /* for (r = 1; r <= n; r++) { */ - /* comb = combination(n, r); */ - /* if (comb > 1000000) { */ - /* counter++; */ - /* comb = combination(23, 10); */ - printf("%llu C %llu = %llu\n", n, r, comb); - /* } */ - /* } */ - printf("counter = %d", counter); - return 0; -} diff --git a/wip/092-square_digit_chains.c b/wip/092-square_digit_chains.c deleted file mode 100644 index 7029ccd..0000000 --- a/wip/092-square_digit_chains.c +++ /dev/null @@ -1,89 +0,0 @@ -#include -#include -#include - - -int lenHelper(int x) -{ - if (x >= 10000000) return 8; - if (x >= 1000000) return 7; - if (x >= 100000) return 6; - if (x >= 10000) return 5; - if (x >= 1000) return 4; - if (x >= 100) return 3; - if (x >= 10) return 2; - return 1; -} - -int get_digit(int nb, int digit_index) -{ - if (digit_index == 1) - return nb % 10; - - return (int)(nb / pow(10.0, (double)(digit_index-1))) % 10; -} - -int next_iteration(int nb) -{ - int i, sum = 0; - for (i = 0; i < lenHelper(nb); i++) { - sum += pow(get_digit(nb, i), 2); - } - return sum; -} - -bool end_of_square_digit_chain_is_89(int nb) -{ - bool once = false; - int next_nb; - for (int i = 0; i < 10; i++) { - // printf("%d", next_nb); - next_nb = next_iteration(nb); - if (next_nb == 89 || next_nb == 1) { - if (once) { - return next_nb == 89 ? true : false; - } - once = true; - } - nb = next_nb; - } - return false; -} - - -int main(void) -{ - int i, counter = 0; - for (i = 1; i < 10000000; i++) { - // printf("%d\n", i); - if (end_of_square_digit_chain_is_89(i)) - counter++; - if (i % 1000000 == 0) - printf("%d\n", counter); - } - - printf("%d\n", counter); - - return 0; -} - - - -// def end_of_square_digit_chain_is_89(nb): -// once = False -// while True: -// next_nb = sum([int(x)**2 for x in str(nb)]) -// if next_nb == 89 or next_nb == 1: -// if once: -// return True if next_nb == 89 else False -// once = True -// nb = next_nb - -// counter = 0 -// for i in range(1, 10_000_000): -// if end_of_square_digit_chain_is_89(i): -// counter += 1 -// if i % 1000_000 == 0: -// print(counter) -// pass -// print(counter) -- cgit