def run():
start_time = util.now()
found = set()
maximum = 999999
primes = set([p for p in util.primes(maximum, verbose=False)])
for prime in primes:
if prime <= 7:
continue
digits, valid = str(prime), True
for i in range(1, len(digits)):
if not (int(digits[i:]) in primes and int(digits[:-i]) in primes):
valid = False
break
if valid:
found.add(prime)
print('found %s' % prime)
answer = sum(found)
print('answer is: %s' % str(answer))
print('elapsed seconds: %f' % (util.now() - start_time).total_seconds())
def run():
start_time = util.now()
best = set()
max_perimeter = 1000
for perimeter in range(4, max_perimeter):
tried, found = set(), []
for a in range(1, int(perimeter / 2)):
tried.add(a)
for b in range(int((perimeter - a) / 2), a, -1):
if b in tried:
break
c = perimeter - (a + b)
if pow(a, 2) + pow(b, 2) == pow(c, 2):
found.append([a, b, c, perimeter])
if len(found) > len(best):
best = found.copy()
print('found new best of length %d' % len(best))
answer = best
print('answer is: %s' % str(answer))
print('elapsed seconds: %f' % (util.now() - start_time).total_seconds())
def run():
start_time = util.now()
curious, products, factors, answer = [], {'n': 1, 'd': 1}, {}, 1
lower, upper = 11, 99
for numerator in range(lower, upper + 1):
for denominator in range(numerator + 1, upper + 1):
reduced = candidate(numerator, denominator)
if reduced:
n, d = reduced
if n * denominator == numerator * d:
found = {'n': numerator, 'd': denominator}
curious.append(found)
print('found %s' % str(found))
for t in 'nd':
for value in [c[t] for c in curious]:
products[t] *= value
factors[t] = util.find_factors(products[t])
least_denominator_factors = factors['d'].copy()
for factor, power in least_denominator_factors.items():
if factor in factors['n']:
power = max(power - factors['n'][factor], 0)
answer *= pow(factor, power)
print('answer is: %s' % str(answer))
print('elapsed seconds: %f' % (util.now() - start_time).total_seconds())
def run():
start_time = util.now()
answer = sum([f for f in util.fibonacci_sequence(MAX) if not f % 2])
print('answer is: %s' % str(answer))
print('elapsed seconds: %f' % (util.now() - start_time).total_seconds())
def run():
start_time = util.now()
accumulated_factors, product = {}, 1
lower, upper = 1, 20
for x in range(lower, upper + 1):
if x == 1:
continue
for prime in util.primes(maximum_value=x, verbose=False):
unfactored_portion = x
count = 0
while util.is_divisor(prime, unfactored_portion):
count += 1
unfactored_portion /= prime
if count:
accumulated_factors[prime] = max(
count, accumulated_factors.get(prime, 0))
for prime, power in accumulated_factors.items():
product *= pow(prime, power)
answer = product
print('answer is: %s' % str(answer))
print('elapsed seconds: %f' % (util.now() - start_time).total_seconds())
def run():
start_time = util.now()
best, verbose = {'count': 0}, False
primes = set([p for p in util.primes(1000 ** 2, verbose=False)])
largest_prime = max(primes)
for a in range(-999, 1000):
for b in range(-1000, 1001):
quadratic = quadratic_factory(a, b)
n = 0
while quadratic(n) in primes:
n += 1
if verbose:
print('a=%d, b=%d, n=%d' % (a, b, n))
if quadratic(n) > largest_prime:
raise EmptyPrimes('ran out on %d (a=%d, b=%d, n=%d)' % (quadratic(n), a, b, n))
if n > best['count']:
best = {'count': n, 'a': a, 'b': b, 'ab': a * b, 'biggest_prime': quadratic(n - 1)}
answer = best
print('answer is: %s' % str(answer))
print('elapsed seconds: %f' % (util.now() - start_time).total_seconds())
def run():
start_time = util.now()
verbose = True
ceiling, floor, biggest, cache = 999, 100, 1, []
for a in range(ceiling, floor - 1, -1):
inner_floor = max(int(biggest / a), floor)
if a * (a - 1) < biggest:
break
for b in range(a - 1, inner_floor, -1):
product = a * b
if is_palindrome(product):
found = Palindrome(product, a, b)
cache.append(found)
biggest = product if product > biggest else biggest
if verbose:
print('found %s' % str(found))
break
answer = biggest
print('answer is: %s' % str(answer))
print('elapsed seconds: %f' % (util.now() - start_time).total_seconds())
def run():
start_time = util.now()
total, count = 0, 0
maximum = 2000000
for prime in util.primes(maximum, verbose=True):
count += 1
total += prime
answer = {'sum': total, 'count': count}
print('answer is: %s' % str(answer))
print('elapsed seconds: %f' % (util.now() - start_time).total_seconds())
def run():
start_time = util.now()
solutions, coins = [], Coins(0, 0, 0, 0, 0, 0, 0, 0)
verbose = True
goal = 200
def range_upper(coins_so_far, denomination):
"""Get range boundary for a denomination given coins already used."""
return int(
(goal - coins_value(coins_so_far)) / FACE_VALUES[denomination]) + 1
for l2 in range(0, range_upper(coins, 'l2')):
coins = coins._replace(l2=l2)
for l1 in range(0, range_upper(coins, 'l1')):
coins = coins._replace(l1=l1)
for p50 in range(0, range_upper(coins, 'p50')):
coins = coins._replace(p50=p50)
for p20 in range(0, range_upper(coins, 'p20')):
coins = coins._replace(p20=p20)
for p10 in range(0, range_upper(coins, 'p10')):
coins = coins._replace(p10=p10)
for p5 in range(0, range_upper(coins, 'p5')):
coins = coins._replace(p5=p5)
for p2 in range(0, range_upper(coins, 'p2')):
coins = coins._replace(p2=p2)
for p1 in range(0, range_upper(coins, 'p1')):
coins = coins._replace(p1=p1)
if coins_value(coins) == goal:
solutions.append(coins)
if verbose:
print('found %s' % str(coins))
coins = coins._replace(p1=0)
coins = coins._replace(p2=0)
coins = coins._replace(p5=0)
coins = coins._replace(p10=0)
coins = coins._replace(p20=0)
coins = coins._replace(p50=0)
coins = coins._replace(l1=0)
answer = {'count': len(solutions)}
print('answer is: %s' % str(answer))
print('elapsed seconds: %f' % (util.now() - start_time).total_seconds())
def run():
"""Visualize the spiral being unwrapped and laid out flat."""
start_time = util.now()
unique_results = set()
integers = range(2, 101)
for base in integers:
for power in integers:
unique_results.add(base ** power)
answer = len(unique_results)
print('answer is: %s' % str(answer))
print('elapsed seconds: %f' % (util.now() - start_time).total_seconds())
def run():
start_time = util.now()
found = []
for candidate in range(3, 100000):
if candidate == sum([util.factorial(int(d)) for d in str(candidate)]):
found.append(candidate)
print('found %d' % candidate)
answer = sum(found)
print('answer is: %s' % str(answer))
print('elapsed seconds: %f' % (util.now() - start_time).total_seconds())
def run():
"""Visualize the spiral being unwrapped and laid out flat."""
start_time = util.now()
center_value = 1
values = [center_value]
grid_size = 1001
for side_length in range(3, grid_size + 1, 2):
values.extend(next_four_corners(values[-1], side_length))
answer = sum(values)
print('answer is: %s' % str(answer))
print('elapsed seconds: %f' % (util.now() - start_time).total_seconds())
def run():
start_time = util.now()
digits, answer = '', 1
max_needed = 1000000
for i in range(max_needed):
digits += str(i)
if len(digits) > max_needed:
break
for power in range(7):
answer *= int(digits[10**power])
print('answer is: %s' % str(answer))
print('elapsed seconds: %f' % (util.now() - start_time).total_seconds())
def run():
start_time = util.now()
found, count = 0, 0
look_for = 10001
for prime in util.primes(pow(10, 6), verbose=True):
count += 1
if count == look_for:
found = prime
break
answer = found
print('answer is: %d' % answer)
print('elapsed seconds: %f' % (util.now() - start_time).total_seconds())
def run():
start_time = util.now()
found = set()
maximum = 999999
for i in range(1, maximum + 1):
decimal, binary = str(i), bin(i)[2:]
if decimal == decimal[::-1] and binary == binary[::-1]:
found.add(i)
print('found %s (%s)' % (decimal, binary))
answer = sum(found)
print('answer is: %s' % str(answer))
print('elapsed seconds: %f' % (util.now() - start_time).total_seconds())
def run():
start_time = util.now()
max_found = {'number': 0, 'series_max': 0, 'product': 0}
# honestly just brute-forcing these ranges
for number in range(2, 20000):
for series_max in range(20, 1, -1):
product = concatenated_product(number, series_max)
if product < max_found['product']:
break
elif is_nine_pandigital(product):
max_found = {'number': number, 'series_max': series_max, 'product': product}
print('found new maximum: %s' % str(max_found))
answer = max_found
print('answer is: %s' % str(answer))
print('elapsed seconds: %f' % (util.now() - start_time).total_seconds())
def run():
start_time = util.now()
given_number = 600851475143
# given_number = 13195
unsolved_portion, factors = given_number, {}
for prime in util.primes(maximum_value=sqrt(unsolved_portion)):
while util.is_divisor(prime, unsolved_portion):
factors[prime] = factors.get(prime, 0) + 1
unsolved_portion /= prime
if unsolved_portion < prime:
break
if unsolved_portion > 1:
factors[unsolved_portion] = 1
answer = max(factors.keys())
print('answer is: %s' % str(answer))
print('elapsed seconds: %f' % (util.now() - start_time).total_seconds())
def run():
start_time = util.now()
digits = set([str(i) for i in range(1, 10)])
factors_length = int(len(digits) / 2) + 1
verbose = True
solutions = []
for first_length in range(1, int(factors_length / 2) + 1):
second_length = factors_length - first_length
for digits_a in itertools.permutations(digits, first_length):
factor_a = int(''.join([d for d in digits_a]))
for digits_b in itertools.permutations(digits - set(digits_a),
second_length):
factor_b = int(''.join([d for d in digits_b]))
product = factor_a * factor_b
unique_digits = set([d for d in str(product)])
if len(unique_digits) != len(str(product)):
continue
if set([d for d in str(product)
]) == digits - (set(digits_a) | set(digits_b)):
solution = {
'a': factor_a,
'b': factor_b,
'product': product
}
solutions.append(solution)
if verbose:
print('found %s' % str(solution))
answer = {
'count': len(solutions),
'sum_unique_products': sum(set([s['product'] for s in solutions])),
}
print('answer is: %s' % str(answer))
print('elapsed seconds: %f' % (util.now() - start_time).total_seconds())
def run():
start_time = util.now()
found = set()
maximum = 999999
primes = set([p for p in util.primes(maximum, verbose=False)])
for prime in primes:
digits, all_prime = str(prime), True
for i in range(1, len(digits)):
if int(digits[i:] + digits[:i]) not in primes:
all_prime = False
break
if all_prime:
found.add(prime)
print('found %d' % prime)
answer = len(found)
print('answer is: %s' % str(answer))
print('elapsed seconds: %f' % (util.now() - start_time).total_seconds())
def run():
"""Visualize the spiral being unwrapped and laid out flat."""
start_time = util.now()
values = []
verbose = True
power = 5
powers = {str(i): pow(i, power) for i in range(10)}
upper_bound = pow(9, power) * (power + 2)
def sum_power_of_digits(value):
"""Sum each digit of an integer raised to the power."""
return sum([powers[d] for d in str(int(value))])
for i in range(2, upper_bound):
if i == sum_power_of_digits(i):
values.append(i)
if verbose:
print('found %d' % i)
answer = {'count': len(values), 'sum': sum(values)}
print('answer is: %s' % str(answer))
print('elapsed seconds: %f' % (util.now() - start_time).total_seconds())
def run():
start_time = util.now()
words_file = abspath(join(dirname(__file__), '..', 'input', 'p042_words.txt'))
matches, words = set(), []
triangle_numbers = [triangle_number(i) for i in range(1, 100)]
with open(words_file, 'r') as f:
for line in csv.reader(f):
words.extend(line)
for word in words:
value = 0
for letter in word:
value += WEIGHTS[letter]
if value in triangle_numbers:
matches.add(word)
print('found triangle word: %s' % word)
answer = len(matches)
print('answer is: %s' % str(answer))
print('elapsed seconds: %f' % (util.now() - start_time).total_seconds())
def run():
start_time = util.now()
answer = sum([i for i in range(1000) if not (i % 3 and i % 5)])
print('answer is: %s' % str(answer))
print('elapsed seconds: %f' % (util.now() - start_time).total_seconds())