Improved project structure.

python/e025.py

@@ -0,0 +1,109 @@
+from copy import deepcopy
+from itertools import islice
+
+
+def primes(n):
+    """ Nice way to calculate primes.  Should be fast. """
+    l = range(2, n + 1)
+    _l = []
+    while True:
+        p = l[0]
+        if p * p > n:
+            return _l + l
+        l = [i for i in l if i % p != 0]
+        _l.append(p)
+
+
+def calculate_decimal_places(numerator, denominator):
+    numerator = (numerator - (numerator / denominator) * denominator) * 10
+    digits = []
+    while True:
+        digit = numerator / denominator
+        numerator = (numerator - digit * denominator) * 10
+        digits.append(digit)
+        if digits[-3:] == [0, 0, 0]:
+            raise StopIteration
+        yield digit
+
+
+def has_cycle(decimal_places, n):
+    d = decimal_places
+    return list(islice(d, 0, n)) == list(islice(d, 0, n)) and \
+           list(islice(d, 0, n)) == list(islice(d, 0, n))
+
+
+def f_025_1():
+    """ Second try.  I realized that only primes must be
+    checked.  Therefore, my brute force approach worked. """
+    l = []
+    for d in primes(1000):
+        for i in range(5, 10000):
+            decimal_places = calculate_decimal_places(1, d)
+            if has_cycle(decimal_places, i):
+                l.append((i, d))
+                break
+    print(max(l))
+
+
+def calculate_cycle(numerator, denominator):
+    numerator = (numerator - (numerator / denominator) * denominator) * 10
+    remainders = set([])
+    while True:
+        digit = numerator / denominator
+        remainder = (numerator - digit * denominator)
+        if remainder in remainders:
+            raise StopIteration
+        remainders.add(remainder)
+        numerator = remainder * 10
+        yield digit
+
+
+def f_025_2():
+    """ Understood trick with remembering remainder... """
+    s = [(len(list(calculate_cycle(1, d))), d)
+         for d in range(1, 1001)]
+    print(max(s))
+
+
+def f_025_3():
+    """ Only testing primes... """
+    s = [(len(list(calculate_cycle(1, d))), d)
+         for d in primes(10000)]
+    print(max(s))
+
+
+f_025_3()
+
+
+#print([(find_cycle_count(calculate_decimal_places(1, d)), d)
+#       for d in range(1, 100)])
+
+#print(find_cycle_count(calculate_decimal_places(22, 7)))
+
+#l = []
+#for d in range(1, 1000):
+#    for i in range(5, 1000):
+#        decimal_places = calculate_decimal_places(1, d)
+#        if has_cycle_one_off(decimal_places, i):
+#            l.append((i, d))
+#            break
+#        decimal_places = calculate_decimal_places(1, d)
+#        if has_cycle(decimal_places, i):
+#            l.append((i, d))
+#            break
+
+#def find_cycle_count(decimal_places):
+#    cycles = []
+#    for digit in decimal_places:
+#        new_cycles = []
+#        for cycle in cycles:
+#            digits, length = cycle
+#            if digits[0] == digit:
+#                if len(digits[1:]) == 0:
+#                    return length
+#                new_cycles.append((digits[1:], length))
+#            new_cycles.append((digits + [digit], length + 1))
+#        new_cycles.append(([digit], 1))
+#        cycles = new_cycles
+
+