import re
 
def word_sum(word):
  word_sum = sum(map(lambda letter: ord(letter)-ord('A')+1, word))
  return word_sum
 
def name_scores_sum(path):
  f = file(path)
  names = f.read()
  names = sorted(re.findall('([A-Z]+)',names))
  sums = map(word_sum,names)
  scores = map(lambda (index,sum): index*sum, enumerate(sums,1))
  return sum(scores)
 
>>> name_scores_sum(path)
871198282

def proper_divisors(n):
  """
  Find all divisors of n by trial division
  """
  divisors = set([1])
  for i in range(2, math.ceil(n ** 0.5)+1):
      if n % i == 0:
        divisors.add(i)
        divisors.add(n/i)
  return divisors
 
def amicable_numbers(n):
  candidates = range(1,n)
  amicables = []
  for a in candidates:
    b = sum(proper_divisors(a))
    if a != b \
        and sum(proper_divisors(a)) == b \
        and sum(proper_divisors(b)) == a:
      amicables.append(a)
      amicables.append(b)
      candidates.remove(b)
  return amicables
 
>>> sum(amicable_numbers(10000))
31626

def print_timing(func):
  def wrapper(*arg):
    t1 = time.time()
    res = func(*arg)
    t2 = time.time()
    print '%s took %0.3f ms' % (func.func_name, (t2-t1)*1000.0)
    return res
  return wrapper

@print_timing
def some_function()
  return "Hi, I'm a function. And I'm gonna get timed!"

# sieve of Eratosthenes
def sieve(n):
  primes = range(2,n)
  x = 0
  while primes[x] < n**0.5:
    # remove all multiples of the current prime from primes
    primes = [y for y in primes if y==primes[x] or y%primes[x]]
    x = x+1
  return primes
 
def get_rotations(x):
  strx = str(x)
  rotations = [strx[i:] + strx[:i] for i in range(len(strx))]
  rotations = map(int,rotations)
  return rotations
 
def all_digits_odd(n):
  n = str(n)
  for digit in n:
    if int(digit) % 2 == 0:
      return False
  return True
 
@print_timing
def num_circular_primes(x):
  primes = sieve(x)
  # optimize: remove all primes with any even digits
  primes = filter(all_digits_odd,primes)
  primes = set(primes)
 
  cprimes = 0
  max_prime = max(primes)
  for p in primes:
    rotations = set(get_rotations(p))
    intersection = primes & rotations
 
    # if all rotations are primes, they are all circular
    if len(intersection) == len(rotations):
      cprimes += len(intersection)
 
    #remove all the rotations from the working set
    primes = primes - rotations
  return cprimes
 
>>> num_circular_primes(1000000)
num_circular_primes took 6531.000 ms
54

triangle = \
"""75
95 64
17 47 82
18 35 87 10
20 04 82 47 65
19 01 23 75 03 34
88 02 77 73 07 63 67
99 65 04 28 06 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 04 68 89 53 67 30 73 16 69 87 40 31
04 62 98 27 23 09 70 98 73 93 38 53 60 04 23"""
 
def get_row_maximal_sums(prow,row):
  """
  Given the previous and current rows, find the sum of
  the maximal path leading to each node of the current row.
  """
  sums = [0]*len(row)
  for index, item in enumerate(row):
    try:
      left_pred = prow[index-1]
    except IndexError:
      # node has no left predecessor
      left_pred = 0
    try:
      right_pred = prow[index]
    except IndexError:
      # node has no right predecessor
      right_pred = 0
    sums[index] = item + max(left_pred,right_pred)
  return sums
 
# process triangle into list of row lists
t = triangle.split("\n")
for i,row in enumerate(t):
  t[i] = map(int,row.split(" "))
 
# problem 18
>>> max(reduce(get_row_maximal_sums,t))
1074
 
# problem 67
>>> max(reduce(get_row_maximal_sums,t))
7273

import math
 
def divisors(n):
  """
  Find all divisors of n by trial division
  """
  divisors = set([1])
  for i in range(1, math.ceil(n ** 0.5)+1):
      if n % i == 0:
        divisors.add(i)
        divisors.add(n/i)
  return divisors
 
class Triangle:
  def __init__(self):
    self.count = 1
    self.sum = 0
  def __iter__(self):
    return self
  def next(self):
    self.sum += self.count
    self.count += 1
    return self.sum
 
def problem12(n):
  t = Triangle()
  while True:
    x = t.next()
    num = len(divisors(x))
    if num > n:
      return x, num
 
>>> problem12(500)
problem12 took 6172.000 ms
(76576500, 576)

from math import factorial
@print_timing
def problem24(n):
  """ 
  Determine the nth lexicographic 
  permutation of 0123456789 
  """
  answer = ""
  digits = [0,1,2,3,4,5,6,7,8,9]
  for i in range(9,-1,-1):
    ifact = factorial(i)
    digit = (n-1) / ifact
    answer += str(digits.pop(digit))
    n = n - (digit * ifact)
  return answer
 
>>> problem24(1000000)
problem24 took 0.000 ms
'2783915460'
>>>

def is_palindrome(x):
  """
  Returns true if the digits of x are the same both backward
  and forward in both base 2 and base 10.
  """
  x10 = str(x)
  x2 = bin(x)[2:]
  return x10 == x10[::-1] and x2 == x2[::-1]
 
# check only odd numbers since even base 2 numbers end in 0
>>> sum(filter(is_palindrome, range(1,1000000,2)))
872187