Inspired by Brian Charlesworth

[This is not a complete solution]

Let's consider how to generalize this problem to finding the square with $n$ identical leading digits.

For those of you who decided to do a brute-force search from 1, 2, 3, it will take you $O ( 10 ^n)$ searches to get to the answer, which is not very appealing. Instead, let's apply math to this problem.

First, let's not care about finding the smallest. Let's find all such numbers (or at least categorize them). We want to find a $k$ and a initial repeating digit $d$ such that

$\overline{dddd000 \ldots } \leq k^2 < \overline{ddd(d+1)000 \ldots}$

Let's focus on the case of $d = 1, n = 5$ .
If $k$ has $2m$ digits, then we can conclude that
$\sqrt{0.11111} \times 10^m \leq k < \sqrt{0.11112} \times 10 ^ m$ . This bounding tells us that the smallest possible value of $m$ for the first case occurs when the values $\sqrt{0.11111}$ and $\sqrt{0.11112}$ differ in their decimal representation. Thus, the smallest answer would be 10541.
If $k$ has $2m+1$ digits, then we can conclude that $\sqrt{1.1111} \times 10^m \leq k < \sqrt{ 1.1112} \times 10 ^ m$ . Similar to the above, we can conclude that the smallest answer would be 33334.

We repeat this for all 9 possible values of $d$ , and we are done.

This is my java solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public static void main(String[] arg){
    int i=1000;
    while(d(i).replaceAll(d(i).substring(0, 1),"").length()!=0){
        i++;    
    }
    System.out.println(i);
}

private static String d(int i) {
    long a=i*i;
    return String.valueOf(a).substring(0,5);        
}

0,455 s run time

Brute force is "relatively" easy. We know square of answer is at least 11,111. So it could be 11,111n where n is an integer between 1 and 9, inclusive. None of these work so then try 111,110n + p where p is an integer between 0 and 9, inclusive (n as previous). Continue with 1,111,100n + q where q is an integer between 0 and 99, inclusive (n as previous), etc. You will find the first perfect square with 5 identical digits at 111,112,681. Q.E.D. (well kind of)!

Hint: I actually did it backwards, e.g. taking sequential numbers in local proximity to square roots to see if squares had the requisite 5 digits.

1
2
3
4
5

for x in range(100,99999):
             a=str(x*x)
             if(a[0]==a[1]==a[2]==a[3]==a[4]):
                     x
                     break

Execution time : 0.18s

I solved it in my JavaScript console with:

for(var i=0;i<1000000;i++)with({n:Math.pow(i,2)})if(n>10000&&/^1{5}|^2{5}|^3{5}|^4{5}|^5{5}|^6{5}|^7{5}|^8{5}|^9{5}/.test(n)){console.log(i+'*'+i+'='+n);break;}

Could also write the regular expression like this:

for(var i=0;i<1000000;i++)with({n:Math.pow(i,2)})if(n>10000&&/^(\d)\1{4}/.test(n)){console.log(i+'*'+i+'='+n);break;}

This takes JavaScript a split second to solve.

This is a brute-force solution in python 3.4

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

def kleadident(n, k):
     return len(str(n))>= k and len(set(str(n)[0:k])) == 1

def solve(k):
    "Inspired by Brian Charlesworth"
    i = 1
    while not kleadident(i*i, k):
        i += 1
    return i

print(solve(5))

I was kinda bored on solving this question on paper so i end up making this java code:

 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

public static void main(String args[])
{
    int i=100;

    while(i>=100)
    {
        String k=String.valueOf(i*i);
        if(k.charAt(0)==k.charAt(1))
        {
            if(k.charAt(0)==k.charAt(2))
            {
                if(k.charAt(0)==k.charAt(3))
                {
                    if(k.charAt(0)==k.charAt(4))
                    {
                        System.out.println(i);
                        break;
                    }
                    else
                    {
                        i++;
                        continue;
                    }
                }
                else
                {
                    i++;
                    continue;
                }
            }
            else
            {
                i++;
                continue;
            }
        }
        else
        {
            i++;
            continue;
        }

    }

}