def run(): lower_n, lower_d = 0, 1 upper_n, upper_d = 3, 7 i, n, d = 1000000, 0, 0 while i > 0: new_n = upper_n * i // upper_d gcd = euler.gcd(new_n, i) new_lower_n, new_lower_d = new_n // gcd, i // gcd if new_lower_n * lower_d > new_lower_d * lower_n: if new_lower_n * upper_d < new_lower_d * upper_n: lower_n, lower_d = new_lower_n, new_lower_d n = new_n d = i i -= 1 return n // euler.gcd(n, d)
def euler33(): nominators = 1 denominators = 1 for a in range(10, 100): for b in range(a + 1, 100): if a % 10 == 0 and b % 10 == 0: continue value = Decimal(a) / Decimal(b) a_str = str(a) b_str = str(b) a0 = int(a_str[0]) b0 = int(b_str[0]) a1 = int(a_str[1]) b1 = int(b_str[1]) if b0 == 0 or b1 == 0: continue if Decimal(a0) / Decimal(b0) == value and a1 == b1: nominators *= a denominators *= b if Decimal(a0) / Decimal(b1) == value and a1 == b0: nominators *= a denominators *= b if Decimal(a1) / Decimal(b0) == value and a0 == b1: nominators *= a denominators *= b if Decimal(a1) / Decimal(b1) == value and a0 == b0: nominators *= a denominators *= b denominators //= gcd(nominators, denominators) print(denominators)
def intTests( lines ): for i in xrange(len(lines)): if i % 10 ==0: print i for j in xrange(i): if i == j: continue (x1,y1),(x2,y2) = tuple(lines[i]) (u1,v1),(u2,v2) = tuple(lines[j]) dx = x2 - x1 dy = y2 - y1 du = u2 - u1 dv = v2 - v1 if euler.gcd(dx,du) == euler.gcd(dy,dv): print 'parallel',dx,du continue else: pass
def solveb(n): cnt = 0 for item in orcharditer(n): div = euler.gcd(item[0], item[1]) if div > 1 and max(item[0], item[1]) > 0: #print item, div sumitem = (item[0] / div + item[1] / div) if sumitem % 2 == 0: cnt += 1 return cnt * 6 + 6 * n
def solveb( n ): cnt = 0 for item in orcharditer(n): div = euler.gcd(item[0],item[1]) if div > 1 and max(item[0],item[1])>0: #print item, div sumitem = (item[0]/div + item[1]/div) if sumitem%2 == 0: cnt += 1 return cnt*6 + 6*n
def h(n): cnt = 0 for x, y in orcharditer(n): #alt_iter(n): gcd = euler.gcd(x, y) if gcd > 1: xd = x / gcd yd = y / gcd if (xd + yd) % 2 == 0: cnt += 1 return (cnt + n - 1) * 6
def h(n): cnt = 0 for x, y in orcharditer(n):#alt_iter(n): gcd = euler.gcd(x, y) if gcd > 1: xd = x / gcd yd = y / gcd if (xd + yd) % 2 == 0: cnt += 1 return (cnt + n -1) * 6
def countReduced(b, x, y): # Counts reduced fractions x < a / b < y x0 = min(x, y) y0 = max(x, y) assert (x0 <= y0) count = 0 for a in range(1 + int(b * x), int(math.ceil(b * y) + 0.5)): if gcd(a, b) == 1: count += 1 return count
def genPythagorianTriplesWithPerimeter(p): """ returns all pythagorian triples up to perimeter (a + b + c) p """ for m in range(1, int(math.sqrt((p // 2 + 1))) + 1): for n in range(1, min(int(p // (2 * m)) + 1 - m, m)): if ((m - n) % 2 == 1): if (gcd(m, n) == 1): a , b = min(m * m - n * n, 2 * m * n) , max(m * m - n * n, 2 * m * n) c = m * m + n * n if (p % (a + b + c) == 0): k = (p // (a + b + c)) return (a * b * c * (k ** 3))
def getTrueIntersectionPoint(l1, l2): def det(a, b): return a[0] * b[1] - a[1] * b[0] dx = (l1[0][0] - l1[1][0], l2[0][0] - l2[1][0]) dy = (l1[0][1] - l1[1][1], l2[0][1] - l2[1][1]) div = det(dx, dy) if (div == 0): return None d = (det(*l1), det(*l2)) x = det(d, dx), div g = gcd(x[0],x[1]) x = x[0] // g, x[1] // g y = det(d, dy), div g = gcd(y[0],y[1]) y = y[0] // g, y[1] // g if (div < 0): x = -x[0],-x[1] y = -y[0],-y[1] xf = x[0] / x[1] if xf < max(min(l1[0][0], l1[1][0]), min(l2[0][0], l2[1][0])) or \ xf > min(max(l1[0][0], l1[1][0]), max(l2[0][0], l2[1][0])): return None yf = y[0] / y[1] if yf < max(min(l1[0][1], l1[1][1]), min(l2[0][1], l2[1][1])) or \ yf > min(max(l1[0][1], l1[1][1]), max(l2[0][1], l2[1][1])): return None if (xf == l1[0][0] and yf == l1[0][1]) or \ (xf == l1[1][0] and yf == l1[1][1]) or \ (xf == l2[0][0] and yf == l2[0][1]) or \ (xf == l2[1][0] and yf == l2[1][1]): return None return x, y
def unconcealed(p, q, e): """Naive solution (too slow) """ n = p * q phi = (p-1)*(q-1) assert euler.gcd(e, phi) == 1 assert e > 1 assert e < phi cnt = 0 for m in xrange(n): c = (m**e) % n if c == m: cnt += 1 return cnt
def naive_totient(x): if x == 1: return 1 return sum(1 for k in range(1,x) if gcd(x,k) == 1)
def is_same_ratio((a, b, c)): x = e.gcd(a, b) y = e.gcd(b, c) return (b / x == c / y and a / x == b / y)
from euler import gcd print gcd(461952, 116298)
# https://projecteuler.net/problem=73 from euler import gcd from math import ceil from time import time T = time() lower_bound = 1/3 upper_bound = 1/2 count = 0 numerator_of_result = 0 limit = 12000 for d in range(1, limit+1): n = ceil(d*lower_bound) fraction = n/d while fraction < upper_bound: if gcd(n, d) == 1: if lower_bound < fraction < upper_bound: # print(n, d) count += 1 n += 1 fraction = n/d print(count) print("time elapsed:", time() - T)
# -*- coding:utf-8 -*- """Project Euler problem 129""" from euler import gcd def R(k): return int("1"*k) def A(n): k=len(str(n)) mod = R(k)%n while mod!=0: mod = (10*mod+1)%n k+=1 return k n = 1000000 while True: if gcd(n, 10)==1: if A(n)>1000000: break n += 1 print("Answer: " + str(n))
def f(d): return sum(1 if 2 * x < d < 3 * x and gcd(x, d) == 1 else 0 for x in xrange(d // 3, d // 2 + 1))
#!/usr/bin/python from euler import gcd import math UPPER = 12000 assert (int(-3.2) == -3) assert (gcd(32, 12) == 4) assert (gcd(32, 11) == 1) def countReduced(b, x, y): # Counts reduced fractions x < a / b < y x0 = min(x, y) y0 = max(x, y) assert (x0 <= y0) count = 0 for a in range(1 + int(b * x), int(math.ceil(b * y) + 0.5)): if gcd(a, b) == 1: count += 1 return count assert (countReduced(8, 1 / 3, 1 / 2) == 1) assert (countReduced(5, 1 / 3, 1 / 2) == 1) assert (countReduced(7, 1 / 3, 1 / 2) == 1) assert (countReduced(4, 1 / 3, 1 / 2) == 0)
def f(d): return sum(1 if 2*x < d < 3*x and gcd(x, d)==1 else 0 for x in xrange(d//3, d//2+1))
def simplify(self): gcd = euler.gcd(self.numerator,self.denominator) return Fraction(self.numerator/gcd,self.denominator/gcd)
def testGCD3(self): self.assert_( euler.gcd(3,7) == 1 )
def is_same_ratio((a, b, c)): x = e.gcd(a, b) y = e.gcd(b, c) return (b/x == c/y and a/x == b/y)
from numpy import prod from euler import gcd nums = list() dens = list() for i in range(1, 10): for j in range(1, 10): for k in range(i, 10): for l in range(1, 10): a = 10 * i + j b = 10 * k + l frac = a / b if (i != k and j != l and ((frac == i / k and j == l) or (frac == i / l and j == k) or (frac == j / k and i == l) or (frac == j / l and i == k))): #print("{}{}/{}{}".format(i, j, k, l)) nums.append(a) dens.append(b) num = prod(nums) den = prod(dens) print(den / gcd(num, den))
def test_gcd2(self): r = gcd(461952, 116298) self.assertEqual(18, r)
def test_gcd(self): r = gcd(9, 4) self.assertEqual(1, r)
z , m = 1 , 1 for a in range(11,100): if a % 10: for b in range(11 , a): if b % 10: a0 , a1 = divmod(a , 10) b0 , b1 = divmod(b , 10) if (a1 == b0 and b * a0 == a * b1) or (a0 == b1 and b * a1 == a * b0): z *= b m *= a from euler import gcd print m / gcd(z , m)
def fast_unconcealed(p, q, e): # From the "Handbook of applied cryptography", which is on google # books p. 290 a = (1+euler.gcd(e-1, p-1)) b = (1+euler.gcd(e-1, q-1)) return a*b
import euler import sympy def fastA(p): # from http://mathlesstraveled.com/2011/11/17/fun-with-repunit-divisors-more-solutions/ i = 1 x = 1 while 1: x = (10*x +1) % p i += 1 if x == 0: break return i import itertools lst = [] for i in itertools.count(start = 6): #for i in xrange(6, 10000): if sympy.isprime(i): continue if euler.gcd(i, 10) != 1: continue if (i-1)%fastA(i) == 0: lst.append(i) if len(lst) == 25: break print sum(lst)
def testGCD2(self): self.assert_( euler.gcd(18,12) == 6 )
#!/usr/bin/python # coding: UTF-8 """ @author: CaiKnife Smallest multiple Problem 5 2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder. What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20? """ from euler import gcd answer = 1 for i in range(1, 21): answer *= i / gcd(answer, i) print answer
def testGCD1(self): self.assert_( euler.gcd(12,24) == 12 )
# -*- coding:utf-8 -*- """Project Euler problem 129""" from euler import gcd def R(k): return int("1" * k) def A(n): k = len(str(n)) mod = R(k) % n while mod != 0: mod = (10 * mod + 1) % n k += 1 return k n = 1000000 while True: if gcd(n, 10) == 1: if A(n) > 1000000: break n += 1 print("Answer: " + str(n))
from itertools import product from euler import gcd result = [] for d1, d2 in product(xrange(1, 10), xrange(1, 10)): denominator = d1 * 10 + d2 for n1, n2 in product(xrange(1, d1+1), xrange(1, 10)): numerator = n1 * 10 + n2 if numerator >= denominator: break fraction_result = float(numerator) / float(denominator) numerator_digits = [n1, n2] denominator_digits = [d1, d2] common_digits_iter = (digit for digit in numerator_digits if digit in denominator_digits) for common_d in common_digits_iter: numerator_digits.remove(common_d) denominator_digits.remove(common_d) tmp_num = numerator_digits[0] tmp_den = denominator_digits[0] if float(tmp_num) / float(tmp_den) == fraction_result: result.append((tmp_num, tmp_den)) break numerator, denominator = reduce(lambda (n1, d1), (n2, d2): (n1 * n2, d1 * d2), result) print denominator / gcd(numerator, denominator)
def R(k): return (10 ** k - 1) / 9 def A(n): for k in xrange(2, n + 2): if R(k) % n == 0: return k assert 1 == 0 def fastA(p): # from http://mathlesstraveled.com/2011/11/17/fun-with-repunit-divisors-more-solutions/ i = 1 x = 1 while 1: x = (10 * x + 1) % p i += 1 if x == 0: break return i # this is a key to this - k > n (but probably not by much) for i in xrange(10 ** 6, 10 ** 7): if euler.gcd(i, 10) == 1: if fastA(i) > 10 ** 6: print i
def R(k): return (10**k - 1) / 9 def A(n): for k in xrange(2, n + 2): if R(k) % n == 0: return k assert (1 == 0) def fastA(p): # from http://mathlesstraveled.com/2011/11/17/fun-with-repunit-divisors-more-solutions/ i = 1 x = 1 while 1: x = (10 * x + 1) % p i += 1 if x == 0: break return i # this is a key to this - k > n (but probably not by much) for i in xrange(10**6, 10**7): if euler.gcd(i, 10) == 1: if fastA(i) > 10**6: print i
#!/usr/bin/python from math import sqrt import sys from numpy import array, dot from euler import gcd stop = 1500000 triangles = {} for m in xrange(2, int(sqrt(stop / 2)) + 1): for n in xrange(1, m + 1): if (n + m) % 2 == 1 and gcd(n, m) == 1: a = m*m + n*n b = m*m - n*n c = 2*m*n p = a+b+c while p <= stop: triangles[p] = triangles.setdefault(p, 0) + 1 p += a + b + c print len([x for x in triangles.itervalues() if x == 1]) sys.exit(0) # see # http://en.wikipedia.org/wiki/Tree_of_primitive_Pythagorean_triples A = array([1, -2, 2, 2, -1, 2, 2, -2, 3]) B = array([1, 2, 2, 2, 1, 2, 2, 2, 3]) C = array([-1, 2, 2, -2, 1, 2, -2, 2, 3]) A.shape = B.shape = C.shape = (3,3)
#!/usr/bin/env python from euler import gcd n = 50 t = 0 for i in xrange(1, n + 1): for j in xrange(1, n): m = gcd(i, j) t += min(i * m / j, m * (n - j) / i) print t * 2 + n * n * 3
There are exactly four non-trivial examples of this type of fraction, less than one in value, and containing two digits in the numerator and denominator. If the product of these four fractions is given in its lowest common terms, find the value of the denominator. """ from euler import gcd nontrivial_curious_fractions = [] for numerator in range(10, 100): for denominator in range(numerator + 1, 100): assert numerator / denominator < 1 s = set(str(numerator)) & set(str(denominator)) - {'0'} if len(s) == 1: d = s.pop() try: numerator_, denominator_ = int(str(numerator).strip(d)), int( str(denominator).strip(d)) except ValueError: # int('') called due to double digit coincidence continue if numerator * denominator_ == numerator_ * denominator: nontrivial_curious_fractions.append((numerator, denominator)) assert len(nontrivial_curious_fractions) == 4 prod_numerators = prod_denominators = 1 for n, d in nontrivial_curious_fractions: prod_numerators *= n prod_denominators *= d result = prod_denominators // gcd(prod_numerators, prod_denominators)
# https://projecteuler.net/problem=71 from euler import gcd from math import floor from time import time T = time() target = 3/7 result = 0 numerator_of_result = 0 limit = 10**6 for d in range(1, limit+1): numerator = floor(d*target) not_found = True while not_found: if gcd(numerator, d) == 1: not_found = False else: numerator -= 1 fraction = numerator/d if result < fraction < target: result = fraction numerator_of_result = numerator print(numerator_of_result) print("time elapsed:", time() - T)
from euler import gcd from time import time T = time() limit = 1500000 m = 2 wirelengths = [] limit_reached = False while not limit_reached: if m % 2 == 0: start = 1 else: start = 2 for n in range(start, m, 2): if gcd(m, n) == 1: k = 1 L_primitive = 2*m*(m+n) L = k*L_primitive if L > limit and n == start: limit_reached = True while L <= limit: wirelengths.append(L) k += 1 L = k*L_primitive m += 1 once = set()
from euler import primes, gcd, radical N = 120000 ps = primes(N) rad = [0] + [radical(n, ps) for n in range(1, N+1)] ans = 0 relradsorted = sorted(list(range(1, N)),key=lambda x: rad[x]/x) radsorted = sorted(list(range(1, N)),key=lambda x: rad[x]) m = 1000 for c in relradsorted: if rad[c]/c > 1/2: break for a in radsorted: if a > c//2-1: continue if rad[a] > (c/rad[c]): break b = c - a if gcd(a,b) == gcd(a,c) == gcd(b,c) == 1: if rad[a]*rad[b]*rad[c] < c: ans += c print(ans)
def find_es(phi): return (e for e in xrange(2, phi) if euler.gcd(e, phi) == 1)
if istr[1] == jstr[1]: return (int(istr[0]), int(jstr[0])) return (i, j) num = 1 denom = 1 for i in range(11, 100): for j in range(11, 100): if i%10 == 0 and j%10 == 0: continue gcd = euler.gcd(i,j) if gcd == 1: continue a = i / gcd b = j / gcd x, y = simplify(i, j) # no cancellations if x == i and y == j: continue gcd = euler.gcd(x, y) x = x / gcd y = y / gcd
def resiliance(d): return sum(euler.gcd(i, d) == 1 for i in xrange(1, d))
import euler import sympy def fastA(p): # from http://mathlesstraveled.com/2011/11/17/fun-with-repunit-divisors-more-solutions/ i = 1 x = 1 while 1: x = (10 * x + 1) % p i += 1 if x == 0: break return i import itertools lst = [] for i in itertools.count(start=6): #for i in xrange(6, 10000): if sympy.isprime(i): continue if euler.gcd(i, 10) != 1: continue if (i - 1) % fastA(i) == 0: lst.append(i) if len(lst) == 25: break print sum(lst)