Palindromic Binary Squares

The Mathematica function

TestQ[n_] := PalindromeQ[IntegerDigits[n^2, 2]]

coupled with the command

Select[Range[10000], TestQ[#] &]

gives

{1, 3, 4523}

so the answer is $4523^2 = \boxed{20457529}$ .

Here is my C++ code. It is worth to mention, that the entire computation is done at the compile time. I used gcc 9.2 with -std=c++17.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

#include <iostream>
#include <bitset>

template<std::size_t N>
constexpr bool is_palindrome(const std::bitset<N>& in_bits)
{
    std::size_t max_bit = N-1;
    while (max_bit < N && in_bits[max_bit] == false)
    {
        --max_bit;
    }
    bool res = true;
    if (max_bit < N)
    {
        for (std::size_t cur_bit = 0; cur_bit < 1+max_bit/2; ++cur_bit)
        {
            if (in_bits[cur_bit] != in_bits[max_bit-cur_bit])
            {
                res = false;
                break;
            }
        }
    }
    return res;
}

template <typename UIntType>
constexpr UIntType find_palindormic_bin_sq(const UIntType& start_val)
{
    UIntType cur_val = start_val;
    using bitset_type = std::bitset<sizeof(UIntType)*8>;
    while (is_palindrome(bitset_type(cur_val*cur_val)) == false)
    {
        ++cur_val;
    }
    return cur_val*cur_val;
}

int main()
{
    static_assert(find_palindormic_bin_sq<unsigned>(2) == 9);
    constexpr auto res = find_palindormic_bin_sq<unsigned>(4);
    static_assert(res == 20457529);
    std::cout<<res;
    return 0;
}

The following is the most Naive implementation.

The next smallest square must be in the form of $N^2$ for integer $N > 3 .$

We will convert the perfect square $N^2$ into a binary number , then check if it's a palindrome or not. If it's not, we increase $N$ by 1. We execute this task until a solution is found.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

def is_it_a_palindrome(s): 
    '''
    Ask if the input string is a palindrome or not
    '''
    s = str(s)
    return bool((s == s[::-1]))

def decimal_to_binary(n):  
    '''
    Convert a decimal number to a binary number
    '''
    return int( bin(n).replace("0b", "")  )

smallest_integer = 4
while True:
    this_number_squared = smallest_integer ** 2
    now_convert_to_binary = decimal_to_binary(this_number_squared)
    if is_it_a_palindrome(now_convert_to_binary):
        print("The next smallest palindromic binary square is {}^2 = {},".format(smallest_integer,this_number_squared))
        print("whose binary representation is {}₂.".format(now_convert_to_binary))
        break
    else:
        smallest_integer += 1

# Output:
# The next smallest palindromic binary square is 4523^2 = 20457529,
# whose binary representation is 1001110000010100000111001₂.