for i in range(1,10):
if list.count(i) != 1: return False
return True
def lists_overlap(a, b):
return bool(set(a) & set(b))
if __name__ == '__main__':
upper_bound = 10000
sum = 0
products_found = []
for i in range(1,upper_bound):
try:
for j in range(1,upper_bound):
#convert factors to lists
i_list = number_as_list(i)
j_list = number_as_list(j)
if not lists_overlap(i_list,j_list):
#only proceed if there is not already a digit overlap
product = i*j
p_list = number_as_list(product)
combined_list = i_list + j_list + p_list
if len(combined_list) > 10:
#if the number is too big, no more results can be
#found for this factor, so move on to next factor
raise TooBig
if check_pandigital_multiplication(combined_list):
if 0 == products_found.count(product):
products_found.append(product)
sum += product
except TooBig:
#!python
from pelib import Found,number_as_list,list_as_number
if __name__ == '__main__':
keylog = [319,680,180,690,129,620,762,689,762,318,368,710,720,710,629,168,\
160,689,716,731,736,729,316,729,729,710,769,290,719,680,318,389,162,289,162,\
718,729,319,790,680,890,362,319,760,316,729,380,319,728,716]
key = []
try:
while(True):
fixed = len(keylog)
for attempt in keylog:
list = number_as_list(attempt)
index = [-1,-1,-1]
for d in range(0,len(list)):
digit = list[d]
if key.count(digit) == 0:
key.append(digit)
index[d] = key.index(digit)
else:
index[d] = key.index(digit)
for i in range(1,len(list)):
if index[i] < index[i-1]:
digit = list[i]
key.remove(digit)
key.insert(index[i-1],digit)
fixed -= 1
if fixed == len(keylog): raise Found
except Found:
#!python
from pelib import number_as_list, list_as_number
from pelib import check_1_9_pandigital as check_pandigital
if __name__ == '__main__':
best_starting_number = -1
best_pandigital = -1
number = 9876
while(number > 0):
number -= 1
list = number_as_list(number)
factor = 2
while(len(list) < 9):
list += number_as_list(number*factor)
factor += 1
if check_pandigital(list) and factor >= 3:
pand_number = list_as_number(list)
if pand_number > best_pandigital:
best_pandigital = pand_number
best_starting_number = number
print "Largest pandigital: ", best_pandigital
exit(0)
#!python
from pelib import Found,number_as_list,list_as_number
def lists_overlap(list1, list2):
#checks if every item in list1 can be found in list2
#list1 and list2 are not interchangable!!!
for i in list1:
found = False
for j in list2:
if i == j: found = True
if not found: return False
return True
if __name__ == '__main__':
try:
number = 1
while(True):
l1 = number_as_list(number)
l2 = number_as_list(number*2)
if len(l1) == len(l2) and lists_overlap(l1,l2) and lists_overlap(l2,l1):
matches = 0
for i in range(3,7):
l3 = number_as_list(number*i)
if lists_overlap(l1,l3) and lists_overlap(l3,l1):
matches += 1
if matches == 4: raise Found
number += 1
except Found:
print "Smallest number: ", number
exit(0)
#python
from pelib import get_primes_prec, number_as_list
def check_pandigital(list):
#returns True if list is 1-9 pandigital
for i in range(1,len(list)+1):
if list.count(i) != 1: return False
return True
if __name__ == '__main__':
primes = get_primes_prec(10000000)
primes.reverse()
for i in primes:
if check_pandigital(number_as_list(i)):
print i
exit(0)
from pelib import number_as_list, check_primality_prec, get_primes_prec
from pelib import get_digit_permutations, number_as_list
def lists_overlap(list1, list2):
#checks if every item in list1 can be found in list2
#list1 and list2 are not interchangable!!!
for i in list1:
found = False
for j in list2:
if i == j: found = True
if not found: return False
return True
if __name__ == '__main__':
primes = get_primes_prec(10000)
lower_bound = 168 #index of first prime > 1000
for i in range(lower_bound,len(primes)):
for j in range(i+1,len(primes)):
p1 = primes[i]
l1 = number_as_list(p1)
max1 = max(l1)
p2 = primes[j]
l2 = number_as_list(p2)
p3 = p2 + p2 - p1
if p3 > 10000 or p2 > max1*1000: break
if lists_overlap(l1,l2) and lists_overlap(l2,l1) and \
l1.count(p3%10) > 0 and check_primality_prec(p3) and \
set(l1) == set(number_as_list(p3)) and p1 != 1487:
print "Concatenated number: %d%d%d" % (p1, p2, p3)
exit(0)
exit(1)
def try_remove(list, number):
try:
new_list = copy.deepcopy(list)
new_list.remove(number)
return [True, new_list]
except ValueError:
return [False, list]
numer_matches = []
denom_matches = []
for numer in range(lower_bound,upper_bound):
for denom in range(lower_bound,upper_bound):
if numer < denom:
# fractions under consideration are all less than 1
numer_list = number_as_list(numer)
denom_list = number_as_list(denom)
for digit in range(1,10):
# skipping over removing zeros because they are "trivial" solutions
[numer_success, numer_new_list] = try_remove(numer_list, digit)
[denom_success, denom_new_list] = try_remove(denom_list, digit)
if numer_success and denom_success:
# this means a digit was removed from the numerator AND the demoninator
if denom_new_list != [0]:
# make sure denominator isnt just a 0
if float(numer)/denom == float(list_as_number(numer_new_list))/list_as_number(denom_new_list):
numer_matches.append(numer_new_list[0])
denom_matches.append(denom_new_list[0])
numer = 1
denom = 1
number = list_as_number(rotate_list_left(list,i))
permutations.append(number)
return permutations
else:
return []
def check_rotational_prime(list):
number = list_as_number(list)
if len(list) > 0:
checked_dict[number] = True
if check_primality_dyn(number,upper_bound):
for i in range(1,len(list)):
number = list_as_number(rotate_list_left(list,i))
checked_dict[number] = True
if not check_primality_dyn(number,upper_bound):
return False
return True
else:
return False
else:
return False
if __name__ == '__main__':
count = 5 #following loop skips a primality check for 2, 3, 5, 7, and 11
for i in range(13,upper_bound,2):
i_list = number_as_list(i)
if not checked_dict[i] and i_list.count(5) == 0:
if check_rotational_prime(i_list):
count += len(i_list)
print "Count: ", count
def get_square_of_digits(number):
#returns the sum of the squared digits of a number
list = number_as_list(number)
sum = 0
for i in list: sum += i**2
return sum
