Project Euler on Python(3) #003 (031~040)

e031.py

"""

영국의 화폐 단위는 파운드(£)와 펜스(p)이고, 동전의 종류는 아래와 같습니다.

    1p, 2p, 5p, 10p, 20p, 50p, £1 (100p), £2 (200p)

이 동전들을 가지고 2파운드를 만드는 방법은 다양할 것입니다. 예를 하나 들면 이렇습니다.

    1×£1 + 1×50p + 2×20p + 1×5p + 1×2p + 3×1p

2파운드를 만드는 서로 다른 방법은 모두 몇가지나 있습니까?"""

def e031():
    coins = (1, 2, 5, 10, 20, 50, 100, 200)
    ways = [1] + [0] * 200
    for coin in coins:
        for i in range(coin, 200 + 1):
            ways[i] += ways[i-coin]

    print(ways[200])
    
%time e031()
#73682
#Wall time: 1 ms

e032.py

"""1부터 n까지의 각 숫자를 한번씩만 써서 만들 수 있는 숫자를 팬디지털(pandigital)이라고 합니다.
예를 들면 15234는 1부터 5의 숫자가 한번씩만 쓰였으므로 1 ~ 5 팬디지털입니다.

7254라는 숫자는 그런 면에서 특이한데, 39 × 186 = 7254 라는 곱셈식을 만들 때 이것이 1 ~ 9 팬디지털이 되기 때문입니다.

이런 식으로 a × b = c 가 1 ~ 9 팬디지털이 되는 모든 c의 합은 얼마입니까?

(참고: 어떤 c는 두 개 이상의 (a, b)쌍에 대응될 수도 있는데, 이런 경우는 하나로 칩니다)"""


def check_pandigital(a, b):
    c = a * b
    d = "%d%d%d" % (a, b, c)
    return "".join(sorted(d)) == "123456789"

def e32():
    s = set()
    for a in range(1,10):
        for b in range(1234,9999):
            if check_pandigital(a, b):
                s.add(a*b)
    for a in range(12, 100):
        for b in range(123,1000):
            if check_pandigital(a, b):
                s.add(a*b)
    print(sum(s))

%time e32()
#45228
#CPU times: user 376 ms, sys: 1.83 ms, total: 378 ms
#Wall time: 380 ms

e033.py

"""분수 49/98에는 재미있는 성질이 있습니다. 수학을 잘 모르는 사람이 분모와 분자에서 9를 각각 지워서 간단히 하려고 49/98 = 4/8 처럼 계산해도 올바른 결과가 됩니다.

이에 비해 30/50 = 3/5 같은 경우는 다소 진부한 예라고 볼 수 있습니다.

위와 같은 성질을 가지면서 '진부하지 않은' 분수는, 값이 1보다 작고 분자와 분모가 2자리 정수인 경우 모두 4개가 있습니다.

이 4개의 분수를 곱해서 약분했을 때 분모는 얼마입니까?"""


from functools import reduce 

def gcd(a, b):
    a,b = (a, b) if a > b else (b, a)
    if a % b == 0:
        return b
    return gcd(b, (a%b))

def getFractionValue(q, d):
    g = gcd(q,d)
    return (q//g, d//g)


def test(n1, n2):
    if n1 % 10 == 0 or n2 % 10 == 0:
        return False
    l1 = [int(x) for x in list(str(n1))]
    l2 = [int(x) for x in list(str(n2))]
    v = getFractionValue(n1, n2)
    for i in l1:
        if i in l2:
            l1.remove(i)
            l2.remove(i)
            v2 = getFractionValue(l1[0], l2[0])
            if v == v2 :
                return True
    return False

def e033():
    answers = []
    for y in range(11,100):
        for x in range(10,y):
            if x < y and  test(x, y):
                answers.append((x, y))

    uppers = [ i[0] for i in answers]
    lowers = [ i[1] for i in answers]

    u = reduce(lambda x,y:x*y, uppers, 1)
    l = reduce(lambda x,y:x*y, lowers, 1)
    g = gcd(u, l)
    print(l/g)
    
%time e033()

#100.0
#CPU times: user 24.7 ms, sys: 612 µs, total: 25.3 ms
#Wall time: 24.9 ms

e034.py

"""숫자 145에는 신기한 성질이 있습니다. 각 자릿수의 팩토리얼(계승)을 더하면  1! + 4! + 5! = 1 + 24 + 120 = 145 처럼 자기 자신이 됩니다.

이렇게 각 자릿수의 팩토리얼을 더하면 자기 자신이 되는 모든 수의 합을 구하세요.

단, 1! = 1 과 2! = 2 의 경우는 덧셈이 아니므로 제외합니다."""

FACTORIALS = [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]
def factorial(n):
    return FACTORIALS[n]

def process(n):
    return n == sum((factorial(int(x)) for x in str(n)))

def e034():
    print(sum([x for x in range(3, 1000000) if process(x)]))
    
%time e034()
#40730
#CPU times: user 3.59 s, sys: 12.2 ms, total: 3.6 s
#Wall time: 3.62 s

e035.py

"""소수 중에서 각 자리의 숫자들을 순환시켜도 여전히 소수인 것을 circular prime이라고 합니다. 예를 들어 197은 971, 719가 모두 소수이므로 여기에 해당합니다.

이런 소수는 100 밑으로 2, 3, 5, 7, 11, 13, 17, 31, 37, 71, 73, 79, 97 처럼 13개가 있습니다.

그러면 1,000,000 밑으로는 모두 몇 개나 있을까요?"""


from math import log10, floor

def prime_sieve(bound):

    sieve = [True] * (bound//2)
    for i in range(3, int(bound**.5)+1, 2):
        if sieve[i//2]:
            sieve[i * i // 2::i] = [False] * ((bound - i * i - 1) // (2 * i) + 1)
    return [2] + [2*i+1 for i in range(1, bound // 2) if sieve[i]]

def e35():
    def check(n):
        k = str(n)
        for c in "024568":
            if c in k:
                return False
        c = int(log10(n))
        l = 10**c
        m = n
        for _ in range(c+1):
            q, r = divmod(m, l)
            m = r * 10 + q
            if m not in s:
                return False
        return True

    s = set(prime_sieve(1000000))
    b = [2,5] + list(filter(check, s))
    print(len(b))

%time e35()

#55
#CPU times: user 109 ms, sys: 4.24 ms, total: 114 ms
#Wall time: 113 ms

e036.py

"""대칭수(palindrome)인 585는 2진수로 나타내도 10010010012가 되어 여전히 대칭수입니다.

10진법과 2진법으로 모두 대칭수인 1,000,000 이하 숫자의 합을 구하세요.

(주의: 첫번째 자리가 0이면 대칭수가 아님)"""


def is_palindrome(n):
    s = str(n)
    return s == s[::-1]

def test(n):
    return is_palindrome(n) and bin(n)[2:] == bin(n)[2:][::-1]
    
def e36():
    r = sum((x for x in range(1, 1000000, 2) if test(x)))
    print(r)
    
%time e36()

#872187
#CPU times: user 566 ms, sys: 2.17 ms, total: 568 ms
#Wall time: 604 ms

e037.py

"""소수 3797에는 왼쪽부터 자리수를 하나씩 없애거나 (3797, 797, 97, 7) 오른쪽부터 없애도 (3797, 379, 37, 3) 모두 소수가 되는 성질이 있습니다.

이런 성질을 가진 소수는 단 11개만이 존재합니다. 이것을 모두 찾아서 합을 구하세요.

(참고: 2, 3, 5, 7은 제외합니다)"""


from math import log10

def rFront(n):
    a = [n]
    while n > 0:
        l = 10**int(log10(n))
        n = n % l
        a.append(n)
    return a[1:-1]

def rRear(n):
    a = [n]
    while n > 0:
        n = n // 10
        a.append(n)
    return a[1:-1]

def memoize(f):
    cache = {}
    def wrapper(a):
        if a in cache:
            return cache[a]
        r = f(a)
        cache[a] = r
        return r
    return wrapper

@memoize
def is_prime(n):
    if n < 2:
        return False
    if n is 2 or n is 3:
        return True
    if n % 2 == 0 or n % 3 == 0:
        return False
    if n < 9:
        return True
    k = 5
    l = n ** 0.5
    while k <= l:
        if n % k == 0 or n % (k+2) == 0:
            return False
        k += 6
    return True


def check(n):
    
    if n % 10 not in (3, 7):
        return False
    
    s = str(n)[1:]
    for c in "02468":
        if c in s:
            return False
        
    if is_prime(n):
        for i in rFront(n):
            if not is_prime(i):
                return False
        for i in rRear(n):
            if not is_prime(i):
                return False
    else:
        return False
    return True

def e37():
    res = []
    a = 11
    c = 0
    while len(res) < 11:
        if check(a):
            res.append(a)
        a += [2, 4][c]
        c = (c + 1) % 2
    print(sum(res))
    
%time e37()
# 748317
# Wall time: 565 ms

e038.py

"""숫자 192에 1, 2, 3을 각각 곱합니다.

192 × 1 = 192
192 × 2 = 384
192 × 3 = 576
곱한 결과를 모두 이어보면 192384576 이고, 이것은 1 ~ 9 팬디지털(pandigital)인 숫자입니다. 
이런 과정을 편의상 '곱해서 이어붙이기'라고 부르기로 합니다. 같은 식으로 9와 (1, 2, 3, 4, 5)를 곱해서 
이어붙이면 918273645 라는 1 ~ 9 팬디지털 숫자를 얻습니다.

어떤 정수와 (1, 2, ... , n)을 곱해서 이어붙였을 때 얻을 수 있는 
가장 큰 아홉자리의 1 ~ 9 팬디지털 숫자는 무엇입니까? (단 n > 1)"""

"""문제 그대로 곱해서 이어붙여가면서 9자리 이상일 때 팬디지털인지 검사한다"""

def test(n):
    s = ""
    for i in range(1, 10):
        s += str(i * n)
        if len(s) >= 9:
            break
    if "".join(sorted(s)) == "123456789":
        return s
    return None

def e038():
    a = []
    print(max(filter(lambda x:x is not None, (test(x) for x in range(1, 100000)))))
    
%time e038()

#932718654
#Wall time: 633 ms

e039.py

"""세 변의 길이가 모두 자연수 {a, b, c}인 직각삼각형의 둘레를 p 로 둘 때, p = 120 을 만족하는 직각삼각형은 아래와 같이 세 개가 있습니다.

{20, 48, 52}, {24, 45, 51}, {30, 40, 50}
1000 이하의 둘레 p에 대해서, 직각삼각형이 가장 많이 만들어지는 p의 값은 얼마입니까?"""

"""
a, b, c 가 삼각형의 변의 길이이고, 중복은 제거하므로 편의상 a < b < c의 관계를 설정하여 
계산량을 줄이고 범위를 쉽게 한 정할 수 있다. 

1 <= a < p / 3
a < b < (p - a) / 2

이 범위 내에서만 검사해도 충분하다.


"""


def check(p):
    s = 0
    for a in range(1, p//3):
        for b in range(a+1, (p-a)//2):
            c = p - a - b
            if c*c == a*a + b*b:
                s += 1
    return (p, s)

from functools import reduce

def e039():
    print(reduce(lambda x,y : x if x[1] > y[1] else y, (check(x) for x in range(1, 1001))))

%time e039()
#(840, 8)
#Wall time: 11.2 s

"""아래와 같이 푸는 방식은 더 빠르다."""

def eu39():

    borderlines = [0] * 1001
    for b in range(1, 501):
        for a in range(1, 501):
            c_square = a**2 + b**2
            c = c_square ** 0.5
            if a+b+c > 1000:
                break
            elif (c == int(c)):
                borderlines[a+b+(int(c))] += 1
    return borderlines.index(max(borderlines))

%time print(eu39())
# 840
# Wall time: 345 ms

e040.py

"""소수점 뒤에 양의 정수를 차례대로 붙여 나가면 아래와 같은 무리수를 만들 수 있습니다.

0.123456789101112131415161718192021...

이 무리수의 소수점 아래 12번째 자리에는 1이 옵니다 (위에서 붉게 표시된 숫자).

소수점 아래 n번째 숫자를 dn이라고 했을 때, 아래 식의 값은 얼마입니까?

d1 × d10 × d100 × d1000 × d10000 × d100000 × d1000000"""

def gen():
    i = 1
    while 1:
        s = str(i)
        for c in s:
            yield c
        i += 1


def e40():
    g = gen()
    point = [10**n for n in range(7)]
    s = 1
    r = 1
    while 1:
        c = int(next(g))
        if s in point:
            r *= c
        s += 1
        if s > 100000:
            print(r)
            break
            
%time e40()
#210
#Wall time: 106 ms