Пример #1
0
    def __init__(self):
        self.dudes = []
        self.voices = []
        self.voters = {
            'Arkady': False,
            'Kirill': False,
            'Random Babka': False,
            'Ded': False,
            'Grisha': False
        }

        self.P, self.Q = gen_prime(1024), gen_prime(1024)
        self.sub = Subscriber(self.P, self.Q)
        self.N = self.sub.N
        self.c = self.sub.c
        self.d = self.sub.d
Пример #2
0
def gen_pnr(size, m):
    while True:
        # 1 шаг
        p = prime.gen_prime(size)
        assert p % 4 == 1
        assert sympy.isprime(p)

        # 2 шаг (страница 168, алгоритм 7.8.1)
        a, b = get_zi_factors(p, 1)
        assert a * a + b * b == p

        # 3 шаг
        t_set = [2 * a, -2 * a, 2 * b, -2 * b]
        for t in t_set:
            n = p + 1 + t
            rs = [n // 2, n // 4]
            for r in rs:
                if prime.isprime(r):
                    assert sympy.isprime(r)
                    # шаг 4
                    if p != r:
                        for i in range(1, m + 1):
                            if pow(p, i, r) == 1:
                                break
                        else:
                            return p, n, r
Пример #3
0
def solution2():
    primes = gen_prime(10000)
    for i in range(1,len(primes)):
        lst = []
        for j in range(i+1, len(primes)):
            if prime_concat(primes[i], primes[j]):
                lst.append([primes[i],primes[j]])
        solve(lst)
Пример #4
0
def gen_params(bit_count):
    p = gen_prime(bit_count)
    q = gen_prime(bit_count)

    n = p * q
    phi = (p - 1) * (q - 1)

    e = randint(2, phi - 1)
    while euclid(e, phi) > 1:
        e = randint(2, phi - 1)

    d = get_inverse(e, phi)

    write('pq.txt', '{}\n{}'.format(p, q))
    write('phi.txt', str(phi))
    write('open.txt', '{}\n{}'.format(n, e))
    write('secret.txt', str(d))
Пример #5
0
def main():
    primes = gen_prime(1000)
    target = 2
    while True:
        result = solve_prime_plus(target, [k for k in primes if k <= target])
        if result > 5000:
            break
        target += 1
    print target
Пример #6
0
 def __init__(self):
     self.p, self.q = prime.gen_prime()  #step 1 get prime numbers
     #step 2 cal n
     self.n = self.p * self.q
     #step 3 cal totient of n
     self.phi = (self.p - 1) * (self.q - 1)
     #step 4 cal public key e
     self.e = calPublicKey.cal(self.phi, self.n)
     #step 5 cal private key d
     self.d = calPrivateKey.cal(self.e, self.phi)
Пример #7
0
def main():
    upperbound = 1000000
    for prime in gen_prime(upperbound):
        for number_family in number_families(prime):
            prime_family = [n for n in number_family if is_prime(n) and len(str(n))==len(str(prime))]
            if len(prime_family)==8 and prime in prime_family:
                print '\n',prime
                return
        sys.stdout.write("Testing number %d\r"%(prime))
        sys.stdout.flush()
Пример #8
0
def main():
    ub = 10**7
    pairs = combinations(gen_prime(2*int(sqrt(ub))), 2)
    result = (87109./79180, 87109)
    # Becasue primes produce most relative primes, but single prime doesn't
    # meet the "permutation" criterion. Hence, directly looking up to the 
    # product of two primes
    for product, phi in ((a*b, (a-1)*(b-1)) for a,b in pairs if a*b<ub):
        if is_permutation(phi, product):
            r = float(product)/phi
            if r < result[0]:
                result = (r, product)
    print result
Пример #9
0
def main():
    limit = 50000000
    primes = prime.gen_prime(int(limit**0.5))
    result = set()

    for i in primes:
        for j in primes:
            sum = i**2+j**3
            if sum >= limit: break
            for k in primes:
                sum2 = sum+k**4
                if sum2 < limit:
                    result.add(sum2)
    print "Q087 = ", len(result)
Пример #10
0
def main():
    # initial set of prime
    primes = set([2])
    ub = 1000000
    primes = gen_prime(ub)
    print "The length of the primes is ", len(primes)

    result = []
    for i in primes:
        if is_circular(i, primes):
            result.append(i)
        sys.stdout.write("Complete %d\r" % (i))
        sys.stdout.flush()

    print result
    print len(result)
Пример #11
0
def main():
    ub = 1000000
    startpoint = 10
    primes = gen_prime(ub)
    result = []

    for start in range(startpoint):
        seq = primes[start:]
        count = 0
        total = 0
        for prime in seq:
            total += prime
            if total > ub:
                break
            count += 1
            if total in primes:
                if count > len(result):
                    result = seq[:count]
    print sum(result)
Пример #12
0
def main():
    primes = gen_prime(10000)
    pool = [k for k in primes if k>1000]
    result = []
    for num in pool:
        if num in result:
            continue
        perms = next_permutation([k for k in str(num)])
        count = 0
        temp = []
        for perm in perms:
            if int(''.join(perm)) in pool:
                count += 1
                temp.append(int(''.join(perm)))
        if count >= 3:
            temp.sort()
            if temp[2]-temp[1]==temp[1]-temp[0]:
                result += temp
    print result
Пример #13
0
def main():
    primes = gen_prime(10000)
    # any number concatenate 2 would generate even number.
    for first in range(1,len(primes)):
        for second in range(first+1,len(primes)):
            if not prime_concat(primes[first], primes[second]):
                continue
            temp = [primes[first], primes[second]]
            for third in range(second+1, len(primes)):
                if not all([prime_concat(k, primes[third]) for k in temp]):
                    continue
                temp.append(primes[third])
                for fourth in range(third+1, len(primes)):
                    if not all([prime_concat(primes[fourth], k) for k in temp]):
                        continue
                    temp.append(primes[fourth])
                    for fifth in range(fourth+1, len(primes)):
                        if all([prime_concat(primes[fifth], k) for k in temp]):
                            temp.append(primes[fifth])
                            print temp
                            print sum(temp)
                            return 0
    
    print "You need to enlarge the searching scope."
Пример #14
0
def gen_parts(p_size, msg, n, k):
    if n < k:
        print('ОШИБКА: число долей={} больше k={}'.format(n, k))
        return

    with open(msg, 'rb') as f:
        msg = bytearray(f.read())

    part_size = ceil(len(msg) / k)
    q = [
        int.from_bytes(msg[i * part_size:(i + 1) * part_size], byteorder='big')
        for i in range(k)
    ]

    p_size_max = max(qi.bit_length() for qi in q) + 1
    if p_size_max > p_size:
        p_size = p_size_max + 1
        print('ЛОГ: длина модуля p изменена на {}'.format(p_size))
    p = gen_prime(p_size)
    mat = gen_mat(p, n, k, q)

    write('p.txt', p)
    for idx, part in enumerate(mat):
        write('part_{}.txt'.format(idx + 1), part)
Пример #15
0
import sys
from prime import gen_prime

def cal_formula(a, b):
    return lambda n: n**2+a*n+b

# initial set of prime
ub = 10000
primes = set(gen_prime(ub))

# initial state for the searching
ar, br = 1, 41
nprime = 40

for a in range(-999, 1000):
    for b in range(2, 1000):
        formula = cal_formula(a,b)
        n = 0
        while True:
            result = formula(n)
            if not result in primes:
                break
            else:
                n +=1
        if n > nprime:
            nprime = n
            ar = a
            br = b
    sys.stdout.write("Complete a = %d\r"%(a))
    sys.stdout.flush()
Пример #16
0
	def test_returns_correct_ouput_for_small_values(self):
		n=prime.gen_prime(10)
		self.assertEqual(n,[2,3,5,7],"The return value is expected to be correct for input 10")
Пример #17
0
	def test_returns_a_message_for_wrong_input(self):
		msg=prime.gen_prime([])
		self.assertEqual(msg,"Only an integer is allowed","The function should return a message telling user about wrong input")
Пример #18
0
	def test_negative(self):
		self.assertEqual(gen_prime(-10),"only positive numbers allowed")
Пример #19
0
	def test_returns_correct_ouput_for_large_values(self):
		n=prime.gen_prime(100)
		self.assertEqual(n,[2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97],"The return value is expected to be correct for input 100")
Пример #20
0
 def test_integer(self):
     self.assertEquals(gen_prime("20"), 'Input must be an integer')
Пример #21
0
 def test_it_works(self):
     self.assertEquals(gen_prime(7), [2, 3, 5, 7])
Пример #22
0
	def test_result_not_none(self):
		self.assertNotEqual( gen_prime(10), None)
Пример #23
0
 def test_negative_input(self):
     self.assertEquals(gen_prime(-5), 'Input cannot be negative')
Пример #24
0
	def test_for_string(self):
		self.assertEqual(gen_prime("100"),"Invalid Input!!Only numbers allowed")
Пример #25
0
	def test_for_input_greater_than_2(self):
		self.assertEqual(gen_prime(1),"Input must be greater than 2")
Пример #26
0
	def test_returns_empty_list_if_no_primes(self):
		n=prime.gen_prime(1)
		self.assertEqual(n,[],"The return value is expected to be correct if no primes are found")
Пример #27
0
 def test_empty_inputs(self):
     self.assertEquals(gen_prime(""), 'Input cannot be empty')
Пример #28
0
	def test_returns_a_list(self):
		a=prime.gen_prime(0)
		self.assertTrue(isinstance(a,list),"The returned output should be a list")
Пример #29
0
#! /usr/bin/env python

from prime import gen_prime
from mod.point import Point

primes = gen_prime()
p10 = []
for i in range(10):
    p10.append(next(primes))

print(', '.join(map(str, p10)))  # 2, 3, 5, 7, 11, 13, 17, 19, 23, 29

a = Point(2, 4)
b = Point(-3, 6)
print(a - b)
a += b
print(a)
b -= a
print(-b)
Пример #30
0
	def test_result_not_string(self):
		self.assertNotEqual( gen_prime(10), "")
Пример #31
0
def gen_params(pq_size, k):
    p = prime.gen_prime(pq_size)
    q = prime.gen_prime(pq_size)
    n = p * q
    write('n.txt', n)
    write('k.txt', k)
Пример #32
0
	def test_gen_prime(self):
		self.assertEqual(gen_prime(10),[2,3,5,7])
Пример #33
0
	def test_result_not_a_dictionary(self):
		self.assertNotEqual( gen_prime(10), {})
Пример #34
0
 def test_output(self):
     self.assertIsInstance(gen_prime(20), list, 'The output must be a list')
Пример #35
0
import sys, os
sys.path.append(os.path.abspath('..'))

import prime

print sum(prime.gen_prime(2000000))

Пример #36
0
	def test_for_large_no(self):
		self.assertEqual(gen_prime(100),[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97])