def __init__(self, p=Fraction(0), q=Fraction(0), ext=2): self.p = p self.q = q self.ext = ext if is_square(ext): self.p += lsqrt(ext) self.q = 0 while is_square(self.ext): self.ext = lsqrt(self.ext)
def solve(N): solutions = [] for m in range(1,2*lsqrt(lsqrt(N))+4): n = find_n(m, N) solutions.append((m,n, f(m,n))) print(solutions) closest = min(solutions, key=lambda (a,b,z): abs(z-N)) return closest[0]*closest[1]
def find_min_solution(D): y = 1 if(is_square(D)): return None while(True): xsq_candidate = D*(y**2) + 1 if(is_square(xsq_candidate)): return (lsqrt(xsq_candidate), y) y += 1
def factorize_with_eratosthenes(number, primes = None): primes_in_number = [] if not primes: primes = gen_sieve_eratosthenes(lsqrt(number)) for prime in primes: while number % prime == 0: primes_in_number.append(prime) number = number / prime if len(primes_in_number) == 0 or number > primes_in_number[-1]: primes_in_number.append(number) return primes_in_number
def solve(L): solutions = {} for a in range(1, L/4 + 1): if a % 100 == 0: print(a) for b in range(a+1, (L-2*a)/2 + 1): absq = a**2 + b**2 if is_square(absq): c = lsqrt(absq) try: solutions[a + b + c].append((a,b,c)) except KeyError, e: solutions[a + b + c] = [(a,b,c)]
def solve(N): result = 0 #@UnusedVariable perimeter_to_sides = {} for a in range(1, N + 1): for b in range(a, N-a + 1): if is_square(a**2 + b**2): p = perimeter(a, b) if p > N: break c = lsqrt(a**2+b**2) try: perimeter_to_sides[p].append((a,b,c)) except KeyError, e: perimeter_to_sides[p] = [(a,b,c)]
def solve(n): for a in range(0, int(n/2) + 1): asq = a**2 start = max(a+1, n/2 - a) end = n/2 for b in range(start, end + 1): bsq = b**2 csq_candidate = asq + bsq if(is_square(csq_candidate) and csq_candidate > bsq): c = lsqrt(csq_candidate) if((a + b + c) == n): return (a, b, c) return None
def solve(N): primes = sieve_eratosthenes(lsqrt(N)*2) print_sieve_stats(primes) min_frac = N min_number = N for step in range(1, 500): for (p, q) in [(primes[i], primes[i-step]) for i in range(len(primes)-1, step-1, -1)]: for (p_power, q_power) in zip(powers_below(p, N), powers_below(q, N)): n = p_power*q_power if n > N: continue phi = (p_power - p_power/p)*(q_power - q_power/q) if permutation.is_permuted(n, phi): frac = float(n)/phi if frac < min_frac: print(n, p, q, phi, frac, step) min_frac = frac min_number = n return min_number
def perimeter(a, b): c = lsqrt(a**2 + b**2) return a + b + c