def pdi(_digits, _f1length, _f2length):
"get pandigital identities, for pandigitals with digits in _digits, and f1*f2=product f1 has length _f1length and f2 has length _f2length"
products = {}
factors1 = p(_digits, _f1length) # two-digit factors
# find all 1..9 pandigital identites with lengths 2*3=4
for f in factors1:
rd = [d for d in digits if d not in f] # remaining digits
factors2 = p(rd, _f2length) # two-digit factors
for F in factors2:
rd2 = [d for d in rd if d not in f and d not in F] # remaining digits available for product
possible_products = p(rd2, len(_digits) - _f1length - _f2length)
for P in possible_products:
# convert factors and product from lists to ints
factor1 = int("".join(map(str, f)))
factor2 = int("".join(map(str, F)))
product = int("".join(map(str, P)))
if factor1 * factor2 == product:
products[product] = (factor1, factor2)
print("%d * %d = %d" % (factor1, factor2, product))
return products
def solve():
def check(three_two):
three, two = [int(''.join(t)) for t in three_two]
fst = str(three * (two %10))
snd = str(three * (two//10))
product = str(three * two)
return (
len(fst) == len(snd) == 3 and len(product) == 4
and all(set(x).issubset(A) for x in [fst, snd, product])
)
_, A = int(input()), set(input().split())
ans = sum(map(check, p(p(A, repeat=3), p(A, repeat=2))))
print_line(ans)
def main():
lst = []
for i in range(3, 10):
lst += p(list(range(1, i)))
lst = list(map(flatten, lst))
lst = list(filter(u.isPrime, lst))
print(max(lst))
def main():
lst = []
for i in range(3, 10):
lst += p(list(range(1, i)))
lst = list(map(flatten, lst))
lst = list(filter(u.isPrime, lst))
print(max(lst))
def brute(astring):
aset = set()
for perm in p(astring):
aset.add(''.join(perm))
alist = list(aset)
alist.sort()
return alist.index(astring)
def solve():
#Define variables
start = time.time()
digits = [str(i) for i in reversed(range(10))]
ans = 0
found = False
#Solve the problem
for perm in p(digits):
if found: break
n = int(''.join(perm))
for k in range(1, 10):
if found: break
t = 10**k
c1 = n / t
c2 = n % t
if c1 == 0 or c2 == 0: continue
g = gcd(c1, c2)
if g == 1: continue
for d in divisors(g):
d1 = str(c1 / d)
d2 = str(c2 / d)
d = str(d)
if sorted(''.join((d1, d2, d)), reverse = True) == digits:
found = True
ans = n
break
ans = str(ans)
#Print the results
print 'The largest 0 to 9 pandigital 10-digit concatenated '
print 'product of an integer with two or more other integers, '
print 'such that the concatenation of the input numbers is '
print 'also a 0 to 9 pandigital 10-digit number, is ' + ans + '.'
def compute_correlations(self):
# Center
if self.normalize_dimensions:
for network in tqdm(self.representations_d, desc='mu, sigma'):
t = self.representations_d[network]
means = t.mean(0, keepdim=True)
self.representations_d[network] = t - means
# Set `self.similarities`
# {network: {other: lincka_similarity}}
self.similarities = {network: {} for network in
self.representations_d}
for network, other_network in tqdm(p(self.representations_d,
self.representations_d),
desc='lincka',
total=len(self.representations_d)**2):
if network == other_network:
continue
if other_network in self.similarities[network]:
continue
X = self.representations_d[network].to(self.device)
Y = self.representations_d[other_network].to(self.device)
XtX_F = torch.norm(torch.mm(X.t(), X), p='fro').item()
YtY_F = torch.norm(torch.mm(Y.t(), Y), p='fro').item()
YtX_F = torch.norm(torch.mm(Y.t(), X), p='fro').item()
# eq 5 in paper
sim = YtX_F**2 / (XtX_F*YtY_F)
self.similarities[network][other_network] = sim
self.similarities[other_network][network] = sim
def generatePalindromes(s):
r=[]
if len(set(s))==1: return [s]
for i in p(s):
i=''.join(i)
if i==i[::-1] and i not in r: r.append(i)
return sorted(r)
def largestTimeFromDigits(A):
"""
:type A: List[int]
:rtype: str
"""
time = (0, 0)
flag = False
for a, b, c, d in list(p(A)):
hour = a * 10 + b
minute = c * 10 + d
if hour < 24 and minute < 60:
time = max(time, (hour, minute))
flag = True
if flag:
h, m = time
res = []
if h < 10:
res.append('0')
res.append(str(h))
res.append(':')
if m < 10:
res.append('0')
res.append(str(m))
return ''.join(map(str, res))
else:
return ''
def Solve(n = 10**7):
#Define variables
start = time.time()
pans, primes, ans = [], [], 0
#Create the pandigitals to test
#Note: pandigitals can only be prime if they
#have a length of 4 or 7. Anything other length
#is either greater than 10, or results in a number
#divisible by 3, and therefore not prime.
for i in [4, 7]:
for pan in list(p([j for j in range(1, i + 1)])):
pans.append(int(''.join(str(digit) for digit in list(pan))))
#Find the prime pandigitals
for i in range(len(pans)):
if isPrime(pans[i]): primes.append(pans[i])
#Find the largest prime pandigital under n
if n <= primes[0]:
print('There are no pandigital primes < ' + str(n) + '.')
else:
for i in range(len(primes)):
if primes[i] >= n:
ans = str(primes[i - 1])
break
if ans == 0:
ans, n = str(primes[-1]), str(n)
print('The largest pandigital prime is ' + ans + '.')
else:
n = str(n)
print('The largest pandigital prime < ' + n + ' is ' + ans + '.')
print('This took ' + str(time.time() - start) + ' seconds to calculate.')
def solve(name):
#Define variables
start = time.time()
digits = set()
ans = 0
f = open(name, 'r')
keys = f.read().split('\n')
keys = [list(key) for key in keys if len(key) > 0]
for i in range(0, len(keys)):
keys[i] = [int(num) for num in keys[i]]
for key in keys:
for digit in key:
digits.add(digit)
digits = list(digits)
perms = p(digits)
#Solve the problem
for perm in perms:
valid = True
for key in keys:
if valid:
a = perm.index(key[0])
b = perm.index(key[1])
c = perm.index(key[2])
if a > b or b > c:
valid = False
break
if valid:
ans = ''.join(str(i) for i in perm)
break
#Print the results
print 'The shortest possible secret passcode of unknown length is ' + ans + '.'
print 'This took ' + str(time.time() - start) + ' seconds to calculate.'
def numTilePossibilities(self, tiles: str) -> int:
ans = {}
for i in range(1, len(tiles) + 1):
for j in p(tiles, i):
ans[j] = 0
return len(ans)
def generatePalindromes(s):
r = []
if len(set(s)) == 1: return [s]
for i in p(s):
i = ''.join(i)
if i == i[::-1] and i not in r: r.append(i)
return sorted(r)
def solution(n):
answer = 0
for i in range(n%2,n+1,2):
temp = [1]*i + [2]*((n-i)//2)
answer += len(list(set(list(p(temp,len(temp))))))
return answer
def combinations(r):
for i in p(leetBaseWord, *punc, *numbers, possibles):
format = "4621_ctf{{{0}}}"
words = (format.format((''.join(i[0:3]))) + salt)
capwords = (format.format((''.join(i[0:3]).capitalize())) + salt)
base = hashlib.sha256(words.encode('utf-8')).hexdigest()
basecapword = hashlib.sha256(capwords.encode('utf-8')).hexdigest()
hashes = (i[-1])
if base == hashes:
with open("candidateWords.txt", 'a') as file1:
file1.writelines("match success: " + hashes + "," + base +
"," + words + '\n')
elif basecapword == hashes:
with open("candidateWords.txt", 'a') as file1:
file1.writelines("match success: " + hashes + ", " +
basecapword + ", " + capwords + '\n')
else:
#print(hashes + "," + base + "," + words)
#print(hashes + " " + basecapword + " " + capwords)
continue
for w in p(leetBaseWord, *numbers, *punc, possibles):
format = "4621_ctf{{{0}}}"
words = (format.format((''.join(w[0:3]))) + salt)
capwords = (format.format((''.join(w[0:3]).capitalize())) + salt)
base = hashlib.sha256(words.encode('utf-8')).hexdigest()
basecapword = hashlib.sha256(capwords.encode('utf-8')).hexdigest()
hashes = (w[-1])
if base == hashes:
with open("candidateWords.txt", 'a') as file1:
file1.writelines("match success: " + hashes + ", " + base +
"," + words + '\n')
elif basecapword == hashes:
with open("candidateWords.txt", 'a') as file1:
file1.writelines("match success: " + hashes + ", " +
basecapword + ", " + capwords + '\n')
else:
#print(hashes + "," + base + "," + words)
#print(hashes + "," + basecapword + "," + capwords)
continue
def permutations(str):
print(str)
permList = p(str)
li = []
for perm in list(permList):
li.append(''.join(perm))
l2=list(set(li))
l2.sort()
return l2
def triplet(nums):
from itertools import permutations as p
square = [i**2 for i in nums]
per = list(p(square, 3))
for i in range(len(per)):
if per[i][0] + per[i][1] == per[i][2]:
return True
else:
return False
def numTilePossibilities(tiles):
"""
:type tiles: str
:rtype: int
"""
res = 0
for i in range(1, len(tiles) + 1):
res += len(set(p(tiles, i)))
return res
def length(digits):
outputs = set()
ops = [o.add, o.sub, o.mul, o.truediv]
for a, b, c, d in p(digits):
for op1, op2, op3 in pr(ops, repeat=3):
outputs.update(
[op1(op2(op3(a, b), c), d),
op1(op2(a, b), op3(c, d))])
return next(i for i in co(1) if i not in outputs) - 1
def solve2(m, N=0, r={*range(128)}):
for N, q in ((N + 1, [S]) for S in p(*[r] * 2) if m[S[0]][S[1]]):
while q:
x, y = q.pop()
m[x][y] = 0
q.extend(n
for n in ((x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1))
if {*n} < r and m[n[0]][n[1]])
return N
def stringsRearrangement(inputArray):
for ia in p(inputArray):
c = 0
for i in range(len(ia) - 1):
for j in range(len(ia[i])):
if ia[i][j] != ia[i + 1][j]: c += 1
if ia[i] == ia[i + 1]: c += 10
if c == len(ia) - 1: return True
return False
def isPermutation(x, y):
permX = p(x)
for i in list(permX):
ans = ''
for j in range(len(i)):
ans += i[j]
if ans == y:
return True
return False
def compute_correlations(self):
# convenient variables
device = self.device
self.num_sentences = len(next(iter(self.attentions_d.values())))
self.num_words = sum(t.size()[-1]
for t in next(iter(self.attentions_d.values())))
# Set `self.corrs` : {network: {other: [corr]}}
# Set `self.pairs` : {network: {other: [pair]}}
# pair is index of head in other network
# Set `self.similarities` : {network: {other: sim}}
self.corrs = {network: {} for network in self.attentions_d}
self.pairs = {network: {} for network in self.attentions_d}
self.similarities = {network: {} for network in self.attentions_d}
for network, other_network in tqdm(p(self.attentions_d,
self.attentions_d),
desc='correlate',
total=len(self.attentions_d)**2):
if network == other_network:
continue
if other_network in self.corrs[network]:
continue
correlation = self.correlation_matrix(network, other_network)
# Main update
self.corrs[network][other_network] = correlation.max(axis=1)
self.corrs[other_network][network] = correlation.max(axis=0)
self.similarities[network][other_network] = self.corrs[network][
other_network].mean()
self.similarities[other_network][network] = self.corrs[
other_network][network].mean()
self.pairs[network][other_network] = correlation.argmax(axis=1)
self.pairs[other_network][network] = correlation.argmax(axis=0)
# Set `self.head_sort` : {network, sorted_list}
# Set `self.head_notated_sort` : {network: [(head, {other: (corr, pair)})]}
self.head_sort = {}
self.head_notated_sort = {}
for network in tqdm(self.attentions_d, desc='annotation'):
self.head_sort[network] = sorted(
range(self.num_heads_d[network]),
key=lambda i: self.op(self.corrs[network][other][i]
for other in self.corrs[network]),
reverse=True,
)
self.head_notated_sort[network] = [(head, {
other: (
self.corrs[network][other][head],
self.pairs[network][other][head],
)
for other in self.corrs[network]
}) for head in self.head_sort[network]]
def gen_pat(ones,zeros,length): #return a list of all possible sub patterns #with 1s as sub numbers and 0s as fixed num #takes 3 ints, Ones, Zeros, number length #make sure ones+zeros==lenght #zeros are the digits that will be replaced by the same number #while ones are the fixed digits a=[1]*ones+[0]*zeros comb= [i for i in p(a,length)] return comb
def solution():
u = set()
for v in p('123456789'):
v = ''.join(it for it in v)
for i in range(1,9):
for j in range(i+1,9):
num1, num2, num3 = int(v[:i]), int(v[i:j]), int(v[j:])
if num1*num2==num3:
u.add(num3)
return sum(u)
def op_manip(l: list = [2, 4, 5, 3, 2], target=7, ops: list = [add, mul, sub]):
for c in p(ops, repeat=len(l) - 1):
r = l[0]
for i in range(len(c)):
r = c[i](r, l[i + 1])
if (r == target):
print("********")
print(r)
if (r == target):
print(*(op.__name__ for op in c))
print("********")
def slogan_maker(array):
new_array = []
for arr in array:
if arr not in new_array:
new_array.append(arr)
# array = list(set(array))
array = new_array
if len(array) == 1:
return array
from itertools import permutations as p
return [' '.join(item) for item in list(p(array))]
def stringsRearrangement(inputArray):
possible_permutation = p(inputArray)
for permu in possible_permutation:
all_match = True
for j in range(len(permu) - 1):
if not is_differ_by_one_char(permu[j], permu[j + 1]):
all_match = False
break
if all_match:
return True
return False
def run(limit):
from itertools import permutations as p
count = 0
result = []
seeds = [False for x in range(0, limit)]
for n in range(0, limit):
if not seeds[n]:
chain = find_chain(n)
if len(chain) == 60:
perms = [int(''.join(x)) for x in p(str(n))]
result.extend([x for x in perms if len(str(x)) == len(str(n))])
for x in chain:
if x < limit:
if not seeds[x]:
perms = [int(''.join(x)) for x in p(str(x))]
for y in perms:
if y < limit:
seeds[y] = True
count += 1
return set(result)
def main():
f = lambda tp: reduce(add, (str(x) for x in tp))
pandigts = [f(x) for x in list(p(range(10), 10))][362880:]
myint = lambda x: int(x) if x[0] != '0' else int(x[1:])
res = 0
denominator = array([2, 3, 5, 7, 11, 13, 17])
for pd in pandigts:
nominator = array([myint(pd[x:x + 3]) for x in range(1, 8)])
if all(nominator % denominator == 0):
res += int(pd)
return res
def stringsRearrangement(input):
for s in p(input):
c = 0
for i in range(len(s) - 1):
for j in range(len(s[i])):
if s[i][j] != s[i + 1][j]:
c += 1
if s[i] == s[i + 1]:
c += 10
if c == len(s) - 1:
return True
return False
def main():
# YOUR CODE GOES HERE
# Please take input and print output to standard input/output (stdin/stdout)
# E.g. 'input()/raw_input()' for input & 'print' for output
s, k = input().split()
l = list()
for i in p(s, int(k)):
l.append(''.join(i))
l.sort()
for i in l:
print(i)
return 0
def f(b, c):
a = 0
for k in p(b):
d = c
r = 0
for i in range(m):
if k[i] <= d:
d -= k[i]
r += k[i]**2
else:
break
a = max(a, r)
return a
def crosswordFormation(words):
from itertools import permutations as p
c = 0
for l in p(words):
for d1 in range(len(l[0])-2):
s1 = [i for i,j in enumerate(l[1]) if j == l[0][d1]]
for d2 in range(d1+2, len(l[0])):
s2 = [i for i,j in enumerate(l[2]) if j == l[0][d2]]
for cw1 in s1:
for cw2 in s2:
for c1, c2 in zip(l[1][cw1+2:],l[2][cw2+2:]):
for c3, c4 in zip(l[3],l[3][d2-d1:]):
c += c1 == c3 and c2 == c4
return c
def figure_end(x):
global MEMOIZED
global END_NUM
if x in [1, 89]:
return x
elif x in MEMOIZED:
return MEMOIZED[x]
else:
final_num = figure_end(sum([int(i)**2 for i in str(x)]))
for k in set([int(''.join(j)) for j in p([i for i in str(x)])]):
MEMOIZED[k] = final_num
return final_num
def readBinaryWatch(self, num):
"""
:type num: int
:rtype: List[str]
"""
if num < 0 or num > 10:
return []
base_vector = ['1'] * num + ['0'] * (10 - num
) # as chars so I can join later
time_strs = [
time_str(v) for v in set(p(base_vector))
] # set of permutations gives all binary vectors (lists of digits) of length 10 (4+6) with <num> 1 digits without repetition, function converts each to string in required format
return [t for t in time_strs
if t != None] # filter out strings with too many hours/monutes
def stringsRearrangement(inputArray):
p_list = list(p(inputArray))
for i in range(len(p_list)):
count1 = 0
for j in range(len(p_list[0]) - 1):
count2 = 0
for k in range(len(p_list[0][0])):
if p_list[i][j][k] != p_list[i][j + 1][k]:
count2 += 1
if count2 == 1:
count1 += 1
if count1 >= (len(p_list[0])) - 1:
return True
return False
def longest_common_substring(s):
def r(k):
s[k] = s[k][1:] + s[k][:1]
l = 0
k = [0]*len(s)
for d in p(*map(lambda x: range(len(x)), s)):
v = len(c(s))
if v > l:
l = v
for i, n in enumerate(d):
if n != k[i]:
r(i)
k[i] = n
return l
#!/usr/bin/env python3
from json import load
from itertools import permutations as p
print('\n'.join('{} is {}'.format(n, 'Valid' if any(not int(''.join(i)) % 8 for i in p(n, 3)) else 'Invalid') for n in load(open('data.json', 'r'))))
'''
http://projecteuler.net/problem=24
What is the millionth lexicographic permutation of the digits 0, 1, 2, 3, 4, 5, 6, 7, 8 and 9?
'''
from itertools import permutations as p
count = 0
for i in p("0123456789"):
if count == 999999:
print ''.join(i)
break
count += 1
# -*- coding:utf-8 -*-
"""Project Euler problem 49"""
from itertools import permutations as p
from euler import get_plist
primes = set(get_plist(10000))
for i in range(1000, 10000):
if i==1487: continue
fst = i
snd = fst + 3330
thd = snd + 3330
if not fst in primes or not snd in primes or not thd in primes:
continue
pat = set(["".join(ls) for ls in p(str(fst))])
if str(snd) in pat and str(thd) in pat:
break
print("Answer: " + str(fst) + str(snd) + str(thd))
def per(n):
return sorted(set([int("".join(list(i))) for i in list(p([i for i in str(n)]))]))
def solution():
return ''.join(str(s) for s in list(p([it for it in range(10)]))[999999])
#!/usr/bin/env pypy3
from itertools import permutations as p
print([i for i in p(set(range(10)) - {1}, 8) if all([i[j] != 0 for j in range(0, 7, 2)]) and (i[0] * 10 + i[1])-(i[2] * 10 + i[3]) == i[4] * 10 + i[5] and (i[4] * 10 + i[5]) + (i[6] * 10 + i[7]) == 111])
def anagram(s):
from itertools import permutations as p
return [''.join(x) for x in p(s)]
from itertools import product as p print(min((abs(a*(a+1)*b*(b+1)//4-2e6),a*b) for a,b in p(range(80),range(80))))
from itertools import permutations as p
def gcd(a,b):
if not b: return a
return gcd(b,a%b)
while True:
try:
n=input("")
print reduce(gcd,[int(''.join(x)) for x in p(str(n))])
except EOFError:
break
X=[50,48,46,44,42,40,38,36,34,32,30,31,33,35,37,39,41,43,45,47,49]
print "length of shortest pipe is", int(d(X)*1000)
print "process time is", time() - st
exit()
#
# test code to find pattern
#
X=[50,49,48,47,46,45]
Z = p(X)
mind = 10000000
minz = ""
for z in Z:
drod = d(z)
print drod ,z
if drod < mind:
mind = drod
minz = z
print
print "min",mind, minz
def checkio(words_set):
pairs = [x for x in p(words_set, 2) if bool(set(x[0]) & set(x[1]))]
return bool([x for x, y in pairs if x.endswith(y)])
from itertools import permutations as p
# possible Knight moves
moves = [(x,y) for x,y in p([-2,-1,1,2], 2)
if abs(x) != abs(y)]
# helper function "b1" -> (2,1)
conv = lambda pos: (ord(pos[0])-96, int(pos[1]))
# allowed coordinates {(1,1), ..., (8,8)}
CHECKBOARD = {(x,y) for x in range(1,9)
for y in range(1,9)}
def checkio(check, #starting input e.g. "b1-d5"
start: set = None,
end: set = None,
count = 0): # Knight moves counter
if check: # Only first call, then not used
start = {conv(check[:2])} # conversion to coordinates tuple
end = {conv(check[-2:])}
elif start & end: # solution is found and returned
return count # N.B.: if "b1-b1" 0 moves is returned
count += 1
pos = set() #helper set
for x_s, y_s in start:
for x_m, y_m in moves:
pos |= {(x_s+x_m,
y_s+y_m)}
start |= pos & CHECKBOARD # only coord of checkboard are added
return checkio(False, # No need anymore
end, # !!! end is switched for start !!!
start, # a vice versa
#!/usr/bin/python
# Problem 24
# A permutation is an ordered arrangement of objects. For example, 3124 is
# one possible permutation of the digits 1, 2, 3 and 4. If all of the
# permutations are listed numerically or alphabetically, we call it
# lexicographic order. The lexicographic permutations of 0, 1 and 2 are:
#
# 012 021 102 120 201 210
#
# What is the millionth lexicographic permutation of the digits 0, 1, 2, 3,
# 4, 5, 6, 7, 8 and 9?
from itertools import permutations as p
perms = p( range(10) )
i = 1
for perm in perms:
#print( perm )
if i == 1000000:
answer = ""
for d in perm:
answer += str(d)
print( answer )
break
i += 1
from itertools import permutations as p x = "0123456789" print "".join(list(p(x))[999999])
from itertools import permutations as p permutation = lambda n, v: list(p(v))[n - 1] print(permutation(1, [1, 2, 3])) print(permutation(4, [1, 2, 3]))
# https://projecteuler.net/problem=4 # Largest palindrome product from itertools import product as p isPalindrome = lambda n: str(n) == str(n)[::-1] print max( filter(isPalindrome, map(lambda (x,y):x*y, p(range(100, 999), range(100, 999)))) )
def insert_operators(e, t):
for d in p(['+', '-', ''], repeat=len(e)-1):
k = ''.join( str(v) for v in list(c.from_iterable(zip(e, d))) + [e[-1]] )
if eval(k) == t:
return k + "=" + str(t)
ospd = open("newDict.txt").read().split("\n") #taken from https://raw.githubusercontent.com/xjtian/PyScrabble/master/wordlists/OSPD4_stripped.txt
nospd = []
for word in ospd:
nospd.append(word.strip())
print(len(ospd))
from itertools import permutations as p
from string import ascii_uppercase as a_u
diphths = ["".join(i) for i in p(list(a_u), 2)]
for i in a_u:
diphths.append(i*2)
for i in diphths:
with open(i+".txt", "w"):
pass
dfile = open(i+".txt", "w")
for word in nospd:
#print(word[:2])
if word[:2] == i:
pass
dfile.write(word)
dfile.write("\n")
dfile.close()
# -*- coding:utf-8 -*-
"""Project Euler problem 52"""
from itertools import permutations as p
for i in range(1, 10**6):
pat = [int("".join(s)) for s in p(str(i))]
for j in range(2, 7):
if not i*j in pat: break
else:
print("Answer: " + str(i))
quit()
def main(): #generate patterns with 3 zeros 2 ones and #patterns with 2 zeros and 3 ones for a #5 digit number #test case 1: # 2 digit numbers, seq len of 6 >> passed ##test case 2: #5 digit numbers, seq len of 7 #passed target=8 nzeros=1 digits=6 suffix=[1,3,7,9] ##write=0 los=[] while nzeros<digits-1: nones=digits-nzeros print 'ones:',nones,'zeros:',nzeros #set number of zeros #generate the respective patterns #as a list of tuples patterns=gen_pat(nones,nzeros,digits) #remove redundancies #patterns=sorted(list(set(patterns))) patterns=set(patterns) #patterns=list(patterns) #print patterns #print len(patterns) #print 'generated patterns',patterns #print 'starting iteration over patterns...' #iterate over the patterns for pat in patterns: pat=list(pat) #print 'current pattern',pat pat_woz=pat[:] #type:list #iterate over all possible ones #print 'iterating over fixed digits..' #if pat==[0,1,0,1,1,1]: print 'current pat: [0,1,0,1,1,1]' #for one in sorted(list(set(p(range(1,10),nones)))): for one in set(p(range(1,10)*2,nones)): #0 is excluded for 2 digit numbers seq=[] #make a list for the found primes loo=list(one) #type: list #print loo ##if loo==[2,3,1,3]: ##write=1 ##else: ##write=0 ##if write: print 'fixed digits are',loo #list of ones #fill the pattern with ones pat=fill_ones(pat_woz,loo) ##if write: print 'filled with ones',pat,'pat2',pat_woz #break if pat ends with non suffix digits if pat[-1] in [2,4,5,6,8]: ##if write: print 'pat ends with non prime digits, skipping..' continue pat_wz=pat[:] #type:list #iterate over the zeros #print 'iterating over zeros...' for zero in xrange(10): ##if write: print 'current zero',zero pat=fill_zeros(pat_wz,zero) #type:list ##if write: print 'filled with zeros',pat #break if pat ends in non suffix digits if pat[-1] not in suffix: #print 'pat ends with non prime digits, skipping..' continue #calculate the number num=calc_num(pat) #type:list if num<10**(digits-1): continue ##if write: print 'calculated number is',num #add to seq list if it's a prime if prime[num]: seq.append(num) ##if write: print 'current seq:',seq #print 'seq=',seq #if seq length == target, stop and return the #smallest number, sequence and sequence length #print '%-'*40 if len(seq)==target: los.append(seq) nzeros+=1 return los
from itertools import permutations as p for i in p(raw_input()):print''.join(i)
