75	1109	1514			855
136	2157	1672			855
197	471	3154			855
258	698	2736			855

• это равноценные методы
• что имеется ввиду?

Python 2.7.17 (default, Nov  7 2019, 10:07:09) 
[GCC 7.4.0] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> type(1.1)
<type 'float'>
>>> type(1)
<type 'int'>
>>> type(100000)
<type 'int'>
>>> type(100000000000000000000)
<type 'long'>
>>> type(10000000000000000000000000000000000000000000000000)
<type 'long'>
>>> 
>>> type(long(1))
<type 'long'>

import math


def invmod(a, b):
  if b == 0:
    return 0
  x2 = 1
  x1 = 0
  y2 = 0
  y1 = 1
  d = b
  while b > 0:
    q = a // b
    r = a - q * b
    x = x2 - q * x1
    y = y2 - q * y1
    a = b
    b = r
    x2 = x1
    x1 = x
    y2 = y1
    y1 = y
  if a == 1:
    if x2 > 0:
      return x2
    else:
      return d + x2
  else:
    return 0

def chinese_rems(mods):
    mod_mults = []
    p_mods = 1
    
    def rem_restore(rems):
        nonlocal mod_mults, p_mods 
        sm = 0
        for i in range(len(rems)):
            sm += rems[i] * mod_mults[i] % p_mods
        return sm % p_mods

    for i in mods:
        p_mods *= i
    for i in mods:
        mod_mults.append(invmod(p_mods//i, i) * (p_mods//i) % p_mods)
    return rem_restore

f = chinese_rems([5,17,12])
print (f([2,15,5]))

2^[(N + 1)/2] mod N = 2^[(x + y)/2] mod N

-- mayton : 28-Sep. Yet another tiny factorization

primes :: [Int]
primes = filterPrime [2..]
  where filterPrime (p:xs) =
          p : filterPrime [x | x <- xs, (mod x p) /= 0]

factorize' :: Int -> [Int] -> [Int] -> [Int]
factorize' x divisors primesVals 
  |x == 1 = reverse divisors 
  |otherwise = let d = head primesVals 
               in if (mod x d) == 0 then factorize' (div x d) (d:divisors) primesVals
               else factorize' x divisors $ tail primesVals

factorize :: Int -> [Int]
factorize x = factorize' x [] primes

(x r+ a) (y r + b) - с = 0

class Number[T] with Factorizable[T] {

   def lazyFactorize() : Map[T,T] // если надо то любое число будет иметь вторую форму представления в виде 240 = 2^2 * 3 * 4 * 5

   .....

}

primes :: [Int]
primes = filterPrime [2..]
  where filterPrime (p:xs) =
          p : filterPrime [x | x <- xs, (mod x p) /= 0]

factorize :: Int -> [Int]
factorize x = factorize' x [] primes
 where 
  factorize' x divisors primesVals 
   |x == 1 = reverse divisors 
   |otherwise = let 
                   d = head primesVals 
                in if (mod x d) == 0 then factorize' (div x d) (d:divisors) primesVals
                   else factorize' x divisors $ tail primesVals