update some

python/108.py

@@ -1,49 +1,39 @@
-def mkp(n):
+'''
-  P = [2]
+n = p1^k1 * p2^k2 * ... * pn^kn
-  p = [2]
+then the diffrent solve number is ((2k1+1)(2k2+1)...(2kn+1)) / 2
-  x = 3
+'''
-  while len(P) < n:
+import math
-    for i in p:
+from functools import reduce
-      if x % i == 0:
+from tools import number_theory
+
+def updateList(limit, lst):
+    lst[0] = int(limit / reduce(lambda x, y: x * (2 * y + 1), lst[1:], 1) - 0.5) + 1
+    lst[0] = max(lst[:2])
+
+def genList(limit, size):
+    result = []
+    base = [0] + [1] * (size - 1)
+    while True:
+        updateList(limit, base)
+        result.append(tuple(base))
+        if len(set(base)) == 1:
             break
-    else:
+        for i in range(1, size):
-      P.append(x)
+            if base[i] < base[0]:
-    while x > p[-1]**2:
+                base[:i + 1] = [base[i] + 1] * (i + 1)
-      p.append(P[len(p)])
-    x += 2
-  return P
-
-primes = mkp(1000)
-
-def factor(x):
-  out = []
-  for p in primes:
-    if p * p > x:
                 break
-    if x % p == 0:
+    return result
-      count = 0
-      while x % p == 0:
-        x /= p
-        count += 1
-      out.append(count)
-  if x > 1:
-    out.append(1)
-  return out
 
+def search(limit):
+    size_max = int(math.log2(limit))
+    prime = list(number_theory.make_prime(size_max * 2))
+    mini = 2 ** limit
+    for size in range(2, size_max):
+        mini = min(mini, min(
+                map(lambda x: reduce(lambda x, y: x * (y[0] ** y[1]),
+                    zip(prime, x), 1),
+                    genList(limit, size)
+                )))
+    return mini
 
-def sum(x):
+print(search(1000))
-  pre = factor(x)
-  out = 1
-  for i in pre:
-    out *= i * 2 + 1
-  return (out + 1) / 2
-
-
-def maxx(x):
-  n = 4
-  while sum(n) < x:
-    n += 1
-  return n
-
-
-print maxx(1000)

python/109.py

@@ -1,30 +1,17 @@
-from sys import argv
 
+def gen3(lst, d):
+    return [d + lst[i] + lst[j] for i in range(len(lst)) for j in range(i, len(lst))]
 
-limit = int(argv[1])
+def gen2(lst, d):
+    return [d + item for item in lst]
 
-kind = range(1, 21)
+def generate(match):
-kind.extend(range(2, 41, 2))
+    scoreDbl = list(range(2, 41, 2)) + [50]
-kind.extend(range(3, 61, 3))
+    scoreAll = list(range(1, 21)) + list(range(3, 61, 3)) + [25] + scoreDbl
-kind.extend([25, 50])
+    mix = scoreDbl[:]
+    for last in scoreDbl:
+        mix += gen3(scoreAll, last)
+        mix += gen2(scoreAll, last)
+    return list(filter(match, mix))
 
-doub = range(2, 41, 2)
+print(len(generate(lambda x: x < 100)))
-doub.extend([50])
-
-count = 0
-
-for i in doub:
-  if i <= limit:
-    count += 1
-  for j in kind:
-    if i + j <= limit:
-      count += 1
-
-tmp = 0
-for i in doub:
-  for j in xrange(len(kind)):
-    for k in xrange(j, len(kind)):
-      if i + kind[j] + kind[k] <= limit: 
-        tmp += 1
-
-print count + tmp

python/110.py

@@ -1,49 +1,39 @@
-def mkp(n):
+'''
-  P = [2]
+n = p1^k1 * p2^k2 * ... * pn^kn
-  p = [2]
+then the diffrent solve number is ((2k1+1)(2k2+1)...(2kn+1)) / 2
-  x = 3
+'''
-  while len(P) < n:
+import math
-    for i in p:
+from functools import reduce
-      if x % i == 0:
+from tools import number_theory
+
+def updateList(limit, lst):
+    lst[0] = int(limit / reduce(lambda x, y: x * (2 * y + 1), lst[1:], 1) - 0.5) + 1
+    lst[0] = max(lst[:2])
+
+def genList(limit, size):
+    result = []
+    base = [0] + [1] * (size - 1)
+    while True:
+        updateList(limit, base)
+        result.append(tuple(base))
+        if len(set(base)) == 1:
             break
-    else:
+        for i in range(1, size):
-      P.append(x)
+            if base[i] < base[0]:
-    while x > p[-1]**2:
+                base[:i + 1] = [base[i] + 1] * (i + 1)
-      p.append(P[len(p)])
-    x += 2
-  return P
-
-primes = mkp(1000)
-
-def factor(x):
-  out = []
-  for p in primes:
-    if p * p > x:
                 break
-    if x % p == 0:
+    return result
-      count = 0
-      while x % p == 0:
-        x /= p
-        count += 1
-      out.append(count)
-  if x > 1:
-    out.append(1)
-  return out
 
+def search(limit):
+    size_max = int(math.log2(limit))
+    prime = list(number_theory.make_prime(size_max * 2))
+    mini = 2 ** limit
+    for size in range(2, size_max):
+        mini = min(mini, min(
+                map(lambda x: reduce(lambda x, y: x * (y[0] ** y[1]),
+                    zip(prime, x), 1),
+                    genList(limit, size)
+                )))
+    return mini
 
-def sum(x):
+print(search(4000000))
-  pre = factor(x)
-  out = 1
-  for i in pre:
-    out *= i * 2 + 1
-  return (out + 1) / 2
-
-
-def maxx(x):
-  n = 4
-  while sum(n) < x:
-    n += 1
-  return n
-
-
-print maxx(100000)

python/119.py

@@ -1,29 +1,34 @@
-def ala(x):
+'''search order:
-  tmp = 0
-  while x != 0:
-    tmp += x % 10
-    x /= 10
-  return tmp
 
-def ist(x, i):
+number   2**1   2**2   2**3   2**4   2**5   2**6   2**7 ...
-  if i == 1:
-    return False
-  if x < 10:
-    return False
-  while x != 1:
-    if x % i != 0:
-      return False
-    x /= i
-  return True
 
-n = 2
+exp           2  /   2  /   2  /   2  /   2  /   2
-count = []
+             ---/ /----/ /----/ /----/ /----/
-while n < 100:
+              3  /   3  /   3  /   3  /   3
-  for i in xrange(100):
+             ---/ /----/ /----/ /----/
-    tmp = n ** i
+              4  /   4  /   4  /   4
-    if ist(tmp, ala(tmp)):
+             ---/ /----/ /----/
-      if count.count(tmp) == 0:
+              5  /   5  /   5
-        count.append(tmp)
+             ---/ /----/
-        count.sort()
+              6  /   6
-  n += 1
+             ---/
-print count[29]
+              7
+'''
+
+def test(find, base, exp, flag):
+    num = base ** exp
+    if sum(map(lambda x: int(x), str(num))) == base:
+        find.append(num)
+
+def expand(limit):
+    find = []
+    exp = 3
+    while len(find) < limit:
+        for e in range(2, exp):
+            start = 2 ** (exp - e)
+            for num in range(start, 2 * start):
+                test(find, num, e, exp)
+        exp += 1
+    return find
+
+print(expand(30))

python/162.py

@@ -1,25 +1,26 @@
-def frag(x):
-  out = []
-  for i in xrange(1, x - 1):
-    for j in xrange(1, x - i):
-      out.append((i, j, x - i - j))
-  return out
 
-def C(n, m):
+from functools import reduce
-  total = 1
-  for i in xrange(n, n - m, -1):
-    total *= i
-  for i in xrange(m, 1, -1):
-    total /= i
-  return total
 
+def conbine(n, m):
+    return reduce(lambda x, y: x // y, range(m, 1, -1),
+            reduce(lambda x, y: x * y, range(n, n - m, -1), 1))
+
+def gen_array(length):
+    for i in range(1, length - 1):
+        for j in range(1, length - i):
+            yield i, j, length - i - j
+
+def calc(limit):
     total = 0
+    for length in range(3, limit + 1):
+        for same in range(3, length + 1):
+            total += sum(map(lambda x:
+                            conbine(length - 1   , x[0]) *
+                            conbine(length - x[0], x[1]) *
+                            conbine(length - x[0] - x[1], x[2]) *
+                            (limit - 3) ** (length - same),
+                            gen_array(same)
+                        ))
+    return hex(total).upper()[2:]
 
-for length in xrange(3, 17):
+print(calc(16))
-  for same in xrange(3, length + 1):
-    for (x,y,z) in frag(same):
-      total += C(length - 1, x) * C(length - x, y) * C(length
-          - x - y, z) * 13 ** (length - same)
-print '%X' % total
-
-

python/88.1.py

@@ -0,0 +1,30 @@
+
+from functools import reduce
+
+def calc(k):
+    eq = []
+    not_one = 2     # how many numbers that != 1
+    while True:
+        lst = [2] * not_one
+        while True:
+            diff = sum(lst) + (k - not_one) - reduce(lambda x, y: x * y, lst, 1)
+            if not diff:
+                eq.append((sum(lst) + k - not_one, lst))
+                break
+            elif diff > 0:
+                lst[0] += 1
+                continue
+            for i in range(1, len(lst)):
+                if lst[i] != lst[0]:
+                    lst[:i + 1] = [lst[i] + 1] * (i + 1)
+                    break
+            else:
+                break
+        not_one += 1
+        if 2 ** not_one > 2 * not_one + k - not_one:
+            break
+    print(k, len(eq), min(eq))
+    return min(eq)
+
+lll = list(map(lambda x: calc(x), range(2, 12)))
+print(sum(map(lambda x: x[0], lll)))

python/88.py

@@ -1,50 +0,0 @@
-
-from functools import reduce
-
-class Num:
-    n = 0
-    l = []
-    over = False
-
-    def __init__(self, limit):
-        if limit < 2:
-            self.over = True
-        self.num = limit
-        self.l = [1] * limit
-        self.l[:2] = [2, 2]
-
-    def multi(self):
-        return reduce(lambda x, y: x * y, self.l, 1)
-
-    def add(self):
-        return sum(self.l)
-
-    def is_overload(self):
-        return self.multi() > self.add()
-
-    def inc(self):
-        if self.over:
-            return
-        if not self.is_overload():
-            self.l[0] += 1
-        else:
-            for i in range(len(self.l)):
-                if self.l[i + 1] < self.l[i]:
-                    self.l[i + 1] += 1
-                    self.l[:i] = [self.l[i + 1]] * (i + 1)
-                    if self.is_overload():
-                        self.over = True
-
-    def eq(self):
-        return self.multi() == self.add()
-
-    def get_min(self):
-        while not self.eq():
-            self.inc()
-            if self.over:
-                return NULL
-        return self.add()
-
-for x in range(3, 20):
-    f = Num(x)
-    print(x, f.get_min())