update a lot

python/18.py

@@ -1,12 +1,11 @@
 
 def trace(pick, triangle):
-    maxi = [0] * (len(triangle[-1]) + 1)
+    path = triangle.pop(0)
-    for line in reversed(triangle):
+    for line in triangle:
-        for i, value in enumerate(line):
+        path = list(map(lambda x: pick(x[0], x[1]) + x[2], zip(path, path[1:], line)))
-            maxi[i] = value + pick(maxi[i], maxi[i + 1])
+    return path[0]
-    return maxi[0]
 
-print(trace(max,[
+print(trace(max,list(reversed([
 [75],
 [95, 64],
 [17, 47, 82],
@@ -21,4 +20,4 @@ print(trace(max,[
 [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]]))
+[ 4, 62, 98, 27, 23,  9, 70, 98, 73, 93, 38, 53, 60,  4, 23]]))))

python/32.py

@@ -16,7 +16,7 @@ def add_type(a, b):
     for x, left in make_permutation(a, '123456789'):
         for y, cmpr in make_permutation(b, left):
             multi = int(x) * int(y)
-            if str(sorted(cmpr)) == str(sorted(str(multi))):
+            if sorted(cmpr) == sorted(str(multi)):
                 s.add(multi)
     return sum(s)
 

python/49.py

@@ -2,7 +2,7 @@
 from tools import number_theory
 
 def same(x, y):
-    return str(sorted(str(x))) == str(sorted(str(y)))
+    return sorted(str(x)) == sorted(str(y))
 
 def search(limit):
     prime = list(filter(lambda x: x > 1487, number_theory.make_prime(limit)))

python/51.py

@@ -1,64 +1,29 @@
-'''
-from string import maketrans, translate
-
-def numbreak(x):
-  out = []
-  while x != 0:
-    out.append(x % 10)
-    x /= 10
-  return set(out)
-
-def numloop(x, a, lis):
-  out = []
-  for i in range(10 - a):
-    tt = maketrans(str(a), str(i + a))
-    tmp = int(translate(str(x), tt))
-    if isp(tmp, lis):
-      out.append(tmp)
-  return out
-
-def isp(x, lis):
-  for i in lis:
-    if x % i == 0:
-      return False
-    if x < i ** 2:
-      break
-  return True
-
-def makeP(x):
-  p = [2]
-  P = [2]
-  n = 3
-  while n < x:
-    for i in p:
-      if n % i == 0:
-        break
-    else:
-      P.append(n)
-    n += 2
-    while n > p[-1] ** 2:
-      p.append(P[len(p)])
-  return P
-
-prime = makeP(100000)
-
-def main():
-  xx = 56003
-  while 1:
-    ss = numbreak(xx)
-    for syn in range(3):
-      if syn in ss:
-        tmp = numloop(xx, syn, prime)
-        if len(tmp) >= 8:
-          print(xx, tmp)
-          return
-    xx += 2
-    while not isp(xx, prime): xx += 2
-
-main()
-'''
 
 from tools import number_theory
 
-prime = list(number_theory.make_prime(1000))
+def trans_num(num):
-print(prime)
+    s_num = str(num)
+    digit = set(s_num)
+    digit.remove(s_num[-1])
+    for d in digit:
+        if d == s_num[0]:
+            yield [int(s_num.replace(d, ch)) for ch in '123456789' if ch != d]
+        else:
+            yield [int(s_num.replace(d, ch)) for ch in '0123456789' if ch != d]
+
+def is_prime(num):
+    for p in range(3, int(num ** 0.5) + 1):
+        if not num % p:
+            return False
+    return True
+
+def search(limit, count):
+    prime = list(filter(lambda x: x > 100000, number_theory.make_prime(limit)))
+    while len(prime):
+        p = prime.pop(0)
+        for l in trans_num(p):
+            pl = list(filter(is_prime, l))
+            if count - 1 <= len(pl):
+                return [p] + pl
+
+print(min(search(200000, 8)))

python/60.py

@@ -29,11 +29,11 @@ prime.remove(5)
 #print len(prime)
 
 dic = {}
-for i in xrange(len(prime)):
+for i in range(len(prime)):
-  if i % (maxx / 10) == 0:
+  if i % (maxx // 10) == 0:
-    print i
+    print(i)
   tmp = set([])
-  for j in xrange(i + 1, len(prime)):
+  for j in range(i + 1, len(prime)):
     aa = int(str(prime[i]) + str(prime[j]))
     bb = int(str(prime[j]) + str(prime[i]))
     if isp(aa, prime) and isp(bb, prime):
@@ -44,7 +44,7 @@ for i in xrange(len(prime)):
   #else:
     #print
 
-print len(dic.keys())
+print(len(dic.keys()))
 
 out = []
 
@@ -73,4 +73,4 @@ for x1 in dic.keys():
               for x5 in both4:
                 out.append([x1, x2, x3, x4, x5])
 
-print sum(sorted(out))
+print(sum(sorted(out)))

python/61.py

@@ -1,73 +1,34 @@
-from math import sqrt, log10
 
-formula = {3:((1,1,0),(2,1),2),
+def gen_num(start, limit, iter_func):
-           5:((3,-1,0),(6,-1),2),
+    value = iter_func(start)
-           6:((2,-1,0),(4,-1),1),
+    while value < limit:
-           7:((5,-3,0),(10,-3),2),
+        yield value
-           8:((3,-2,0),(6,-2),1)}
+        start += 1
+        value = iter_func(start)
 
+def init_nums():
+    funcs = (lambda n: n * (n + 1) // 2, lambda n: n * n, lambda n: n * (3 * n - 1) // 2,
+        lambda n: n * (2 * n - 1), lambda n: n * (5 * n - 3) // 2, lambda n: n * (3 * n - 2))
+    for f in funcs:
+        yield list(filter(lambda x: x > 1000, gen_num(1, 10000, f)))
 
-def poly(x, coef):
+def find(platform, scan, result):
-    out = 0
+    if not scan:
-    for i in coef:
+        if result[-1] % 100 == result[0] // 100:
-        out = x * out + i
+            return result
-    return out
+    else:
+        for shape in scan:
+            for num in platform[int(shape)]:
+                if num // 100 == result[-1] % 100:
+                    get = find(platform, scan.replace(shape, ''), result + [num])
+                    if get:
+                        return get
 
+def search():
+    platform = list(init_nums())
+    for first in platform[-1]:
+        result = find(platform[:-1], '01234', [first])
+        if result:
+            return result
 
-def tt_ori(x, f, fd, flag):
+print(sum(search()))
-    tmp = int(sqrt(flag * x))
-    tmp_ = 0
-    while tmp_ != tmp:
-        tmp_ = tmp
-        tmp -= (poly(tmp, f) - flag * x) / poly(tmp, fd)
-    while poly(tmp, f) - flag * x > 0:
-        tmp -= 1
-    return tmp + 1
-
-def tt(x, num):
-    return tt_ori(x, formula.get(num)[0], formula.get(num)[1], formula.get(num)[2])
-
-def test(x, num):
-    return poly(x, formula.get(num)[0]) / formula.get(num)[2]
-
-def sumri(num, n):
-    out = []
-    tmp = tt(num, n)
-    while test(tmp, n) < num + 100:
-        out.append(tmp)
-        tmp += 1
-    return out
-
-
-def iter(num, lis, end, trap):
-    for i in lis:
-        trynum = sumri(num, i)
-        for j in trynum:
-            tmp = test(j, i)
-            if str(tmp)[2] == '0':
-                continue
-            if len(lis) == 1 and str(tmp)[2:] == end:
-                trap.append((tmp,j,i))
-                total = 0
-                for i in trap:
-                    total += i[0]
-                print total
-                print trap
-                quit()
-            lis_ = lis[:]
-            lis_.remove(i)
-            trap.append((tmp, j,i))
-            iter(tmp % 100 * 100, lis_, end, trap)
-            trap.pop(-1)
-
-def main():
-    for i in xrange(32, 100):
-        tmp = i ** 2
-        if str(tmp)[2] == '0':
-            continue
-        ch = str(tmp)[0:2]
-        iter(tmp % 100 * 100, [3,5,6,7,8], ch, [(tmp,i,4)])
-
-
-main()
-

python/63.py

@@ -1,9 +1,11 @@
-from math import log10
+import math
-total = [1]
+
-for i in xrange(2, 10):
+def gen():
+    yield 1
+    for i in range(2, 10):
         n = 1
-  tmp = log10(i)
+        while int(n * math.log10(i)) + 1 == n:
-  while int(n * tmp) + 1 == n:
+            yield i ** n
-    total.append(i ** n)
             n += 1
-print total
+
+print(len(list(gen())))

python/64.py

@@ -1,29 +1,21 @@
-def div(sq, sub, quo):
-  return (sq ** 0.5 + sub) / quo
-
-
-def cor(x):
-  a = 0
-  b = 1
-  v = 0
-  out = []
-  ab = []
-  while 1:
-    v = int(div(x, a, b))
-    tmp = b * v - a
-    b = (x - tmp ** 2) / b
-    a = tmp
-    ab.append((a,b))
-    out.append(v)
-    num = ab.index((a,b)) + 1
-    if num != len(ab):
-      return (out[:num], out[num:])
 
+'''(sqrt(num) + a) / b'''
 
+def con_frac(num):
+    a, b = 0, 1
+    para = []
+    while b and (a, b) not in para:
+        d = int((num ** 0.5 + a) / b)
+        yield d
+        para.append((a, b))
+        a = b * d - a
+        b = (num - a ** 2) // b
 
+def count(limit):
     total = 0
-for i in xrange(2, 10001):
+    for x in range(2, limit + 1):
-  if int(i ** 0.5) ** 2 != i:
+        if not len(list(con_frac(x))) % 2:
-    if len(cor(i)[1]) % 2:
             total += 1
-print tota
+    return total
+
+print(count(10000))

python/65.py

@@ -1,25 +1,14 @@
-maxx = 99
 
-a = [1] * maxx
+def con2frac(con_list):
-for i in xrange(1, maxx, 3):
+    a, b = 1, 0
-  a[i] = ((i - 1) / 3 + 1) * 2
+    for r in reversed(con_list):
+        a, b = b + a * r, a
+    return a, b
 
-a.reverse()
+def exp_con(limit):
+    exp_list = [1] * limit
+    exp_list[0] = 2
+    exp_list[2::3] = list(range(2, limit // 3 * 2 + 1, 2))
+    return con2frac(exp_list)[0]
 
-
+print(sum(map(lambda x: int(x), str(exp_con(100)))))
-x = [0, 1]
-n = 0
-for i in a:
-  x[n % 2] += i * x[(n + 1) % 2]
-  n += 1
-
-x[n % 2] += 2 * x[(n + 1) % 2]
-
-def sum(x):
-  out = 0
-  while x != 0:
-    out += x %10
-    x /= 10
-  return out
-
-print sum(x[n % 2])

python/66.py

@@ -4,50 +4,31 @@ def issq(x):
         return True
     return False
 
-def div(sq, sub, quo):
+def con_frac(num):
-  return (sq ** 0.5 + sub) / quo
+    a, b = 0, 1
+    para = []
+    while b and (a, b) not in para:
+        d = int((num ** 0.5 + a) / b)
+        yield d
+        para.append((a, b))
+        a = b * d - a
+        b = (num - a ** 2) // b
 
+def con2frac(con_list):
+    a, b = 1, 0
+    for r in reversed(con_list):
+        a, b = b + a * r, a
+    return a, b
 
-def cor(x):
+def solve(d):
-  a = 0
+    x, y = con2frac(list(con_frac(d))[:-1])
-  b = 1
+    if x ** 2 - d * y ** 2 == 1:
-  v = 0
+        return (x, y)
-  out = []
-  ab = []
-  while 1:
-    v = int(div(x, a, b))
-    tmp = b * v - a
-    b = (x - tmp ** 2) / b
-    a = tmp
-    ab.append((a,b))
-    out.append(v)
-    num = ab.index((a,b)) + 1
-    if num != len(ab):
-      return out
-
-
-def pair(lis):
-        a = 1
-        b = lis[0]
-        for i in lis[1:]:
-                a, b = b, b * i + a
-        return (a,b)
-
-def sol(x):
-        if issq(x): return (0, 0)
-        pp = pair(cor(x)[-2::-1])
-        a = pp[0]
-        b = pp[1]
-        if b ** 2 - x * a ** 2 == 1:
-                return (a, b)
     else:
-                return (2 * a * b, b ** 2 + x * a ** 2)
+        return (2 * x * y, x ** 2 + d * y ** 2)
 
-maxx = [0, 0]
+def search(limit):
+    for num in range(2, limit + 1):
+        yield solve(num)[1], num
 
-for i in xrange(2,1001):
+print(max(search(1000))[1])
-        tmp = sol(i)[1]
-        if tmp > maxx[0]:
-                maxx = [tmp, i]
-
-print maxx

python/67.py

@@ -1,44 +1,14 @@
-a = []
 
-ff = open('triangle.txt', 'r')
+def get_file(fn):
-for i in ff.readlines():
+    with open(fn, 'r') as f:
-  tmp = i.split(' ')
+        return list(map(lambda x:
-  for j in xrange(len(tmp)):
+            list(map(lambda x: int(x), x.split(' '))),
-    tmp[j] = int(tmp[j])
+            f.read().strip().split('\n')))
-  a.append(tmp)
-ff.close()
 
+def shortest(pick, triangle):
+    path = triangle.pop(0)
+    for line in triangle:
+        path = list(map(lambda x: pick(x[0], x[1]) + x[2], zip(path, path[1:], line)))
+    return path
 
-path = a[-1][:]
+print(shortest(max, list(reversed(get_file('../resource/triangle.txt')))))
-for i in xrange(len(a) - 2, 0, -1):
-  newpath = []
-  for j in xrange(i + 1):
-    better = max(path[j], path[j + 1])
-    newpath.append(a[i][j] + better)
-  path = newpath
-print max(path) + a[0][0]
-
-
-'''
-path = [[a[0][0], [a[0][0]]]]
-for i in xrange(1, len(a)):
-  newpath = []
-  tmp = path[0][1][:]
-  tmp.append(a[i][0])
-  newpath.append([path[0][0] + a[i][0], tmp])
-  for j in xrange(1, i):
-    flag = (path[j - 1][0] > path[j][0]) and -1 or 0
-    tmp = path[j + flag][1][:]
-    tmp.append(a[i][j])
-    newpath.append([path[j + flag][0] + a[i][j], tmp])
-  tmp = path[i - 1][1][:]
-  tmp.append(a[i][i])
-  newpath.append([path[i - 1][0] + a[i][i], tmp])
-  path = newpath
-
-maxx = [0, 0]
-for i in path:
-  if i[0] > maxx[0]:
-    maxx = i
-print maxx
-'''

python/69.py

@@ -1,51 +1,27 @@
-def makeP(x):
+from tools import number_theory
-  p = [2]
+from functools import reduce
-  P = [2]
+
-  n = 3
+def multi(l):
-  while n < x:
+    return reduce(lambda x, y: x * y, l, 1)
-    for i in p:
+
-      if n % i == 0:
+def phi_rate(l):
-        break
+    return reduce(lambda x, y: x * y / (y - 1), l, 1)
+
+def find_longest(l, )
+
+def calc(limit):
+    prime = list(number_theory.make_prime(int(limit ** 0.5) + 1))
+    result = []
+    for l in range(len(prime)):
+        if multi(prime[:l]) > limit:
+            l -= 1
+            i = 0
+            while True:
+                if multi(prime[i:i + l]) < limit:
+                    result.append((phi_rate(prime[i:i + l]), prime[i:i + l]))
+                    i += 1
                 else:
-      P.append(n)
-    n += 2
-    while p[-1] ** 2 < n:
-      p.append(P[len(p)])
-  return P
-
-prime = makeP(1000)
-
-def factor(x):
-  dic = {}
-  for i in prime:
-    if i ** 2 > x:
                     break
-    if x % i == 0:
+    return max(result)
-      tmp = 0
-      while x % i == 0:
-        tmp += 1
-        x /= i
-      dic.update({i:tmp})
-  if x != 1:
-    dic.update({x:1})
-  return dic
 
-
+print(multi(calc(200000)[1]))
-def phi(x):
-  ff = factor(x)
-  out = 1
-  for i in ff.keys():
-    #print (i - 1) * i ** (ff.get(i) - 1)
-    out *= (i - 1) * i ** (ff.get(i) - 1)
-  return out
-
-
-
-maxx = [0, 0]
-for i in xrange(2, 1000001):
-  if i % 100000 == 0:
-    print i
-  tmp = float(i) / phi(i)
-  if tmp > maxx[0]:
-    maxx = [tmp, i]
-print maxx

python/70.py

@@ -1,54 +1,32 @@
-maxx = 10000000
+from tools import number_theory
+from functools import reduce
 
-def mkp(x):
+def update_factor(num, p, factor):
-  P = [2]
+    count = 0
-  p = [2]
+    while not num % p:
-  n = 3
+        num //= p
-  while n < x:
+        count += 1
-    for i in p:
+    if count:
-      if n % i == 0:
+        factor[p] = count
+    return num
+
+def calc_factor(num, prime):
+    factor = {}
+    for p in prime:
+        if p ** 2 > num:
             break
-    else:
+        num = update_factor(num, p, factor)
-      P.append(n)
+    if num > 1:
-    n += 2
+        factor[num] = 1
-    while n > p[-1] ** 2:
+    return factor
-      p.append(P[len(p)])
-  return P
 
-prime = mkp(2 * maxx ** 0.5)
+def phi(num, prime):
+    return reduce(lambda x, y: x * (y[0] - 1) * y[0] ** (y[1] - 1), calc_factor(num, prime).items(), 1)
 
-p = maxx ** 0.5
+def search(limit):
-pi = 0
+    prime = list(number_theory.make_prime(int(limit ** 0.5) + 1))
-for i in xrange(len(prime)):
+    for x in range(2, limit + 1):
-  if prime[i] > p:
+        if sorted(str(x)) == sorted(str(phi(x, prime))):
-    pi = i
+            print(x, calc_factor(x, prime))
-    break
-q = maxx / p
-qi = 0
 
-nn, dndn = 0, 1
+print(search(100000))
-
-while pi > 1:
-  pi -= 1
-  p = prime[pi]
-  q = maxx / p
-  for i in xrange(len(prime) - 1, pi, -1):
-    if prime[i] < q:
-      qi = i + 1
-      break
-  while qi > pi:
-    qi -= 1
-    q = prime[qi]
-    n = p * q
-    if n > maxx:
-      continue
-    dn = p + q - 1
-    if n * dndn > nn * dn:
-      sn = str(n)
-      sdn = str(n - dn)
-      if sorted(sn) == sorted(sdn):
-        nn = n
-        dndn = dn
-        break
-
-print nn

python/72.py

@@ -1,35 +1,33 @@
-def phi(x, lis):
+from tools import number_theory
-  out = 1
+from functools import reduce
-  for p in lis:
+import time
-    if x % p == 0:
-      k = 0
-      while x % p == 0:
-        k += 1
-        x /= p
-      out *= p ** (k - 1) * (p - 1)
-    if x <= p ** 2:
-      if x == 1:
-        return out
-      return out * (x - 1)
 
-def makep(x):
+def update_factor(num, p, factor):
-  p = [2]
+    count = 0
-  P = [2]
+    while not num % p:
-  n = 3
+        num //= p
-  while n < x:
+        count += 1
-    for i in p:
+    if count:
-      if n % i == 0:
+        factor[p] = count
+    return num
+
+def calc_factor(num, prime):
+    factor = {}
+    for p in prime:
+        if p ** 2 > num:
             break
-    else:
+        num = update_factor(num, p, factor)
-      P.append(n)
+    if num > 1:
-    n += 2
+        factor[num] = 1
-    while n > p[-1] ** 2:
+    return factor
-      p.append(P[len(p)])
-  return P
 
-prime = makep(1010)
+def phi(num, prime):
-total = 0
+    ret = reduce(lambda x, y: x * (y[0] - 1) * y[0] ** (y[1] - 1), calc_factor(num, prime).items(), 1)
-for i in xrange(2, 1000001):
+    return ret
-  total += phi(i, prime)
-print total
 
+def count(limit):
+    prime = list(number_theory.make_prime(int(limit ** 0.5) + 1))
+    return sum(map(lambda x: phi(x, prime), range(2, limit + 1)))
+
+print(count(1000000))
+print(time.process_time())

python/73.py

@@ -1,10 +1,9 @@
-gcd = lambda x, y: y == 0 and x or gcd(y, x % y)
+from tools import number_theory
 
+def deno_count(num):
+    return len(list(filter(lambda x: 1 == number_theory.gcd(num, x), range(num // 3 + 1, num // 2 + num % 2))))
 
-total = 0
+def count(limit):
-for i in xrange(12001):
+    return sum(list(map(lambda x: deno_count(x), range(limit + 1))))
-  for j in xrange(i / 3 + 1, i / 2 + i % 2):
-    if gcd(i, j) == 1:
-      total += 1
 
-print total
+print(count(12000))

python/74.py

@@ -1,38 +1,31 @@
-def mul(x):
-  out = 1
-  while x != 1 and x != 0:
-    out *= x
-    x -= 1
-  return out
-
-def next(x):
-  out = 0
-  while x != 0:
-    out += mul(x % 10)
-    x /= 10
-  return out
 
 
-def make(x):
+def fac_sum(num, fac_map):
-  out = [x]
+    tale = 0
-  while 1:
+    while num:
-    tmp = next(out[-1])
+        tale += fac_map[num % 10]
-    if out.count(tmp):
+        num //= 10
-      return out
+    return tale
-    out.append(tmp)
 
+def fac_update(fac_map, num, target, fac_list, frm_set = set()):
+    s_num = str(sorted(str(num)))
+    if s_num in frm_set:
+        fac_list.append(num)
+        return
+    loop = []
+    shift = num
+    while shift not in loop:
+        loop.append(shift)
+        shift = fac_sum(shift, fac_map)
+    if len(loop) == target:
+        fac_list.append(num)
+        frm_set.add(s_num)
 
-total = []
+def count(limit, target):
-bak = []
+    fac_map = [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]
-for i in xrange(1, 2000):#1000001):
+    tale = []
-  if bak.count(next(i)):
+    for x in range(limit):
-    print i, bak
+        fac_update(fac_map, x, target, tale)
-    total.append([i, next(i)])
+    return tale
-    continue
-  tmp = make(i)
-  if len(tmp) >= 60:
-    print i, tmp
-    total.append(tmp)
-    bak.append(tmp[1])
 
-print total
+print(len(count(1000000, 60)))

python/76.py

@@ -1,21 +1,20 @@
-a = [0, 1, 2]
-dic = {(2, 1): 1}
-maxx = 100
 
-from sys import argv
+def get(x, y, lst, dct):
-if len(argv) > 0:
+    if y < x:
-  maxx = int(argv[1])
+        return dct[(x, y)]
+    return lst[x]
 
-def get(x, y):
+def count(num):
-  if y >= x:
+    lst = [0, 1, 2]
-    return a[x]
+    dct = {(2, 1): 1}
-  return dic.get((x, y))
+    if 3 > num:
+        return lst[num]
+    for x in range(3, num + 1):
+        tale = 0
+        for n in range(1, x):
+            tale += get(x - n, n, lst, dct)
+            dct[(x, n)] = tale
+        lst.append(tale + 1)
+    return lst[num] - 1
 
-for n in xrange(3, maxx + 1):
+print(count(100))
-  tmp = 0
-  for i in xrange(1, n):
-    tmp += get(n - i, i)
-    dic.update({(n, i): tmp})
-  a.append(tmp + 1)
-
-print a[-1] - 1

python/77.py

@@ -1,40 +1,26 @@
-def mkp(x):
+from tools import number_theory
-  P = [2]
+
-  p = [2]
+def get(x, y, lst, dct):
-  n = 3
+    if x > y:
-  while n < x:
+        return dct[(x, y)]
-    for i in p:
+    return lst[x]
-      if n % i == 0:
+
+def count(limit):
+    prime = list(number_theory.make_prime(1000))
+    lst = [0, 0, 1, 1, 1, 2]
+    dct = {(4, 3): 1, (4, 2): 1, (5, 3): 1, (5, 2): 0}
+    num = 5
+    while lst[-1] <= limit:
+        num += 1
+        tale = 0
+        for p in prime:
+            if p > num:
                 break
-    else:
+            tale += get(num - p, p, lst, dct)
-      P.append(n)
+            dct[(num, p)] = tale
-    n += 2
+        if num in prime:
-    while n > p[-1] ** 2:
+            tale += 1
-      p.append(P[len(p)])
+        lst.append(tale)
-  return P
+    return len(lst) - 1
 
-def get(x, y):
+print(count(5000))
-  if x <= y:
-    return a[x]
-  return dic.get((x, y))
-
-maxx = 5000
-
-prime = mkp(10000)
-
-a = [0, 0, 1, 1, 1, 2]
-dic = {(4, 3):1, (4, 2):1, (5, 3):1, (5, 2):0}
-n = 5
-while a[-1] <= maxx:
-  n += 1
-  tmp = 0
-  for i in prime:
-    if i > n:
-      break
-    tmp += get(n - i, i)
-    #print n - i, i, get(n - i, i)
-    dic.update({(n, i):tmp})
-  if n in prime:
-    tmp += 1
-  a.append(tmp)
-print len(a) - 1

python/78.py

@@ -7,13 +7,13 @@ def get(x, y):
     return a[x]
   return dic.get((x, y))
 
-for n in xrange(3, maxx + 1):
+for n in range(3, maxx + 1):
   tmp = 0
-  for i in xrange(1, n):
+  for i in range(1, n):
     tmp += get(n - i, i)
     dic.update({(n, i): tmp})
   a.append(tmp + 1)
 
-for i in xrange(len(a)):
+for i in range(len(a)):
   if a[i] % 10 == 0:
-    print i, a[i]
+    print(i, a[i])

python/79.py

@@ -0,0 +1,14 @@
+
+def get_file(fn):
+    with open(fn, 'r') as f:
+        content = f.readlines()
+        return list(sorted(set(map(lambda x: x.strip()[:2], content)) | \
+                           set(map(lambda x: x.strip()[1:], content)) | \
+                           set(map(lambda x: x.strip()[::2], content))))
+
+def resort(lst):
+    lst = [list(filter(lambda x: x[0] == c, lst)) for c in set(map(lambda x: x[0], lst))]
+    lst.sort(key=lambda x: len(x))
+    return ''.join(list(reversed(list(map(lambda x: x[0][0], lst[1:]))))) + lst[0][0]
+
+print(resort(get_file('../resource/keylog.txt')))

python/87.py

@@ -1,36 +1,22 @@
-def makep(x):
+from tools import number_theory
-  P = [2]
-  p = [2]
-  n = 3
-  while x > n:
-    for i in p:
-      if n % i == 0:
-        break
-    else:
-      P.append(n)
-    n += 2
-    while n > p[-1] ** 2:
-      p.append(P[len(p)])
-  return P
-
-maxx = 50000000
-
-prime = makep(int(maxx ** 0.5))
 
 def make(x, y, z):
     return x ** 2 + y ** 3 + z ** 4
 
-out = set([])
+def count(limit):
-
+    result = set()
+    prime = list(number_theory.make_prime(int(limit ** 0.5) + 1))
     for i in prime:
         for j in prime:
             for k in prime:
-      tmp = make(i, j, k)
+                trns = make(i, j, k)
-      if tmp > maxx:
+                if trns > limit:
                     break
-      out.add(tmp)
+                result.add(trns)
-    if make(i, j, 2) > maxx:
+            if make(i, j, 2) > limit:
                 break
-  if make(i, 2, 2) > maxx:
+        if make(i, 2, 2) > limit:
             break
-print len(out)
+    return result
+
+print(len(count(50000000)))