def encrypt(text, key):
binary_text = misc.text_to_bits(text)
binary_text = textwrap.wrap(binary_text, 64)
last_text_part = binary_text[len(binary_text) - 1]
binary_text[len(binary_text) - 1] = last_text_part + ''.zfill(64-len(last_text_part))
subkeys = conversion.primary_key_to_subkeys(key)
for part_num, part in enumerate(binary_text):
part = permutations.permutation(part, "initial")
lpt, rpt = part[:int(len(part) / 2)], part[int(len(part) / 2):]
for i in range(16):
lpt, rpt = rpt, misc.binary_addition(lpt, function(rpt, subkeys[0]), 32)
binary_text[part_num] = permutations.permutation(rpt + lpt, "inverse")
return ''.join(binary_text)
def findPanPrime():
for d in range(8, 1, -1):
digits = [x for x in range(1, d)]
digits.reverse()
if sum(digits) % 3 == 0:
continue
for p in permutation(digits, len(digits)):
if p[-1] not in BAD_END_NUMS:
n = int("".join([str(x) for x in p]))
if primeCheckII.PrimeCheck(n):
return (n)
def findSpecialPrimes():
checked_list = []
for prime in primeCheckII.primes(1000,10000):
#print(prime)
for p in permutation([x for x in range(len(str(prime)))],len(str(prime))):
s = [str(prime)[x] for x in p]
next_prime = int("".join(s))
if len(str(next_prime)) < PRIME_LENGTH or next_prime <= prime:
continue
if primeCheckII.PrimeCheck(next_prime):
d_prime = next_prime - prime
last_prime = next_prime + d_prime
if len(str(last_prime)) != PRIME_LENGTH:
continue
if primeCheckII.PrimeCheck(last_prime):
if Counter([s for s in str(last_prime)]) == Counter(s):
if prime not in checked_list:
checked_list.append(prime)
yield([prime,next_prime,last_prime])
def computeUniqueCombos(digit_list, n, min_prime=2):
if len(digit_list) == 0:
yield ([])
set_list = []
for x in permutation(digit_list, n):
x_str = ''
for i in x:
x_str += str(i)
X = int(x_str)
if X >= min_prime:
new_digit_list = [i for i in digit_list if i not in x]
if not isPrime(X):
continue
else:
if len(new_digit_list) == 0:
set_list.append([X])
else:
for N in range(n, len(new_digit_list) + 1):
for y in computeUniqueCombos(new_digit_list, N, X):
set_list.append([X] + y)
for item in set_list:
yield (item)
def primary_key_to_subkeys(key):
subkeys = []
binary_prim_key = misc.hex_to_bits(key)
binary_prim_key = ''.join(
[binary_prim_key[i:i + 7] for i in range(0, len(binary_prim_key), 8)])
left_part, right_part = binary_prim_key[:int(
len(binary_prim_key) /
2)], binary_prim_key[int(len(binary_prim_key) / 2):]
for i in range(16):
if i == 0 \
or i == 1 \
or i == 8 \
or i == 15:
left_part = misc.left_shift(left_part, 1)
right_part = misc.left_shift(right_part, 1)
else:
left_part = misc.left_shift(left_part, 2)
right_part = misc.left_shift(right_part, 2)
subkeys.append(
permutations.permutation(left_part + right_part, "compression"))
return subkeys
def test_example(self):
expected = [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2],
[3, 2, 1]]
actual = permutations.permutation([1, 2, 3])
self.assertEqual(actual, expected)
def function(rpt, subkey):
rpt = permutations.permutation(rpt, "expansion")
rpt = misc.XOR(rpt, subkey)
rpt = permutations.sBox_permutation(rpt)
rpt = permutations.permutation(rpt, "pBox")
return rpt
# PROJECT EULER PROBLEM 24 - Lexicographic Permutations
from permutations import permutation
digits = [x for x in range(10)]
for i, p in enumerate(permutation(digits, len(digits))):
if i + 1 == 1000000:
x = int("".join([str(j) for j in p]))
print(x)
break
# What is the millionth lexicographic permutation of the digits 0, 1, 2, 3, 4, 5, 6, 7, 8 and 9? import permutations print(permutations.permutation([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 999999)) # My permutation finder is zero-based.
def test_small_permutations(self):
self.data = ["0", "1", "2"]
self.index = 6 - 1
result = permutations.permutation(self.index, self.data)
self.assertEqual(result, "210")
def test_permutations(self):
self.data = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
self.index = 1000000 - 1
result = permutations.permutation(self.index, self.data)
self.assertEqual(result, "2783915460")
print("Result: {0}".format(result))
#!/usr/bin/python
# -*- coding: utf-8 -*-
import permutations
def mediana(data):
n = len(data)
sorted_data = sorted(data)
if n < 1:
return None
if n % 2 == 1:
return sorted_data[n // 2] # integer division
else:
return (sorted_data[n // 2 - 1] + sorted_data[n // 2]) / 2.0
if __name__ == "__main__":
items = permutations.permutation(10)
print mediana(items)
prime_list = [p for p in primes(2, 18)]
results = []
for digit3 in GOOD3:
digit_list = [x for x in range(10)]
new_num = ['X' for x in range(10)]
new_num[3] = digit3
digit_list.remove(digit3)
for digit5 in GOOD5:
new_digit_list = digit_list[:]
if digit3 == digit5:
continue
new_num[5] = digit5
new_digit_list.remove(digit5)
for p in permutation(new_digit_list, len(new_digit_list)):
num = ''
for d in new_num:
if d == 'X':
num += str(p.pop(0))
else:
num += str(d)
good_num = True
for d in range(1, 8):
val = int(num[d:d + 3])
if val % prime_list[d - 1] != 0:
good_num = False
break
if good_num:
results.append(int(num))
# PROJECT EULER PROBLEM 32 - Pandigital Products
from permutations import permutation
digits = [i for i in range(1, 10)]
final_result_dict = {}
product_sum = 0
for n in range(1, 3):
m = 5 - n
for p in permutation(digits, n):
if p == [1]:
continue
new_digits = [x for x in digits if x not in p]
for q in permutation(new_digits, m):
r = [x for x in new_digits if x not in q]
multiplicand = int("".join([str(i) for i in p]))
multiplier = int("".join([str(i) for i in q]))
result = multiplicand * multiplier
if result > 9999:
continue
result_list = sorted([i for i in str(result)])
if '0' in result_list:
continue
product_list = sorted([str(i) for i in r])
if product_list == result_list:
if result not in final_result_dict:
final_result_dict[result] = [multiplicand, multiplier]
product_sum += result
print(final_result_dict)
print(product_sum)