matlab中的大号Palindroms

Question

Converting a number into string and reversing that string and then comparing if the both strings are equal or not.

I am using the above mentioned algorithms to find out Palindromes.

The problem is, I want to detect the number of palindromes from 10^50 to 10^100, and this function is taking too much time.

Any faster algorithm or hint to do this?

Answer 1

I think you need to take a more "combinatoric" approach to this. Rather than brute-forcing through all those numbers (it probably can't be done with today's computing power...), think about it in steps:

Given the number of digits, how many possible combinations can be palindromes?

Well, to begin with, we can start looking at numbers with quite few digits, to get a sense of how it works:

• For 2-digit numbers, if you choose the first digit the second has to be the same if the number is to be palindromic. That is, in base 10 you have 10 choices (if you count 00 as two-digit) or 9 choices (if you don't, which makes more sense).

• For 3-digit numbers, if you choose the first digit the third is fixed. That gives you 9 choices (as we don't call eg 020 three-digit). The middle digit is still free, so that gives you another 10 (since the middle digit can be 0) independent choices. The total number of palindromes is given by 9*10 = 90.

• For 4-digit numbers, you can choose the first and second digit independently, and then the third and fourth are fixed. The first must be nonzero, but after that zeroes are OK. 9*10 = 90 palindromes.

• For 5-digit numbers, you choose first, second and third independently, and then the fourth and fifth are fixed. The first is nonzero, the rest are completely free: 9*10^2 = 900 palindromes.

I think we're ready to generalize this, don't you?

A general approach

We noted above that for even digit numbers, you can choose digits for half the number independently, and for odd digit numbers you also choose the middle digit. The first digit cannot be 0, but all the others can, yielding. That means that for a number with N digits, the number of palindrome choices are
P = 10 _* 9 ^{ceil( N / ₂ )-1} . Note that for this to work, ^N / ₂ must be floating point division - for N = 7 we want 3.5, so we can round it up to 4 and choose also the middle digit.

The specific problem

To count the number of palindromes between 10^50 and 10^100, there is one more bit of information we need to make use of: what we know about the number of digits for these numbers. Since all numbers between 10 ⁵⁰ and 10 ⁵¹ have 50 digits (and since 10 ¹⁰⁰ is not a palindrome) the rest is quite simple.

A python snippet that gives you the count:

import math

palindromes = 0
for n in range(50):
    palindromes = palindromes + 10**math.ceil((n+50)/2.0)*0.9

Or, with a one-liner that does exactly the same thing:

import math
sum(.9*10**math.ceil((n+50)/2.0) for n in range(50))

Since this loops over 50 iterations, rather than almost 10 ¹⁰⁰ , it's no problem at all for any computer. Note also that 9*10 ^N-1 = 0.9*10 ^N .

Answer 2

How many k digit palindromes are there? Ok, now, how many k+2 digit palindromes are there? See that we can write a recursion for the number of palindromes.

Define P(n) to be the number of n digit palindromes. Arbitrarily, assume that there is only one 0 digit palindrome, so P(0) = 1.

As well, it seems logical to state that there are 9 one digit palindromes, so P(1) = 9. And P(2) is also 9, since the two digit palindromes are easy to build and count.

Can we generate the 3 digit palindromes? We will do so by appending/prepending any non-zero digit to all of the 1 digit palindromes. That misses the palindromes of form x0x, so we will add them in too.

P(3) = P(1)*9 + 1*9 = (P(1) + 1)*9

How about 5 digit palindromes? Again, append & prepend any non-zero digit to the smaller order palindromes. But we need to worry about the case where we need zeros inside the palindrome. So x0p0x is a palindrome, as well as x000x.

P(5) = P(3)*9 + P(1)*9 + 1*9 = (P(3) + P(1) + 1)*9

(We can go one step further, and write P(5) in terms of P(1).)

So we have P(5) = 900. A good idea is always to verify simple claims like this. This makes us more confident that we have not missed anything. I'll do that in MATLAB.

n = 10000:99999;
D = dec2base(n,10);
isp = sum(all(D == fliplr(D),2))

isp =
   900

We can extrapolate the above logic to compute the 7 digit palindromes, resulting in the formula:

P(7) = P(5)*9 + P(3)*9 + P(1)*9 + 1*9 = (P(5) + P(3) + P(1) + 1)*9

This suggests that P(7) = 9000. Again, we can test that claim using brute force.

n = 1000000:9999999;
D = dec2base(n,10);
isp = sum(all(D == fliplr(D),2))
isp =

        9000

So it seems easy to count the n digit palindromes when n is odd. It is just as easy to count the n digit palindromes for even n. I'll let you derive those relations.

Answer 3

Because the palindrome property of a number depends essentially on the base in which you want to represent the number, you have to convert it to string, in the base that you chose. There may be specific tricks for specific bases, but in the general case I guess the fastest way would be:

% Suppose your number is stored as string in str
strcmp(str, str(end:-1:1))

Later edit: now I see that what are you looking for is not a test for "palindromeness," but to count the palindromes between 2 given numbers. Again, that depends on the base, but you can always count palindromes with 2n or 2n+1 digits in base B by counting the valid numbers having n digits in base B. But this is not about Matlab, I guess it's about math.

Even later edit: maybe this would help (it's not optimal, but I hope is clear and helpful):

%COUNT_PALINDROMES returns the number of palindrome
% numbers with nd digits in base b

function np = count_palindromes(b, nd)

        % For the sake of brevity the function assumes
        % that b has natural values greater than 1, and
        % nd has appropriate values also.

        if nd == 1
                % Single digit "palindromes"
                np = b;

        elseif mod(nd,2) == 1
                % 2n+1 digit palindromes
                %    abcd...uvXvu...cba
                n  = fix(nd/2);
                np = (b-1)*b^n;

        else
                % 2n digit palindromes
                %    abcd...uvvu...cba
                n = fix(nd/2);
                np = (b-1)*b^(n-1);
        end;
end

Please be careful to the floating point precision when using its values. I'm not sure if you'll be able to keep exactly the number of palindromes in a double -- which is the default type in Matlab. Change to other (integral) types as needed.