def solve(): c,m = 0,0 while c < N: m += 1 for a in xrange(2,2*m+1): if is_square(a*a + m*m): c += (m + m + 2 - a)//2 if a > m+1 else a//2 return m,c
def gen_integral_almost_equilateral_triangles(max_x, limit): for x in range(2, max_x): a = 4 * x * x * x * x - (2 * x * x - (x - 1) * (x - 1)) * \ (2 * x * x - (x - 1) * (x - 1)) if a % 16 == 0: if is_square(a / 16): perimeter = 3 * x - 1 if perimeter <= limit: yield perimeter a = 4 * x * x * x * x - (2 * x * x - (x + 1) * (x + 1)) * \ (2 * x * x - (x + 1) * (x + 1)) if a % 16 == 0: if is_square(a / 16): perimeter = 3 * x + 1 if perimeter <= limit: yield perimeter
def rectilinear_shape(population): try: pos = population.positions except Exception, e: LOGGER.warning(("Could not retrieve units positions for population " "%s; assuming square shape."), population.label) if not is_square(population.size): raise TypeError(("The shape population %s is not square and could " "neither be retreived nor guessed."), population.label) dim1 = dim2 = int(math.sqrt(population.size))
def main(): cnt = 0 for a in count(1): for s in range(2, 2 * a + 1): if is_square(a * a + s * s): cnt += min(s, a + 1) - (s + 1) // 2 if cnt > 1_000_000: return a
def conjecture_correct(current_odd): for i in xrange(1, current_odd - 1): if not is_prime_c(i): continue r = current_odd - i if not is_even(r): continue r /= 2 if is_square(r): #print "%d = %d + 2 * %d" % (current_odd, i, r) return True return False
def continued_fraction(n): if is_square(n): return [int(n**0.5)] num = 0 denom = 1 rep = [] while True: m = int((n**0.5 + num) / denom) rep.append(m) if m == 2 * int(n**0.5): return rep num, denom = denom * m - num, (n - (num - denom * m)**2) / denom
def decrypt(self, criptotext): message = "" for c in criptotext: punto, x = c s = (pow(punto[0], 3) + self.curve.A*punto[0] + self.curve.B) % self.curve.p while not is_square(s): s += self.curve.p raiz = int(math.sqrt(s)) if punto[1]==1: raiz *= -1 pt_desc = ec.scalar_multiplication((punto[0], raiz), self.s, self.curve) valorFinal = (x * modinv(pt_desc[0]%self.curve.p, self.curve.p)) % self.p message += self.alphabet[valorFinal] return message
def convergents(number): if is_square(number): return number ** 0.5 m, d, a = 0, 1, int(number ** 0.5) a0 = a history = [] yield a while a != 2 * a0 or (m, d, a) not in history: history.append((m, d, a)) m = int(d * a - m) d = int((number - m * m) / d) a = int((a0 + m) / d) yield a
def convergents(number): if is_square(number): return number**0.5 m, d, a = 0, 1, int(number**0.5) a0 = a history = [] yield a while a != 2 * a0 or (m, d, a) not in history: history.append((m, d, a)) m = int(d * a - m) d = int((number - m * m) / d) a = int((a0 + m) / d) yield a
def num_type(n): types = list() if utils.is_triangle(n): types.append('A') if utils.is_square(n): types.append('B') if utils.is_pentagonal(n): types.append('C') if utils.is_hexagonal(n): types.append('D') if utils.is_heptagonal(n): types.append('E') if utils.is_octagonal(n): types.append('F') return types
def cal_len(n): if utils.is_square(n): return 0 h = dict() cnt = 0 s = utils.FracWithSqrt(0, 1, 1, n) while True: cnt += 1 rem = s.minus_int(int(s.get_exact())) if rem.get_val() not in h: h[rem.get_val()] = cnt else: return cnt - h[rem.get_val()] s = rem.reciprocal() return None
def find(n): if utils.is_square(n): return None s = utils.FracWithSqrt(0, 1, 1, n) a_i = list() while True: a_i.append(int(s.get_exact())) cur = utils.FracWithSqrt(a_i[-1], 0, 1, 0) for a in a_i[::-1][1:]: cur = cur.reciprocal().minus_int(-a) x, _, y = cur.get_val() if x * x - n * y * y == 1: return x rem = s.minus_int(a_i[-1]) s = rem.reciprocal() return None
def __init__(self, init_params, xform, num_frames=12): random.seed(RANDOM_SEED) self.gen_id = str(uuid4())[:18] self.xform = xform self.num_frames = num_frames self.init_params = init_params assert utils.is_square(self.xform) assert len(self.init_params) == len(self.xform) print("calc params") self.params = self.gen_params() print("calc seeds") self.seeds = self.gen_seeds() print(f"calc frames {self.gen_id}") self.frames = self.gen_frames()
def run(): """ Solution: We observe that since a triangle number is given by x = n(n+1)/2, 8*x + 1 = 4n(n+1) + 1 = 4n^2 + 4n + 1 = (2n + 1)^2 which is a perfect square. So to test for whether a number is a triangle number, we test if 8x + 1 is a perfect square. """ words = read_file("data/p042 words.txt") count = 0 for word in words: n = sum(map(lambda s: alphabet[s], word.lower())) if is_square(8 * n + 1): count += 1 return count
squares = defaultdict(list) for n in range(1, 1000): x = n**2 squares[generalize(str(x))].append(x) words = defaultdict(list) with open("./p098_words.txt") as f: for word in f.read().split(","): word = word[1:-1] words["".join(sorted(word))].append(word) words = {k: l for k, l in words.items() if len(l) > 1} res = 0 for word_chain in words.values(): for a in word_chain: for b in word_chain: if a == b: continue if generalize(a) in squares: for n in squares[generalize(a)]: if len(a) != len(str(n)): continue mapping = {c: d for c, d in zip(a, str(n))} m = int("".join(mapping[c] for c in b)) if is_square(m) and len(str(m)) == len(b): res = max(res, n, m) print res
def refutes(i): for p in PRIMES: if is_square((i - p) / 2): return False return True
# Odd period square roots from utils import is_square def continued_fraction(n): m = 0 d = 1 a = a0 = int(n**0.5) expansion = [a0] while a != 2 * a0: m = d * a - m d = (n - m**2) / d a = (a0 + m) / d expansion.append(a) return expansion max_N = 10000 n = 0 for i in range(max_N + 1): if is_square(i): continue e = continued_fraction(i) if len(e) % 2 == 0: n += 1 print n
def continous_fraction(sequence): if len(sequence) == 1: return sequence.pop() else: return Fraction(sequence.pop(0) + Fraction(1, continous_fraction(sequence))) # VARIABLES largest_x = 0 d_answer = 0 timer.start() for D in range(2, 1001): # skip perfect squares if is_square(D): continue # init variables it = convergents(D) expansion = [] expansion.append(next(it)) # compute continous fraction and test it against Pell's equation. # keep expanding until a solution is found while True: frac = continous_fraction(expansion.copy()) if frac.numerator ** 2 - D * frac.denominator ** 2 == 1: if frac.numerator > largest_x: largest_x = frac.numerator d_answer = D break
def test_is_square(self): self.assertTrue(is_square(4)) self.assertFalse(is_square(8)) x = 12345678987654321234567**2 self.assertTrue(is_square(x)) self.assertFalse(is_square(x + 2))
from utils import is_square from decimal import Decimal, getcontext getcontext().prec = 120 res = 0 for n in range(1, 101): if is_square(n): continue root = Decimal(n)**Decimal(0.5) res += sum(int(d) for d in str(root).replace(".", "")[:100]) print(res)
sqr_list = set() i = 1 while i * i < RANGE: sqr_list.add(i * i) i += 1 ans = 0 for p in pairs: for s in sqr_list: if len(p[0]) == len(str(s)): c2d = dict() d2c = dict() match = True for c, d in zip(p[0], str(s)): if c not in c2d: c2d[c] = d elif c2d[c] != d: match = False break if d not in d2c: d2c[d] = c elif d2c[d] != c: match = False break if match: n2 = int(''.join([c2d[c] for c in p[1]])) if len(str(s)) == len(str(n2)) and utils.is_square(n2): ans = max(ans, max(s, n2)) print(ans)
from fractions import gcd from utils import is_square limit = 10**12 res = set() for a in range(2, 10**4): for b in range(1, min(a, limit / a**3)): if gcd(a, b) > 1: continue for c in range(1, int((limit // a**3 // b)**0.5)): n = a**3 * b * c * c + c * b**2 if is_square(n): res.add(n) print sum(res)
from utils import is_square limit = 10**6 cur = 0 m = 2 while cur <= limit: m += 1 for ab in range(3, 2*m): if is_square(ab*ab + m*m): cur += min(ab, m+1) - (ab+1)//2 print m
""" Created on Mon Apr 24 15:59:39 2018 @author: lamwa """ import utils SUP = 10**12 def f(a, x, y): return a * a * x * x * x * y + a * y * y ans_set = set() x = 2 while f(1, x, 1) < SUP: y = 1 while y < x and f(1, x, y) < SUP: a = 1 while f(a, x, y) < SUP: ns = f(a, x, y) if utils.is_square(ns): ans_set.add(ns) a += 1 y += 1 x += 1 ans = sum(ans_set) print(ans)
from utils import is_square def combs(x, y, z): return (x + y, x - y, x + z, x - z, y + z, y - z) l = 1000 for i in range(1, l): e = i * i for j in range(i + 1, l): c = j * j if not is_square(c - e): continue off = 2 - i % 2 for k in range(j + off, int((c + e)**0.5) + 1, 2): a = k * k if all(is_square(x) for x in (a - c, a - e, c - e)): print(a + c + e) / 2
if len(sequence) == 1: return sequence.pop() else: return Fraction( sequence.pop(0) + Fraction(1, continous_fraction(sequence))) # VARIABLES largest_x = 0 d_answer = 0 timer.start() for D in range(2, 1001): # skip perfect squares if is_square(D): continue # init variables it = convergents(D) expansion = [] expansion.append(next(it)) # compute continous fraction and test it against Pell's equation. # keep expanding until a solution is found while True: frac = continous_fraction(expansion.copy()) if frac.numerator**2 - D * frac.denominator**2 == 1: if frac.numerator > largest_x: largest_x = frac.numerator d_answer = D break
def test_is_square(self): self.assertTrue(is_square(4)) self.assertFalse(is_square(8)) x = 12345678987654321234567 ** 2 self.assertTrue(is_square(x)) self.assertFalse(is_square(x + 2))
def fracs(x): first, l = get_period(x) n = 0 d = 1 for a in period_to_generator(l): n += a * d g = gcd(d, n) d, n = n / g, d / g yield first * d + n, d def find_solution(D): for x, y in fracs(D): if x ** 2 - D * y ** 2 == 1: return x, y m = 0 best = 0 for D in range(1001): if not is_square(D): x, y = find_solution(D) print D, x, y if x > m: best = D m = x print m, best # # print find_solution(61)
from utils import is_square pos = 15 res = [] for l in range(900000): for add in (2, 4): k = (l + (5 * l * l + add)**0.5) / 2.0 n = k * l if n % 1 == 0: res.append(int(n)) if l > 0: for sub in (1, 2): k = 2 * l + (5 * l * l - sub)**0.5 n = k * l if n % 1 == 0: res.append(int(n)) res = [n for n in sorted(set(res)) if is_square((n + 1)**2 + 4 * n**2)] print res[pos]
# -*- coding: utf-8 -*- """ Created on Tue Mar 27 00:26:01 2018 @author: lamwa """ from decimal import getcontext, Decimal import utils RANGE = 100 getcontext().prec = 105 ans = 0 for n in range(2, RANGE): if utils.is_square(n): continue sqrt = str(Decimal(n) ** Decimal('0.5')) sqrt = sqrt.replace('.', '') ans += sum(int(c) for c in sqrt[ : 100]) print(ans)
def test_is_square(self): cases = {1:True, 2:False, 3:False, 4:True} for case in cases: result = utils.is_square(case) if result != cases[case]: self.fail("is_square failed for %s: it got %s" % (case, result))
# -*- coding: utf-8 -*- """ Created on Fri Apr 20 19:54:20 2018 @author: lamwa """ import utils import math a = [8, 136, 2448] for i in range(4, 13): a.append(17 * a[-1] + 17 * a[-2] - a[-3]) ans = 0 for k in a: h1 = 2 * k - 1 h2 = 2 * k + 1 if utils.is_square(k**2 + h1**2): ans += round(math.sqrt(k**2 + h1**2)) else: ans += round(math.sqrt(k**2 + h2**2)) print(ans)
Created on Mon Apr 24 16:56:01 2018 @author: lamwa """ import utils done = False i = 4 while not done: a = i * i j = i - 1 while not done and j > 0: c = j * j f = a - c if not utils.is_square(f): j -= 1 continue k = j - 1 while not done and k > 0: e = k * k d = a - e b = c - e if not utils.is_square(d) or not utils.is_square(b): k -= 1 continue if (a + c + e) % 2 == 0: ans = (a + c + e) // 2 done = True k -= 1 j -= 1
# -*- coding: utf-8 -*- """ Created on Wed Mar 28 14:07:27 2018 @author: lamwa """ import utils n = 3 cnt = 0 while True: for k in range(2, n * 2 + 1): if utils.is_square(k * k + n * n): l = max(k - n, 1) r = k // 2 cnt += r - l + 1 #print(r - l + 1) if cnt > 1000000: print(n) break n += 1
def solve_eq_for(d): """ Solve for minimum integer x: x**2 - d*y**2 = 1 """ x0, y0 = 0, 1 x1, y1 = 1, 0 n = d num = 0 denom = 1 while True: m = int((n**0.5 + num) / denom) x, y = m * x1 + x0, m * y1 + y0 x0, y0 = x1, y1 x1, y1 = x, y num, denom = denom * m - num, (n - (num - denom * m)**2) / denom if x * x - d * y * y == 1: return x return -1 res = None max_x = 0 for d in range(1, 1001): if is_square(d): continue x = solve_eq_for(d) if x > max_x: max_x = x res = d print(res)
l = len(expansion) - 1 for i in range(n - 1, -1, -1): frac = 1 / (a1[i % l] + frac) return a0 + frac def solve_diophantine_equation(D): n = 0 expansion = continued_fraction(D) while True: frac = approximation(expansion, n) x = frac.numerator y = frac.denominator if x**2 - D * y**2 == 1: return x, y break n += 1 x_max = 0 D_max = 0 for D in range(1000): if is_square(D): continue x, y = solve_diophantine_equation(D) if x > x_max: x_max = x D_max = D print D_max
# -*- coding: utf-8 -*- """ Created on Wed Mar 28 17:06:55 2018 @author: lamwa """ import utils RANGE = 1000000000 f1 = list() for i in range(1, 1000): if utils.is_square((3 * i + 1) * (i + 1)): f1.append(i) while True: new = 14 * f1[-1] - f1[-2] + 8 if 6 * new + 2 <= RANGE: f1.append(new) else: break f2 = list() for i in range(2, 1000): if utils.is_square((3 * i - 1) * (i - 1)): f2.append(i) while True:
# -*- coding: utf-8 -*- """ Created on Mon Apr 25 10:56:39 2018 @author: lamwa """ import utils import math N = 120000 mapping = [set() for _ in range(N)] for p in range(1, N): for q in range(1, min(p, N - p) + 1): b = p * p + q * q + p * q if utils.is_square(b): mapping[p].add(q) ans_set = set() for p in range(1, N): for q in mapping[p]: for r in mapping[q]: if p + q + r <= N and r in mapping[p]: ans_set.add(p + q + r) ans = sum(ans_set) print(ans)