回文数可被任何给定数整除

Question

I have the following problem to solve: The numbers 545, 5995 and 15151 are the three smallest palindromes divisible by 109. There are nine palindromes less than 100000 which are divisible by 109.

How many palindromes less than 10**32 are divisible by 10000019 ?

So my code is shown below. In theory my code will work, but to count all the way from 0 to 10**32 would take my computer literally YEARS.

Is there anyway to improve this code?

Python code:

listPalindroms=[]
for i in range (0,10**32):
    strI = str(i)
    printTrue = 1
    if len(strI) == 1:
        listPalindroms.append(i)
    else:
        if len(strI)%2 ==0:
            FinalVal = int(len(strI)/2)
            for count in range (0,FinalVal):
                if strI[count]!=strI[-count-1]:
                    printTrue = 0
            if printTrue==1: listPalindroms.append(i)
        else:
            FinalVal = int(round(len(strI)/2))-1
            for count in range (0,FinalVal):
                if strI[count]!=strI[-count-1]:
                    printTrue = 0
            if printTrue ==1: listPalindroms.append(i)

i=0
for item in listPalindroms:
    if item%10000019 ==0:
        i = i + 1
print (i)

The problem is presented as Project Euler 655

Answer 1

You are getting all palindromes between 0 and 10**32 then filtering using divisibility. But you can do it the other way around also. Just find the multiples of 10000019 that are less than 10**32 then check if each multiple is a palindrome.

This way you can avoid checking palindromes for numbers that are not required.

i = 1
number = 10000019
list_palindromes = []
element = number * i
while element < (10**32):
    e = str(element)
    for j in range(len(e)):
        if e[j] != e[len(e)-j-1]:
            break
        if len(e)-1 == j:
            list_palindromes.append(e)
            print(e)
    i += 1
    element = number * i

Answer 2

Well, you just need to check for numbers divisible by your divisor, so why check numbers before that, and while incrementing, why not just increment the divisor amount?

def is_palin(num):
    num_str = str(num)
    for index in range(len(num_str)/2):
        if num_str[index]==num_str[len(num_str)-1-index]:
            continue
        return False
    return True

def multiple(divisor, end):
    count=0
    index = divisor*2
    while index<end:
        if is_palin(index):
            count+=1
        index+=divisor

    return count

if __name__=="__main__":
    print(multiple(109, 100000))
    # print(multiple(10000019, 10**32))

This approach still takes a lot of time, and I'd recommend finding a better method.

Answer 3

Given that MathJax doesn't work here it's gonna be tough to present my solution.

When you look at a number, eg. 1991, you can write this as 1000*1+100*9+10*9+1*1. If you look at the remainder when dividing by 19 we have that:

(1000*1+100*9+10*9+1*1)%19 = ((1000%19)*1+(100%19)*9+(10%19)*9+(1%19)*1)%19 = (12*1+5*9+10*9+1*1)%19 = 10.

Therefore 19 doesn't divide 1991

For a palindrome, abcba , we can use this property of modular arithmetic to see that 19 divides abcba if and only if:

(7*a + 3*b + 5*c)%19 = 0

Because

(10000*a+1000*b+100*c+10*b+a)%19 = (10001*a+1010*b+100*c)%19 = (10001*a%19+1010*b%19+100*c%19)%19 = (7*a + 3*b + 5*c)%19

By using this method we can cut the number of iterations down to the square root of the max value. A routine for calculating the sum of ever palindrome less than 10**10 that is divisible by 109 will look some thing like this.

maxValue = 10**5
divisor = 109

moduli = []
for i in range(0,33):
    moduli.append((10**i)%divisor)

def test(n,div):
    n = str(n)
    sum_odd = 0
    sum_even = 0
    for i in range(len(n)):
        sum_even = sum_even + int(n[i])*(moduli[i]+moduli[2*len(n)-i-1])
        if i != len(n)-1:
            sum_odd = sum_odd + int(n[i])*(moduli[i]+moduli[2*len(n)-i-2])
        else:
            sum_odd = sum_odd + int(n[i])*(moduli[i])
    if sum_odd%div==0 and sum_even%div==0:
        return 2
    if sum_odd%div==0 or sum_even%div==0:
        return 1
    else:
        return 0

# The sum starts at -1 because 0 is counted twice
sum = -1
for a in range(maxValue):
    sum = sum + test(a,divisor)
print(sum)

Running the calculation for every palindrome less than 10**32, still requires 10**16 iterations, so it's not efficient enough for your problem, it's however better than previous answers (requiring about 10**24 iterations).