xw_y_am/ProjectEuler
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

update a lot

Browse Source
This commit is contained in:
xw_y_am@rmbp 2017-08-23 17:57:34 +08:00
parent 83308d74e5
commit d19ee31562
22 changed files with 358 additions and 570 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
python/18.py
View File

@ -1,12 +1,11 @@
def trace(pick, triangle): 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], [75],
[95, 64], [95, 64],
[17, 47, 82], [17, 47, 82],
@ -21,4 +20,4 @@ print(trace(max,[
[70, 11, 33, 28, 77, 73, 17, 78, 39, 68, 17, 57], [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], [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], [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]]))))

4
python/2.py
View File

@ -6,12 +6,12 @@ def fibonacci():
a, b = b, a + b a, b = b, a + b
def target_sum(limit, match): def target_sum(limit, match):
total = 0 total = 0
for x in fibonacci(): for x in fibonacci():
if x >= limit: if x >= limit:
break break
if match(x): if match(x):
total += x total += x
return total return total
print(target_sum(4000000, lambda x: not (x & 1))) print(target_sum(4000000, lambda x: not (x & 1)))

2
python/32.py
View File

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

2
python/49.py
View File

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

87
python/51.py
View File

@ -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 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)))

12
python/60.py
View File

@ -29,11 +29,11 @@ prime.remove(5)
#print len(prime) #print len(prime)
dic = {} 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([]) 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])) aa = int(str(prime[i]) + str(prime[j]))
bb = int(str(prime[j]) + str(prime[i])) bb = int(str(prime[j]) + str(prime[i]))
if isp(aa, prime) and isp(bb, prime): if isp(aa, prime) and isp(bb, prime):
@ -44,7 +44,7 @@ for i in xrange(len(prime)):
#else: #else:
#print #print
print len(dic.keys()) print(len(dic.keys()))
out = [] out = []
@ -73,4 +73,4 @@ for x1 in dic.keys():
for x5 in both4: for x5 in both4:
out.append([x1, x2, x3, x4, x5]) out.append([x1, x2, x3, x4, x5])
print sum(sorted(out)) print(sum(sorted(out)))

107
python/61.py
View File

@ -1,73 +1,34 @@
from math import sqrt, log10
def gen_num(start, limit, iter_func):
formula = {3:((1,1,0),(2,1),2), value = iter_func(start)
5:((3,-1,0),(6,-1),2), while value < limit:
6:((2,-1,0),(4,-1),1), yield value
7:((5,-3,0),(10,-3),2), start += 1
8:((3,-2,0),(6,-2),1)} value = iter_func(start)
def init_nums():
def poly(x, coef): funcs = (lambda n: n * (n + 1) // 2, lambda n: n * n, lambda n: n * (3 * n - 1) // 2,
out = 0 lambda n: n * (2 * n - 1), lambda n: n * (5 * n - 3) // 2, lambda n: n * (3 * n - 2))
for i in coef: for f in funcs:
out = x * out + i yield list(filter(lambda x: x > 1000, gen_num(1, 10000, f)))
return out
def find(platform, scan, result):
if not scan:
def tt_ori(x, f, fd, flag): if result[-1] % 100 == result[0] // 100:
tmp = int(sqrt(flag * x)) return result
tmp_ = 0 else:
while tmp_ != tmp: for shape in scan:
tmp_ = tmp for num in platform[int(shape)]:
tmp -= (poly(tmp, f) - flag * x) / poly(tmp, fd) if num // 100 == result[-1] % 100:
while poly(tmp, f) - flag * x > 0: get = find(platform, scan.replace(shape, ''), result + [num])
tmp -= 1 if get:
return tmp + 1 return get
def tt(x, num): def search():
return tt_ori(x, formula.get(num)[0], formula.get(num)[1], formula.get(num)[2]) platform = list(init_nums())
for first in platform[-1]:
def test(x, num): result = find(platform[:-1], '01234', [first])
return poly(x, formula.get(num)[0]) / formula.get(num)[2] if result:
return result
def sumri(num, n):
out = [] print(sum(search()))
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()

20
python/63.py
View File

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

50
python/64.py
View File

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

39
python/65.py
View File

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

75
python/66.py
View File

@ -1,53 +1,34 @@
def issq(x): def issq(x):
sqr = int(x ** 0.5) sqr = int(x ** 0.5)
if sqr ** 2 == x: if sqr ** 2 == x:
return True return True
return False 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 = [] else:
ab = [] return (2 * x * y, x ** 2 + d * y ** 2)
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 search(limit):
for num in range(2, limit + 1):
yield solve(num)[1], num
def pair(lis): print(max(search(1000))[1])
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)
maxx = [0, 0]
for i in xrange(2,1001):
tmp = sol(i)[1]
if tmp > maxx[0]:
maxx = [tmp, i]
print maxx

52
python/67.py
View File

@ -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
'''

78
python/69.py
View File

@ -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)
else:
P.append(n) def find_longest(l, )
n += 2
while p[-1] ** 2 < n: def calc(limit):
p.append(P[len(p)]) prime = list(number_theory.make_prime(int(limit ** 0.5) + 1))
return P result = []
for l in range(len(prime)):
prime = makeP(1000) if multi(prime[:l]) > limit:
l -= 1
def factor(x): i = 0
dic = {} while True:
for i in prime: if multi(prime[i:i + l]) < limit:
if i ** 2 > x: result.append((phi_rate(prime[i:i + l]), prime[i:i + l]))
break i += 1
if x % i == 0: else:
tmp = 0 break
while x % i == 0: return max(result)
tmp += 1
x /= i print(multi(calc(200000)[1]))
dic.update({i:tmp})
if x != 1:
dic.update({x:1})
return dic
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

86
python/70.py
View File

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

62
python/72.py
View File

@ -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
break return num
else:
P.append(n)
n += 2
while n > p[-1] ** 2:
p.append(P[len(p)])
return P
prime = makep(1010) def calc_factor(num, prime):
total = 0 factor = {}
for i in xrange(2, 1000001): for p in prime:
total += phi(i, prime) if p ** 2 > num:
print total break
num = update_factor(num, p, factor)
if num > 1:
factor[num] = 1
return factor
def phi(num, prime):
ret = reduce(lambda x, y: x * (y[0] - 1) * y[0] ** (y[1] - 1), calc_factor(num, prime).items(), 1)
return ret
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())

13
python/73.py
View File

@ -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))

59
python/74.py
View File

@ -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)))

35
python/76.py
View File

@ -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

60
python/77.py
View File

@ -1,40 +1,26 @@
def mkp(x): from tools import number_theory
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
def get(x, y): def get(x, y, lst, dct):
if x <= y: if x > y:
return a[x] return dct[(x, y)]
return dic.get((x, y)) return lst[x]
maxx = 5000 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
tale += get(num - p, p, lst, dct)
dct[(num, p)] = tale
if num in prime:
tale += 1
lst.append(tale)
return len(lst) - 1
prime = mkp(10000) print(count(5000))
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

8
python/78.py
View File

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

14
python/79.py Normal file
View File

@ -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')))

50
python/87.py
View File

@ -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): def make(x, y, z):
return x ** 2 + y ** 3 + z ** 4 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:
trns = make(i, j, k)
if trns > limit:
break
result.add(trns)
if make(i, j, 2) > limit:
break
if make(i, 2, 2) > limit:
break
return result
for i in prime: print(len(count(50000000)))
for j in prime:
for k in prime:
tmp = make(i, j, k)
if tmp > maxx:
break
out.add(tmp)
if make(i, j, 2) > maxx:
break
if make(i, 2, 2) > maxx:
break
print len(out)