update some & clean eol

python/101.py

@@ -1,30 +1,24 @@
-def poly(x, coef):
+from functools import reduce
-  out = 0
-  for i in coef:
-    out = out * x + i
-  return out
 
+def poly(x, l):
+    return reduce(lambda s, a: x * (s + a), l[:-1], 0) + l[-1]
 
-un = (1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1)
+def gen_item(l):
+    for i in range(1, len(l)):
+        yield poly(i, l)
 
-a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+def gen_lagrange(n, k):
-for i in xrange(len(a)):
+    lst = list(filter(lambda x: x != k, range(n)))
-  a[i] = poly(a[i], un)
+    tale = 1
+    for x in lst:
+        tale *= n - x
+    for x in lst:
+        tale //= k - x
+    return tale
 
-total = 0
+def calc(l):
-for length in xrange(2, len(a) + 1):
+    lst = list(gen_item(l))
-  y = a[:length]
+    for n in range(1, len(l)):
-  n = len(y)
+        yield sum(map(lambda x: x[0] * x[1], zip(lst, [gen_lagrange(n, k) for k in range(n)])))
-  L = 0
-  for k in xrange(n):
-    l = 1
-    for xi in xrange(n):
-      if xi != k:
-        l *= (n - xi)
-    for xi in xrange(n):
-      if xi != k:
-        l /= (k - xi)
-    L += (l * y[k])
-  total += L
 
-print total + 1
+print(sum(calc([1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1])))

python/102.py

@@ -1,26 +1,17 @@
-def pl(p1, p2):
-  return p1[0] * p2[1] - p1[1] * p2[0]
 
-def isit(lis):
+def get_file(fn):
-  if pl(lis[1], lis[0]) * pl(lis[2], lis[0]) > 0:
+    for l in open(fn, 'r'):
-    return False
+        lst = list(map(lambda x: int(x), l.strip().split(',')))
-  if pl(lis[0], lis[1]) * pl(lis[2], lis[1]) > 0:
+        yield ((lst[0], lst[1]), (lst[2], lst[3]), (lst[4], lst[5]),
-    return False
+                (lst[0], lst[1]), (lst[2], lst[3]))
-  if pl(lis[0], lis[2]) * pl(lis[1], lis[2]) > 0:
-    return False
-  return True
 
-def breaknum(lis):
+def pro_multi(p, q):
-  return [[int(lis[0]), int(lis[1])], [int(lis[2]), int(lis[3])], [int(lis[4]), int(lis[5])]]
+    return p[0] * q[1] - p[1] * q[0]
 
+def judge(l):
+    for i in range((len(l) + 1) // 2):
+        if pro_multi(l[i + 1], l[i]) * pro_multi(l[i + 2], l[i]) > 0:
+            return False
+    return True
 
-ff = open('../triangles.txt', 'r')
+print(len(list(filter(judge, get_file('../resource/triangles.txt')))))
-points = ff.readlines()
-ff.close()
-
-
-count = 0
-for i in points:
-  if isit(breaknum(i.split(','))):
-    count += 1
-print count

python/104.py

@@ -1,48 +1,23 @@
-unit = 1000000000
+import math
-bigunit = 1.0e+100
 
-def musq(a, b):
+def num_match(num):
-  bi = []
+    return sorted(str(num)) == sorted('123456789')
-  while b != 0:
-    bi.append(b % 2)
-    b /= 2
-  bi.reverse()
-  out = 1
-  for p in bi:
-    out = out * out
-    if out > bigunit:
-      out /= bigunit
-    if p == 1:
-      out *= a
-      if out > bigunit:
-        out /= bigunit
-  return out
 
+def fibnacci_mod():
+    i, a, b = 0, 0, 1
+    while True:
+        i, a, b = i + 1, b % 1000000000, a + b
+        yield i, a
 
-def fib(x):
+def head_match(k):
-  sq5 = 5 ** 0.5
+    exp = k * math.log10((1 + 5 ** 0.5) / 2) - math.log10(5) / 2
-  oa = musq((1 + sq5) / 2, n)
+    n = 10 ** (8 + exp % 1)
-  return oa / sq5
+    return num_match(str(n)[:9])
 
-n = 0
+def search():
-a, b = 0, 1
+    for k, n in fibnacci_mod():
+        if num_match(n):
+            if head_match(k):
+                return k, n
 
-while 1:
+print(search())
-  a, b = b, a + b
-  a %= unit
-  b %= unit
-  n += 1
-  bit = set('#'.join(str(a)).split('#'))
-  if len(bit) == 9 and (not '0' in bit):
-    try:
-      pre = str(fib(n))
-      if pre == 'inf':
-        break
-    except OverflowError:
-      print n
-      break
-    pre = pre[0] + pre[2:]
-    bitend = set('#'.join(pre[:9]).split('#'))
-    if len(bitend) == 9 and (not '0' in bitend):
-      print n, a, pre[:9]
-      break

python/98.py

@@ -1,115 +1,54 @@
-ff = open('../words.txt', 'r')
-ww = ff.readline()
-ff.close()
 
-longest = 0
+def get_file(fn):
-dic = {}
+    with open(fn, 'r') as f:
-lisw = ww.split(',')
+        return list(map(lambda x: x[1:-1], f.read().split(',')))
-for i in lisw:
-  i = i[1:-1]
-  if len(i) > 2:
-    tmp = '.'.join(i).split('.')
-    tmp = ''.join(sorted(tmp))
-    if tmp in dic.keys():
-      dic.get(tmp).append(i)
-    else:
-      dic.update({tmp:[i]})
 
+def get_pair(lst):
+    for i in range(len(lst) - 1):
+        for j in range(i + 1, len(lst)):
+            yield (lst[i], lst[j])
 
-move = []
+def calc_rearray(pair):
+    def do_iter(para):
+        repeat = {}
+        for ch in para[0]:
+            map_index = para[1].find(ch, repeat.setdefault(ch, 0))
+            yield map_index
+            repeat[ch] = map_index + 1
+    return tuple(do_iter(pair))
 
-dicmove = {}
+def reverse_rearray(map_rearray):
+    def do_iter(para):
+        for i in sorted(para):
+            yield para.index(i)
+    return tuple(do_iter(map_rearray))
 
-def howtomove(a, b):
+def word_rearray(lst):
-  tmp = ''
+    pick = {}
-  for i in a:
+    for item in lst:
-    tmp += str(b.index(i))
+        s_item = ''.join(sorted(item))
-  if dicmove.has_key(tmp):
+        pick.setdefault(s_item, []).append(item)
-    dicmove.get(tmp).append([a, b])
+    result = {}
-  else:
+    while len(pick):
-    dicmove.update({tmp:[[a, b]]})
+        key, value = pick.popitem()
-  return tmp
+        if len(value) > 1:
+            for pair in get_pair(value):
+                map_rearray = calc_rearray(pair)
+                result.setdefault(map_rearray, []).append(pair)
+                result.setdefault(reverse_rearray(map_rearray), []).append(tuple(reversed(pair)))
+    return result
 
-def howtolis(lis):
+def pow_range(digit):
-  out = set([])
+    return int((10 ** (digit // 2)) * ((10 ** 0.5) ** (digit % 2)))
-  for i in lis:
-    for j in lis:
-      if i != j:
-        tmp = howtomove(i, j)
-        out.add(tmp)
-  return list(out)
 
-words = []
+def num_power(digit):
+    return list(map(lambda x: str(x ** 2), range(pow_range(digit - 1), pow_range(digit) + 1)))
 
+def num_rearray(digit):
+    result = []
+    for n in range(3, digit + 1):
+        result.append(word_rearray(num_power(n)))
+    return result
 
-for i in dic.keys():
+print(sorted(word_rearray(get_file('../resource/words.txt')), key=lambda x: len(x)))
-  if len(dic.get(i)) > 1:
+#print(num_rearray(9))
-    wordlen = len(i)
-    while len(move) - 1 < wordlen:
-      move.append([])
-      words.append([])
-    move[wordlen].extend(howtolis(dic.get(i)))
-    words[wordlen].extend(dic.get(i))
-
-#print words
-#print move
-
-def movenum(num, mm):
-  out = ''
-  num = str(num)
-  for i in xrange(len(mm)):
-    try:
-      out += num[int(mm[i])]
-    except IndexError:
-      return 3
-  return int(out)
-
-
-def issq(x):
-  tmp = int(x ** 0.5)
-  if tmp ** 2 == x:
-    return True
-  return False
-
-result = []
-length = len(move[-1][0])
-#print length
-n = int((10 ** length) ** 0.5)
-while length > 1 and n > 0:
-  sq = n ** 2
-  length = len(str(sq))
-  while len(move[length]) <= 0:
-    length -= 1
-    n = int((10 ** length) ** 0.5)
-  for moveit in move[length]:
-    newsq = movenum(sq, moveit)
-    if len(str(sq)) == len(str(newsq)):
-      if issq(newsq):
-        #print sq, newsq
-        result.append([sq, dicmove.get(moveit)[0][0]])
-        #if len(str(result[-1])) != len(str(result[0])):
-          #break
-  n -= 1
-
-#print result
-
-for item in result:
-  nums = str(item[0])
-  dicju1 = {}
-  dicju2 = {}
-  for i in xrange(len(item[1])):
-    numm = nums[i]
-    chh = item[1][i]
-    if numm in dicju1.keys():
-      if chh != dicju1.get(numm):
-        break
-    else:
-      dicju1.update({numm:chh})
-    if chh in dicju2.keys():
-      if numm != dicju2.get(numm):
-        break
-    else:
-      dicju2.update({chh:numm})
-  else:
-    print nums
-    quit()

python/99.py

@@ -1,16 +1,12 @@
-ff = open('../base_exp.txt', 'r')
+import math
-lis = ff.readlines()
-ff.close()
 
-from math import log10
+def search(fn):
+    lst = list(map(lambda x: (int(x[0]), int(x[1])),
+            map(lambda x: x.strip().split(','),
+                open('../resource/base_exp.txt', 'r').readlines()
+            )
+        ))
+    return lst.index(max(lst, key=lambda x: x[1] * math.log(x[0]))) + 1
 
-maxx = [0, 0]
-for i in xrange(len(lis)):
-  tmp = lis[i].split(',')
-  base = int(tmp[0])
-  power = int(tmp[1])
-  loga = power * log10(base)
-  if loga > maxx[0]:
-    maxx = [loga, i + 1]
 
-print maxx
+print(search('../resource/base_exp.txt'))