First perfect square in base n with n unique digits

First perfect square in base n with n unique digits
You are encouraged to solve this task according to the task description, using any language you may know.

Find the first perfect square in a given base N that has at least N digits and exactly N significant unique digits when expressed in base N.

E.G. In base 10, the first perfect square with at least 10 unique digits is 1026753849 (32043²).

You may use analytical methods to reduce the search space, but the code must do a search. Do not use magic numbers or just feed the code the answer to verify it is correct.

Task

• Find and display here, on this page, the first perfect square in base N, with N significant unique digits when expressed in base N, for each of base 2 through 12. Display each number in the base N for which it was calculated.

• (optional) Do the same for bases 13 through 16.

• (stretch goal) Continue on for bases 17 - ?? (Big Integer math)

See also

• OEIS A260182: smallest square that is pandigital in base n.

Related task

• Casting out nines

11l

Translation of: Nim

L(base) 2..16
   V n = Int64(Float(base) ^ ((base - 1) / 2))
   L
      V sq = n * n
      V sqstr = String(sq, radix' base)
      I sqstr.len >= base & Set(Array(sqstr)).len == base
         V nstr = String(n, radix' base)
         print(‘Base #2:  #8^2 = #.’.format(base, nstr, sqstr))
         L.break
      n++

Output:

Base  2:        10^2 = 100
Base  3:        22^2 = 2101
Base  4:        33^2 = 3201
Base  5:       243^2 = 132304
Base  6:       523^2 = 452013
Base  7:      1431^2 = 2450361
Base  8:      3344^2 = 13675420
Base  9:     11642^2 = 136802574
Base 10:     32043^2 = 1026753849
Base 11:    111453^2 = 1240A536789
Base 12:    3966B9^2 = 124A7B538609
Base 13:   3828943^2 = 10254773CA86B9
Base 14:   3A9DB7C^2 = 10269B8C57D3A4
Base 15:  1012B857^2 = 102597BACE836D4
Base 16:  404A9D9B^2 = 1025648CFEA37BD9

ALGOL 68

Assumes LONG INT is at least 64 bits as in e.g., Algol 68G

BEGIN # find the first perfect square in base n with n unique digits n=1..16 #
    [ 0 : 15 ]BITS dmask; # masks for recording the digits in a BITS string  #
    dmask[ 0 ] := 16r1;
    FOR i TO UPB dmask DO dmask[ i ] := BIN ( 2 * ABS dmask[ i - 1 ] ) OD; 
    # base digits                                                            #
    STRING digits = "0123456789abcdefghijklmnopqrstuvwxyz";
    # returns a string representation of n in base b                         #
    #         the result is balank padded on the left to at least w digits   #
    PROC to base = ( LONG INT n, INT b, w )STRING:
         BEGIN
            STRING result := "";
            LONG INT v := ABS n;
            WHILE v > 0 DO
                digits[ SHORTEN ( v MOD b ) + 1 ] +=: result;
                v OVERAB b
            OD;
            IF   INT len = ( UPB result - LWB result ) + 1;
                 len < w
            THEN
                 ( ( w - len ) * " " ) + result
            ELSE result
            FI
         END # to base # ;
    BITS all digits := dmask[ 0 ];
    FOR b FROM 2 TO 16 DO
        all digits    := all digits OR dmask[ b - 1 ];
        LONG INT root := 1;
        FOR i TO b - 1 DO
            root *:= b
        OD;
        root       := ENTIER long sqrt( root );
        BOOL found := FALSE;
        WHILE NOT found DO
            LONG INT square = root * root;
            LONG INT v     := square;
            BITS present   := 16r0;
            WHILE v > 0 DO
                present := present OR dmask[ SHORTEN ( v MOD b ) ];
                v OVERAB b
            OD;
            IF found := present = all digits THEN
                print( ( "Base: ", whole( b, -2 )
                       , ":", to base( root, b, 20 ), "^2 = ", to base( square, b, 0 )
                       , newline
                       )
                     )
            FI;
            root +:= 1
        OD
    OD
END

Output:

Base:  2:                  10^2 = 100
Base:  3:                  22^2 = 2101
Base:  4:                  33^2 = 3201
Base:  5:                 243^2 = 132304
Base:  6:                 523^2 = 452013
Base:  7:                1431^2 = 2450361
Base:  8:                3344^2 = 13675420
Base:  9:               11642^2 = 136802574
Base: 10:               32043^2 = 1026753849
Base: 11:              111453^2 = 1240a536789
Base: 12:              3966b9^2 = 124a7b538609
Base: 13:             3828943^2 = 10254773ca86b9
Base: 14:             3a9db7c^2 = 10269b8c57d3a4
Base: 15:            1012b857^2 = 102597bace836d4
Base: 16:            404a9d9b^2 = 1025648cfea37bd9

C

#include <stdio.h>
#include <string.h>

#define BUFF_SIZE 32

void toBaseN(char buffer[], long long num, int base) {
    char *ptr = buffer;
    char *tmp;

    // write it backwards
    while (num >= 1) {
        int rem = num % base;
        num /= base;

        *ptr++ = "0123456789ABCDEF"[rem];
    }
    *ptr-- = 0;

    // now reverse it to be written forwards
    for (tmp = buffer; tmp < ptr; tmp++, ptr--) {
        char c = *tmp;
        *tmp = *ptr;
        *ptr = c;
    }
}

int countUnique(char inBuf[]) {
    char buffer[BUFF_SIZE];
    int count = 0;
    int pos, nxt;

    strcpy_s(buffer, BUFF_SIZE, inBuf);

    for (pos = 0; buffer[pos] != 0; pos++) {
        if (buffer[pos] != 1) {
            count++;
            for (nxt = pos + 1; buffer[nxt] != 0; nxt++) {
                if (buffer[nxt] == buffer[pos]) {
                    buffer[nxt] = 1;
                }
            }
        }
    }

    return count;
}

void find(int base) {
    char nBuf[BUFF_SIZE];
    char sqBuf[BUFF_SIZE];
    long long n, s;

    for (n = 2; /*blank*/; n++) {
        s = n * n;
        toBaseN(sqBuf, s, base);
        if (strlen(sqBuf) >= base && countUnique(sqBuf) == base) {
            toBaseN(nBuf, n, base);
            toBaseN(sqBuf, s, base);
            //printf("Base %d : Num %lld Square %lld\n", base, n, s);
            printf("Base %d : Num %8s Square %16s\n", base, nBuf, sqBuf);
            break;
        }
    }
}

int main() {
    int i;

    for (i = 2; i <= 15; i++) {
        find(i);
    }

    return 0;
}

Output:

Base 2 : Num       10 Square              100
Base 3 : Num       22 Square             2101
Base 4 : Num       33 Square             3201
Base 5 : Num      243 Square           132304
Base 6 : Num      523 Square           452013
Base 7 : Num     1431 Square          2450361
Base 8 : Num     3344 Square         13675420
Base 9 : Num    11642 Square        136802574
Base 10 : Num    32043 Square       1026753849
Base 11 : Num   111453 Square      1240A536789
Base 12 : Num   3966B9 Square     124A7B538609
Base 13 : Num  3828943 Square   10254773CA86B9
Base 14 : Num  3A9DB7C Square   10269B8C57D3A4
Base 15 : Num 1012B857 Square  102597BACE836D4

C#

Library: System.Numerics

Translation of: Visual Basic .NET

Based on the Visual Basic .NET version, plus it shortcuts some of the allIn() checks. When the numbers checked are below a threshold, not every digit needs to be checked, saving a little time.

using System;
using System.Collections.Generic;
using System.Numerics;

static class Program
{
    static byte Base, bmo, blim, ic; static DateTime st0; static BigInteger bllim, threshold;
    static HashSet<byte> hs = new HashSet<byte>(), o = new HashSet<byte>();
    static string chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz|";
    static List<BigInteger> limits;
    static string ms;

    // convert BigInteger to string using current base
    static string toStr(BigInteger b) {
        string res = ""; BigInteger re; while (b > 0) {
            b = BigInteger.DivRem(b, Base, out re); res = chars[(byte)re] + res;
        } return res;
    }

    // check for a portion of digits, bailing if uneven
    static bool allInQS(BigInteger b) {
        BigInteger re; int c = ic; hs.Clear(); hs.UnionWith(o); while (b > bllim) {
            b = BigInteger.DivRem(b, Base, out re);
            hs.Add((byte)re); c += 1; if (c > hs.Count) return false;
        } return true;
    }

    // check for a portion of digits, all the way to the end
    static bool allInS(BigInteger b) {
        BigInteger re; hs.Clear(); hs.UnionWith(o); while (b > bllim) {
            b = BigInteger.DivRem(b, Base, out re); hs.Add((byte)re);
        } return hs.Count == Base;
    }

    // check for all digits, bailing if uneven
    static bool allInQ(BigInteger b) {
        BigInteger re; int c = 0; hs.Clear(); while (b > 0) {
            b = BigInteger.DivRem(b, Base, out re);
            hs.Add((byte)re); c += 1; if (c > hs.Count) return false;
        } return true;
    }

    // check for all digits, all the way to the end
    static bool allIn(BigInteger b) {
        BigInteger re; hs.Clear(); while (b > 0) {
            b = BigInteger.DivRem(b, Base, out re); hs.Add((byte)re);
        } return hs.Count == Base;
    }

    // parse a string into a BigInteger, using current base
    static BigInteger to10(string s) {
        BigInteger res = 0; foreach (char i in s) res = res * Base + chars.IndexOf(i);
        return res;
    }

    // returns the minimum value string, optionally inserting extra digit
    static string fixup(int n) {
        string res = chars.Substring(0, Base); if (n > 0) res = res.Insert(n, n.ToString());
        return "10" + res.Substring(2);
    }

    // checks the square against the threshold, advances various limits when needed
    static void check(BigInteger sq) {
        if (sq > threshold) {
            o.Remove((byte)chars.IndexOf(ms[blim])); blim -= 1; ic -= 1;
            threshold = limits[bmo - blim - 1]; bllim = to10(ms.Substring(0, blim + 1));
        }
    }

    // performs all the caclulations for the current base
    static void doOne() {
        limits = new List<BigInteger>();
        bmo = (byte)(Base - 1); byte dr = 0; if ((Base & 1) == 1) dr = (byte)(Base >> 1);
        o.Clear(); blim = 0;
        byte id = 0; int inc = 1; long i = 0; DateTime st = DateTime.Now; if (Base == 2) st0 = st;
        byte[] sdr = new byte[bmo]; byte rc = 0; for (i = 0; i < bmo; i++) {
            sdr[i] = (byte)((i * i) % bmo); rc += sdr[i] == dr ? (byte)1 : (byte)0;
            sdr[i] += sdr[i] == 0 ? bmo : (byte)0;
        } i = 0; if (dr > 0) {
            id = Base;
            for (i = 1; i <= dr; i++) if (sdr[i] >= dr) if (id > sdr[i]) id = sdr[i]; id -= dr;
            i = 0;
        } ms = fixup(id);
        BigInteger sq = to10(ms); BigInteger rt = new BigInteger(Math.Sqrt((double)sq) + 1);
        sq = rt * rt; if (Base > 9) {
            for (int j = 1; j < Base; j++)
                limits.Add(to10(ms.Substring(0, j) + new string(chars[bmo], Base - j + (rc > 0 ? 0 : 1))));
            limits.Reverse(); while (sq < limits[0]) { rt++; sq = rt * rt; }
        }
        BigInteger dn = (rt << 1) + 1; BigInteger d = 1; if (Base > 3 && rc > 0) {
            while (sq % bmo != dr) { rt += 1; sq += dn; dn += 2; } // alligns sq to dr
            inc = bmo / rc;
            if (inc > 1) { dn += rt * (inc - 2) - 1; d = inc * inc; }
            dn += dn + d;
        }
        d <<= 1; if (Base > 9) {
            blim = 0; while (sq < limits[bmo - blim - 1]) blim++; ic = (byte)(blim + 1);
            threshold = limits[bmo - blim - 1];
            if (blim > 0) for (byte j = 0; j <= blim; j++) o.Add((byte)chars.IndexOf(ms[j]));
            if (blim > 0) bllim = to10(ms.Substring(0, blim + 1)); else bllim = 0;
            if (Base > 5 && rc > 0)
                do { if (allInQS(sq)) break; sq += dn; dn += d; i += 1; check(sq); } while (true);
            else
                do { if (allInS(sq)) break; sq += dn; dn += d; i += 1; check(sq); } while (true);
        } else {
            if (Base > 5 && rc > 0)
                do { if (allInQ(sq)) break; sq += dn; dn += d; i += 1; } while (true);
            else
                do { if (allIn(sq)) break; sq += dn; dn += d; i += 1; } while (true);
        } rt += i * inc;
        Console.WriteLine("{0,3}  {1,2}  {2,2} {3,20} -> {4,-40} {5,10} {6,9:0.0000}s  {7,9:0.0000}s",
            Base, inc, (id > 0 ? chars.Substring(id, 1) : " "), toStr(rt), toStr(sq), i,
            (DateTime.Now - st).TotalSeconds, (DateTime.Now - st0).TotalSeconds);
    }

    static void Main(string[] args) {
        Console.WriteLine("base inc id                 root    square" +
            "                                   test count    time        total");
        for (Base = 2; Base <= 28; Base++) doOne();
        Console.WriteLine("Elasped time was {0,8:0.00} minutes", (DateTime.Now - st0).TotalMinutes);
    }
}

Output:

base inc id                 root    square                                   test count    time        total
  2   1                       10 -> 100                                               0    0.0050s     0.0050s
  3   1                       22 -> 2101                                              4    0.0000s     0.0050s
  4   3                       33 -> 3201                                              2    0.0010s     0.0060s
  5   1   2                  243 -> 132304                                           14    0.0000s     0.0060s
  6   5                      523 -> 452013                                           20    0.0000s     0.0060s
  7   6                     1431 -> 2450361                                          34    0.0000s     0.0060s
  8   7                     3344 -> 13675420                                         41    0.0000s     0.0060s
  9   4                    11642 -> 136802574                                       289    0.0010s     0.0070s
 10   3                    32043 -> 1026753849                                       17    0.0050s     0.0120s
 11  10                   111453 -> 1240A536789                                    1498    0.0010s     0.0130s
 12  11                   3966B9 -> 124A7B538609                                   6883    0.0040s     0.0170s
 13   1   3              3828943 -> 10254773CA86B9                                 8242    0.0439s     0.0609s
 14  13                  3A9DB7C -> 10269B8C57D3A4                                 1330    0.0010s     0.0619s
 15  14                 1012B857 -> 102597BACE836D4                                4216    0.0020s     0.0638s
 16  15                 404A9D9B -> 1025648CFEA37BD9                              18457    0.0100s     0.0738s
 17   1   1            423F82GA9 -> 101246A89CGFB357ED                           195112    0.2783s     0.3521s
 18  17                44B482CAD -> 10236B5F8EG4AD9CH7                            30440    0.0199s     0.3720s
 19   6               1011B55E9A -> 10234DHBG7CI8F6A9E5                           93021    0.0589s     0.4309s
 20  19               49DGIH5D3G -> 1024E7CDI3HB695FJA8G                       11310604    6.9833s     7.4142s
 21   1   6          4C9HE5FE27F -> 1023457DG9HI8J6B6KCEAF                       601843    1.0871s     8.5013s
 22  21              4F94788GJ0F -> 102369FBGDEJ48CHI7LKA5                     27804949   18.3290s    26.8302s
 23  22             1011D3EL56MC -> 10234ACEDKG9HM8FBJIL756                    17710217   11.4105s    38.2407s
 24  23             4LJ0HDGF0HD3 -> 102345B87HFECKJNIGMDLA69                    4266555    2.4763s    40.7171s
 25  12            1011E145FHGHM -> 102345DOECKJ6GFB8LIAM7NH9                  78092124   52.6831s    93.4012s
 26   5            52K8N53BDM99K -> 1023458LO6IEMKG79FPCHNJDBA                402922568  287.9058s   381.3080s
 27  26           1011F11E37OBJJ -> 1023458ELOMDHBIJFGKP7CQ9N6A               457555293  326.1714s   707.4794s
 28   9           58A3CKP3N4CQD7 -> 1023456CGJBIRQEDHP98KMOAN7FL              749592976  508.4498s  1215.9292s
Elasped time was    20.27 minutes

C++

Translation of: C#

A stripped down version of the C#, using unsigned longs instead of BigIntegers, and shifted bits instead of a HashSet accumulator.

#include <string>
#include <iostream> 
#include <cstdlib>
#include <math.h>
#include <chrono>
#include <iomanip>

using namespace std;

const int maxBase = 16;  // maximum base tabulated
int base, bmo, tc; // globals: base, base minus one, test count
const string chars = "0123456789ABCDEF"; // characters to use for the different bases
unsigned long long full; // for allIn() testing

// converts base 10 to string representation of the current base
string toStr(const unsigned long long ull) {
	unsigned long long u = ull; string res = ""; while (u > 0) {
		lldiv_t result1 = lldiv(u, base); res = chars[(int)result1.rem] + res;
		u = (unsigned long long)result1.quot;
	} return res;
}

// converts string to base 10
unsigned long long to10(string s) {
	unsigned long long res = 0; for (char i : s) res = res * base + chars.find(i); return res;
}

// determines whether all characters are present
bool allIn(const unsigned long long ull) {
	unsigned long long u, found; u = ull; found = 0; while (u > 0) {
		lldiv_t result1 = lldiv(u, base); found |= (unsigned long long)1 << result1.rem;
		u = result1.quot;
	} return found == full;
}

// returns the minimum value string, optionally inserting extra digit
string fixup(int n) {
	string res = chars.substr(0, base); if (n > 0) res = res.insert(n, chars.substr(n, 1));
	return "10" + res.substr(2);
}

// perform the calculations for one base
void doOne() {
	bmo = base - 1; tc = 0; unsigned long long sq, rt, dn, d;
	int id = 0, dr = (base & 1) == 1 ? base >> 1 : 0, inc = 1, sdr[maxBase] = { 0 };
	full = ((unsigned long long)1 << base) - 1;
	int rc = 0; for (int i = 0; i < bmo; i++) {
		sdr[i] = (i * i) % bmo; if (sdr[i] == dr) rc++; if (sdr[i] == 0) sdr[i] += bmo;
	}
	if (dr > 0) {
		id = base; for (int i = 1; i <= dr; i++)
			if (sdr[i] >= dr) if (id > sdr[i]) id = sdr[i]; id -= dr;
	}
	sq = to10(fixup(id)); rt = (unsigned long long)sqrt(sq) + 1; sq = rt * rt;
	dn = (rt << 1) + 1; d = 1; if (base > 3 && rc > 0) {
		while (sq % bmo != dr) { rt += 1; sq += dn; dn += 2; } // alligns sq to dr
		inc = bmo / rc; if (inc > 1) { dn += rt * (inc - 2) - 1; d = inc * inc; }
		dn += dn + d;
	} d <<= 1;
	do { if (allIn(sq)) break; sq += dn; dn += d; tc++; } while (true);
	rt += tc * inc;
	cout << setw(4) << base << setw(3) << inc << "  " << setw(2)
		<< (id > 0 ? chars.substr(id, 1) : " ") << setw(10) << toStr(rt) << "  "
		<< setw(20) << left << toStr(sq) << right << setw(12) << tc << endl;
}

int main() {
	cout << "base inc id      root  sqr                   test count" << endl;
	auto st = chrono::system_clock::now();
	for (base = 2; base <= maxBase; base++) doOne();
	chrono::duration<double> et = chrono::system_clock::now() - st;
	cout << "\nComputation time was " << et.count() * 1000 << " milliseconds" << endl;
	return 0;
}

Output:

base inc id      root  sqr                   test count
   2  1            10  100                            0
   3  1            22  2101                           4
   4  3            33  3201                           2
   5  1   2       243  132304                        14
   6  5           523  452013                        20
   7  6          1431  2450361                       34
   8  7          3344  13675420                      41
   9  4         11642  136802574                    289
  10  3         32043  1026753849                    17
  11 10        111453  1240A536789                 1498
  12 11        3966B9  124A7B538609                6883
  13  1   3   3828943  10254773CA86B9              8242
  14 13       3A9DB7C  10269B8C57D3A4              1330
  15 14      1012B857  102597BACE836D4             4216
  16 15      404A9D9B  1025648CFEA37BD9           18457

Computation time was 25.9016 milliseconds

D

Translation of: C

import std.algorithm;
import std.exception;
import std.math;
import std.stdio;
import std.string;

string toBaseN(const long num, const int base)
in (base > 1, "base cannot be less than 2")
body {
    immutable ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    enforce(base < ALPHABET.length, "base cannot be represented");

    char[] result;
    long cnum = abs(num);
    while (cnum > 0) {
        auto rem = cast(uint) (cnum % base);
        result ~= ALPHABET[rem];
        cnum = (cnum - rem) / base;
    }

    if (num < 0) {
        result ~= '-';
    }
    return result.reverse.idup;
}

int countUnique(string buf) {
    bool[char] m;
    foreach (c; buf) {
        m[c] = true;
    }
    return m.keys.length;
}

void find(int base) {
    long nmin = cast(long) pow(cast(real) base, 0.5 * (base - 1));

    for (long n = nmin; /*blank*/; n++) {
        auto sq = n * n;
        enforce(n * n > 0, "Overflowed the square");
        string sqstr = toBaseN(sq, base);
        if (sqstr.length >= base && countUnique(sqstr) == base) {
            string nstr = toBaseN(n, base);
            writefln("Base %2d : Num %8s Square %16s", base, nstr, sqstr);
            return;
        }
    }
}

void main() {
    foreach (i; 2..17) {
        find(i);
    }
}

Output:

Base  2 : Num       10 Square              100
Base  3 : Num       22 Square             2101
Base  4 : Num       33 Square             3201
Base  5 : Num      243 Square           132304
Base  6 : Num      523 Square           452013
Base  7 : Num     1431 Square          2450361
Base  8 : Num     3344 Square         13675420
Base  9 : Num    11642 Square        136802574
Base 10 : Num    32043 Square       1026753849
Base 11 : Num   111453 Square      1240A536789
Base 12 : Num   3966B9 Square     124A7B538609
Base 13 : Num  3828943 Square   10254773CA86B9
Base 14 : Num  3A9DB7C Square   10269B8C57D3A4
Base 15 : Num 1012B857 Square  102597BACE836D4
Base 16 : Num 404A9D9B Square 1025648CFEA37BD9

Delphi

Works with: Delphi version 6.0

Library: SysUtils,StdCtrls

function GetRadixString(L: int64; Radix: Byte): string;
{Converts integer a string of any radix}
const RadixChars: array[0..35] Of char =
    ('0', '1', '2', '3', '4', '5', '6', '7',
     '8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
     'G','H', 'I', 'J', 'K', 'L', 'M', 'N',
     'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
     'W', 'X', 'Y', 'Z');
var I: integer;
var S: string;
var Sign: string[1];
begin
Result:='';
If (L < 0) then
	begin
	Sign:='-';
	L:=Abs(L);
	end
else Sign:='';
S:='';
repeat
	begin
	I:=L mod Radix;
	S:=RadixChars[I] + S;
	L:=L div Radix;
	end
until L = 0;
Result:=Sign + S;
end;


function HasUniqueDigits(N: int64; Base: integer): boolean;
{Keep track of unique digits with bits in a mask}
var Mask,Bit: cardinal;
var I,Cnt: integer;
begin
Cnt:=0; Mask:=0;
repeat
	begin
	I:=N mod Base;
	Bit:=1 shl I;
	if (Bit and Mask)=0 then
		begin
		Mask:=Mask or Bit;
		Inc(Cnt);
		end;
	N:=N div Base;
	end
until N = 0;
Result:=Cnt=Base;
end;


function GetStartValue(Base: integer): Int64;
{Start with the first N-Digit number in the base}
var I: integer;
begin
Result:=1;
for I:=1 to Base-1 do Result:=Result*Base;
Result:=Trunc(Sqrt(Result+0.0))-1;
end;


function FindFirstSquare(Base: integer): int64;
{Test squares to find the first one with unique digits}
var Start: int64;
begin
Result:=GetStartValue(Base);
while Result<=high(integer) do
	begin
	if HasUniqueDigits(Result*Result,Base) then break;
	Inc(Result);
	end;
end;


procedure ShowFirstSquares(Memo: TMemo);
{Find and display first perfect square that uses all digits in bases 2-16}
var I: integer;
var N: int64;
var S1,S2: string;
begin
for I:=2 to 16 do
	begin
	N:=FindFirstSquare(I);
	S1:=GetRadixString(N,I);
	S2:=GetRadixString(N*N,I);
	Memo.Lines.Add(Format('Base=%2d   %14s^2 = %16s',[I,S1,S2]));
	end;
end;

Output:

Base= 2               10^2 =              100
Base= 3               22^2 =             2101
Base= 4               33^2 =             3201
Base= 5              243^2 =           132304
Base= 6              523^2 =           452013
Base= 7             1431^2 =          2450361
Base= 8             3344^2 =         13675420
Base= 9            11642^2 =        136802574
Base=10            32043^2 =       1026753849
Base=11           111453^2 =      1240A536789
Base=12           3966B9^2 =     124A7B538609
Base=13          3828943^2 =   10254773CA86B9
Base=14          3A9DB7C^2 =   10269B8C57D3A4
Base=15         1012B857^2 =  102597BACE836D4
Base=16         404A9D9B^2 = 1025648CFEA37BD9
Run Time = 28.2 sec

EasyLang

Translation of: Nim

alpha$ = "0123456789AB"
func$ itoa n b .
   if n > 0
      return itoa (n div b) b & substr alpha$ (n mod b + 1) 1
   .
.
func unique s$ .
   len dig[] 12
   for c$ in strchars s$
      ind = strpos alpha$ c$
      dig[ind] = 1
   .
   for v in dig[]
      cnt += v
   .
   return cnt
.
proc find b . .
   n = floor pow b ((b - 1) div 2)
   repeat
      sq = n * n
      sq$ = itoa sq b
      until len sq$ >= b and unique sq$ = b
      n += 1
   .
   n$ = itoa n b
   print "Base " & b & ": " & n$ & "² = " & sq$
.
for base = 2 to 12
   find base
.

Output:

Base 2: 10² = 100
Base 3: 22² = 2101
Base 4: 33² = 3201
Base 5: 243² = 132304
Base 6: 523² = 452013
Base 7: 1431² = 2450361
Base 8: 3344² = 13675420
Base 9: 11642² = 136802574
Base 10: 32043² = 1026753849
Base 11: 111453² = 1240A536789
Base 12: 3966B9² = 124A7B538609

F#

The Task

// Nigel Galloway: May 21st., 2019
let fN g=let g=int64(sqrt(float(pown g (int(g-1L)))))+1L in (Seq.unfold(fun(n,g)->Some(n,(n+g,g+2L))))(g*g,g*2L+1L)
let fG n g=Array.unfold(fun n->if n=0L then None else let n,g=System.Math.DivRem(n,g) in Some(g,n)) n
let fL g=let n=set[0L..g-1L] in Seq.find(fun x->set(fG x g)=n) (fN g)
let toS n g=let a=Array.concat [[|'0'..'9'|];[|'a'..'f'|]] in System.String(Array.rev(fG n g)|>Array.map(fun n->a.[(int n)]))
[2L..16L]|>List.iter(fun n->let g=fL n in printfn "Base %d: %s² -> %s" n (toS (int64(sqrt(float g))) n) (toS g n))

Output:

Base 2: 10² -> 100
Base 3: 22² -> 2101
Base 4: 33² -> 3201
Base 5: 243² -> 132304
Base 6: 523² -> 452013
Base 7: 1431² -> 2450361
Base 8: 3344² -> 13675420
Base 9: 11642² -> 136802574
Base 10: 32043² -> 1026753849
Base 11: 111453² -> 1240a536789
Base 12: 3966b9² -> 124a7b538609
Base 13: 3828943² -> 10254773ca86b9
Base 14: 3a9db7c² -> 10269b8c57d3a4
Base 15: 1012b857² -> 102597bace836d4
Base 16: 404a9d9b² -> 1025648cfea37bd9

Using Factorial base numbers indexing permutations of a collection

On the discussion page for Factorial base numbers indexing permutations of a collection an anonymous contributor queries the value of Factorial base numbers indexing permutations of a collection. Well let's see him use an inverse Knuth shuffle to partially solve this task. This solution only applies to bases that do not require an extra digit. Still I think it's short and interesting.
Note that the minimal candidate is 1.0....0 as a factorial base number.

// Nigel Galloway: May 30th., 2019
let fN n g=let g=n|>Array.rev|>Array.mapi(fun i n->(int64 n)*(pown g i))|>Array.sum
           let n=int64(sqrt (float g)) in g=(n*n)
let fG g=lN([|yield 1; yield! Array.zeroCreate(g-2)|])|>Seq.map(fun n->lN2p n [|0..(g-1)|]) |> Seq.filter(fun n->fN n (int64 g))
printfn "%A" (fG 12|>Seq.head) // -> [|1; 2; 4; 10; 7; 11; 5; 3; 8; 6; 0; 9|]
printfn "%A" (fG 14|>Seq.head) // -> [|1; 0; 2; 6; 9; 11; 8; 12; 5; 7; 13; 3; 10; 4|]

Factor

The only thing this program does to save time is start the search at a root high enough such that its square has enough digits to be pandigital.

USING: assocs formatting fry kernel math math.functions
math.parser math.ranges math.statistics sequences ;
IN: rosetta-code.A260182

: pandigital? ( n base -- ? )
    [ >base histogram assoc-size ] keep >= ;

! Return the smallest decimal integer square root whose squared
! digit length in base n is at least n.
: search-start ( base -- n ) dup 1 - ^ sqrt ceiling >integer ;

: find-root ( base -- n )
    [ search-start ] [ ] bi
    '[ dup sq _ pandigital? ] [ 1 + ] until ;

: show-base ( base -- )
    dup find-root dup sq pick [ >base ] curry bi@
    "Base %2d: %8s squared = %s\n" printf ;

: main ( -- ) 2 16 [a,b] [ show-base ] each ;

MAIN: main

Output:

Base  2:       10 squared = 100
Base  3:       22 squared = 2101
Base  4:       33 squared = 3201
Base  5:      243 squared = 132304
Base  6:      523 squared = 452013
Base  7:     1431 squared = 2450361
Base  8:     3344 squared = 13675420
Base  9:    11642 squared = 136802574
Base 10:    32043 squared = 1026753849
Base 11:   111453 squared = 1240a536789
Base 12:   3966b9 squared = 124a7b538609
Base 13:  3828943 squared = 10254773ca86b9
Base 14:  3a9db7c squared = 10269b8c57d3a4
Base 15: 1012b857 squared = 102597bace836d4
Base 16: 404a9d9b squared = 1025648cfea37bd9

Forth

#! /usr/bin/gforth-fast

: 2^  1 swap lshift ;

: sq  s" dup *" evaluate ; immediate

: min-root  ( -- n )  \ minimum root that can be pandigitial
    base @ s>f fdup 1e f- 0.5e f* f** f>s ;

: pandigital? ( n -- f )
    0 swap  \ bitmask
    begin
        base @ /mod
        >r 2^ or r>
    dup 0= until drop
    base @ 2^ 1- = ;

: panroot ( -- n ) \ get the minimum square root using the variable BASE.
    min-root 1- begin
        1+
    dup sq pandigital? until ;

: .squares ( -- )
    base @ 17 2 do
        i base !
        i 2 dec.r 3 spaces panroot dup 8 .r ." ² = " sq . cr
    loop base ! ;

.squares
bye

Output:

 2         10² = 100 
 3         22² = 2101 
 4         33² = 3201 
 5        243² = 132304 
 6        523² = 452013 
 7       1431² = 2450361 
 8       3344² = 13675420 
 9      11642² = 136802574 
10      32043² = 1026753849 
11     111453² = 1240A536789 
12     3966B9² = 124A7B538609 
13    3828943² = 10254773CA86B9 
14    3A9DB7C² = 10269B8C57D3A4 
15   1012B857² = 102597BACE836D4 
16   404A9D9B² = 1025648CFEA37BD9 

FreeBASIC

Translation of: XPLo

#define floor(x) ((x*2.0-0.5) Shr 1)

Dim Shared As Double n, base_ = 2.  ' Base is a reserved word on FB

Sub NumOut(n As Double)             'Display n in the specified base
    Dim As Integer remainder = Fix(n Mod base_)
    n = floor(n / base_)
    If n <> 0. Then NumOut(n)
    Print Chr(remainder + Iif(remainder <= 9, Asc("0"), Asc("A")-10));
End Sub

Function isPandigital(n As Double) As Boolean
    Dim As Integer used, remainder
    used = 0
    While n <> 0.
        remainder = Fix(n Mod base_)
        n = floor(n / base_)
        used Or= 1 Shl remainder
    Wend
    Return used = (1 Shl Fix(base_)) - 1
End Function

Do
    n = floor(Sqr(base_ ^ (base_-1.)))
    Do
        If isPandigital(n*n) Then
            Print Using "Base ##: "; base_;
            NumOut(n)
            Print "^2 = ";
            NumOut(n*n)
            Print
            Exit Do
        End If
        n += 1.
    Loop
    base_ += 1.
Loop Until base_ > 14.

Sleep

Output:

Base  2: 10^2 = 100
Base  3: 22^2 = 2101
Base  4: 33^2 = 3201
Base  5: 243^2 = 132304
Base  6: 523^2 = 452013
Base  7: 1431^2 = 2450361
Base  8: 3344^2 = 13675420
Base  9: 11642^2 = 136802574
Base 10: 32043^2 = 1026753849
Base 11: 111453^2 = 1240A536789
Base 12: 3966B9^2 = 124A7B538609
Base 13: 3828943^2 = 10254773CA86B9
Base 14: 3A9DB7C^2 = 10269B8C57D3A4

Go

This takes advantage of major optimizations described by Nigel Galloway and Thundergnat (inspired by initial pattern analysis by Hout) in the Discussion page and a minor optimization contributed by myself.

package main

import (
    "fmt"
    "math/big"
    "strconv"
    "time"
)

const maxBase = 27
const minSq36 = "1023456789abcdefghijklmnopqrstuvwxyz"
const minSq36x = "10123456789abcdefghijklmnopqrstuvwxyz"

var bigZero = new(big.Int)
var bigOne = new(big.Int).SetUint64(1)

func containsAll(sq string, base int) bool {
    var found [maxBase]byte
    le := len(sq)
    reps := 0
    for _, r := range sq {
        d := r - 48
        if d > 38 {
            d -= 39
        }
        found[d]++
        if found[d] > 1 {
            reps++
            if le-reps < base {
                return false
            }
        }
    }
    return true
}

func sumDigits(n, base *big.Int) *big.Int {
    q := new(big.Int).Set(n)
    r := new(big.Int)
    sum := new(big.Int).Set(bigZero)
    for q.Cmp(bigZero) == 1 {
        q.QuoRem(q, base, r)
        sum.Add(sum, r)
    }
    return sum
}

func digitalRoot(n *big.Int, base int) int {
    root := new(big.Int)
    b := big.NewInt(int64(base))
    for i := new(big.Int).Set(n); i.Cmp(b) >= 0; i.Set(root) {
        root.Set(sumDigits(i, b))
    }
    return int(root.Int64())
}

func minStart(base int) (string, uint64, int) {
    nn := new(big.Int)
    ms := minSq36[:base]
    nn.SetString(ms, base)
    bdr := digitalRoot(nn, base)
    var drs []int
    var ixs []uint64
    for n := uint64(1); n < uint64(2*base); n++ {
        nn.SetUint64(n * n)
        dr := digitalRoot(nn, base)
        if dr == 0 {
            dr = int(n * n)
        }
        if dr == bdr {
            ixs = append(ixs, n)
        }
        if n < uint64(base) && dr >= bdr {
            drs = append(drs, dr)
        }
    }
    inc := uint64(1)
    if len(ixs) >= 2 && base != 3 {
        inc = ixs[1] - ixs[0]
    }
    if len(drs) == 0 {
        return ms, inc, bdr
    }
    min := drs[0]
    for _, dr := range drs[1:] {
        if dr < min {
            min = dr
        }
    }
    rd := min - bdr
    if rd == 0 {
        return ms, inc, bdr
    }
    if rd == 1 {
        return minSq36x[:base+1], 1, bdr
    }
    ins := string(minSq36[rd])
    return (minSq36[:rd] + ins + minSq36[rd:])[:base+1], inc, bdr
}

func main() {
    start := time.Now()
    var nb, nn big.Int
    for n, k, base := uint64(2), uint64(1), 2; ; n += k {
        if base > 2 && n%uint64(base) == 0 {
            continue
        } 
        nb.SetUint64(n)
        sq := nb.Mul(&nb, &nb).Text(base)
        if !containsAll(sq, base) {
            continue
        }
        ns := strconv.FormatUint(n, base)
        tt := time.Since(start).Seconds()
        fmt.Printf("Base %2d:%15s² = %-27s in %8.3fs\n", base, ns, sq, tt)
        if base == maxBase {
            break
        }
        base++
        ms, inc, bdr := minStart(base)
        k = inc
        nn.SetString(ms, base)
        nb.Sqrt(&nn)
        if nb.Uint64() < n+1 {
            nb.SetUint64(n + 1)
        }
        if k != 1 {
            for {
                nn.Mul(&nb, &nb)
                dr := digitalRoot(&nn, base)
                if dr == bdr {
                    n = nb.Uint64() - k
                    break
                }
                nb.Add(&nb, bigOne)
            }
        } else {
            n = nb.Uint64() - k
        }
    }
}

Output:

Timings (in seconds) are for my Intel Core i7-8565U laptop using Go 1.12.9 on Ubuntu 18.04.

Base  2:             10² = 100                         in    0.000s
Base  3:             22² = 2101                        in    0.000s
Base  4:             33² = 3201                        in    0.000s
Base  5:            243² = 132304                      in    0.000s
Base  6:            523² = 452013                      in    0.000s
Base  7:           1431² = 2450361                     in    0.000s
Base  8:           3344² = 13675420                    in    0.000s
Base  9:          11642² = 136802574                   in    0.000s
Base 10:          32043² = 1026753849                  in    0.000s
Base 11:         111453² = 1240a536789                 in    0.001s
Base 12:         3966b9² = 124a7b538609                in    0.002s
Base 13:        3828943² = 10254773ca86b9              in    0.004s
Base 14:        3a9db7c² = 10269b8c57d3a4              in    0.005s
Base 15:       1012b857² = 102597bace836d4             in    0.006s
Base 16:       404a9d9b² = 1025648cfea37bd9            in    0.008s
Base 17:      423f82ga9² = 101246a89cgfb357ed          in    0.074s
Base 18:      44b482cad² = 10236b5f8eg4ad9ch7          in    0.084s
Base 19:     1011b55e9a² = 10234dhbg7ci8f6a9e5         in    0.116s
Base 20:     49dgih5d3g² = 1024e7cdi3hb695fja8g        in    3.953s
Base 21:    4c9he5fe27f² = 1023457dg9hi8j6b6kceaf      in    4.174s
Base 22:    4f94788gj0f² = 102369fbgdej48chi7lka5      in   14.084s
Base 23:   1011d3el56mc² = 10234acedkg9hm8fbjil756     in   20.563s
Base 24:   4lj0hdgf0hd3² = 102345b87hfeckjnigmdla69    in   22.169s
Base 25:  1011e145fhghm² = 102345doeckj6gfb8liam7nh9   in   52.082s
Base 26:  52k8n53bdm99k² = 1023458lo6iemkg79fpchnjdba  in  209.808s
Base 27: 1011f11e37objj² = 1023458elomdhbijfgkp7cq9n6a in  401.503s

It's possible to go beyond base 27 by using big.Int (rather than uint64) for N as well as N² though this takes about 15% longer to reach base 27 itself.

For example, to reach base 28 (the largest base shown in the OEIS table) we have:

package main

import (
    "fmt"
    "math/big"
    "time"
)

const maxBase = 28

// etc

func main() {
    start := time.Now()
    var n, k, b, t, nn big.Int
    n.SetUint64(2)
    k.SetUint64(1)
    b.SetUint64(2)
    for base := 2; ; n.Add(&n, &k) { 
       if base > 2 && t.Rem(&n, &b).Cmp(bigZero) == 0 {
            continue
        }
        sq := nn.Mul(&n, &n).Text(base)
        if !containsAll(sq, base) {
            continue
        }
        ns := n.Text(base)
        tt := time.Since(start).Seconds()
        fmt.Printf("Base %2d:%15s² = %-28s in %8.3fs\n", base, ns, sq, tt)
        if base == maxBase {
            break
        }
        base++
        b.SetUint64(uint64(base))
        ms, inc, bdr := minStart(base)
        k.SetUint64(inc)
        nn.SetString(ms, base)
        n.Sqrt(&nn)
        t.Add(&n, bigOne)
        if n.Cmp(&t) == -1 {
            n.Set(&t)
        }
        if inc != 1 {
            for {
                nn.Mul(&n, &n)
                dr := digitalRoot(&nn, base)
                if dr == bdr {
                    n.Sub(&n, &k)
                    break
                }
                n.Add(&n, bigOne)
            }
        } else {
            n.Sub(&n, &k)
        }
    }
}

Output:

Base  2:             10² = 100                          in    0.000s
Base  3:             22² = 2101                         in    0.000s
Base  4:             33² = 3201                         in    0.000s
Base  5:            243² = 132304                       in    0.000s
Base  6:            523² = 452013                       in    0.000s
Base  7:           1431² = 2450361                      in    0.000s
Base  8:           3344² = 13675420                     in    0.000s
Base  9:          11642² = 136802574                    in    0.000s
Base 10:          32043² = 1026753849                   in    0.000s
Base 11:         111453² = 1240a536789                  in    0.001s
Base 12:         3966b9² = 124a7b538609                 in    0.003s
Base 13:        3828943² = 10254773ca86b9               in    0.005s
Base 14:        3a9db7c² = 10269b8c57d3a4               in    0.006s
Base 15:       1012b857² = 102597bace836d4              in    0.007s
Base 16:       404a9d9b² = 1025648cfea37bd9             in    0.010s
Base 17:      423f82ga9² = 101246a89cgfb357ed           in    0.088s
Base 18:      44b482cad² = 10236b5f8eg4ad9ch7           in    0.100s
Base 19:     1011b55e9a² = 10234dhbg7ci8f6a9e5          in    0.138s
Base 20:     49dgih5d3g² = 1024e7cdi3hb695fja8g         in    4.632s
Base 21:    4c9he5fe27f² = 1023457dg9hi8j6b6kceaf       in    4.894s
Base 22:    4f94788gj0f² = 102369fbgdej48chi7lka5       in   16.282s
Base 23:   1011d3el56mc² = 10234acedkg9hm8fbjil756      in   23.697s
Base 24:   4lj0hdgf0hd3² = 102345b87hfeckjnigmdla69     in   25.525s
Base 25:  1011e145fhghm² = 102345doeckj6gfb8liam7nh9    in   59.592s
Base 26:  52k8n53bdm99k² = 1023458lo6iemkg79fpchnjdba   in  239.850s
Base 27: 1011f11e37objj² = 1023458elomdhbijfgkp7cq9n6a  in  461.305s
Base 28: 58a3ckp3n4cqd7² = 1023456cgjbirqedhp98kmoan7fl in  911.059s

Haskell

Translation of: F#

import           Control.Monad (guard)
import           Data.List (find, unfoldr)
import           Data.Char (intToDigit)
import qualified Data.Set as Set
import           Text.Printf (printf)
 
digits :: Integral a => a -> a -> [a]
digits 
  b = unfoldr
        (((>>) . guard . (0 /=)) <*> (pure . ((,) <$> (`mod` b) <*> (`div` b))))
 
sequenceForBaseN :: Integral a => a -> [a]
sequenceForBaseN
  b = unfoldr (\(v, n) -> Just (v, (v + n, n + 2))) (i ^ 2, i * 2 + 1)
  where
    i = succ (round $ sqrt (realToFrac (b ^ pred b)))
 
searchSequence :: Integral a => a -> Maybe a
searchSequence
  b = find ((digitsSet ==) . Set.fromList . digits b) (sequenceForBaseN b)
  where
    digitsSet = Set.fromList [0 .. pred b]
 
display :: Integer -> Integer -> String
display b n = map (intToDigit . fromIntegral) $ reverse $ digits b n
 
main :: IO ()
main = mapM_
  (\b -> case searchSequence b of
     Just n  -> printf
       "Base %2d: %8s² -> %16s\n"
       b
       (display b (squareRootValue n))
       (display b n)
     Nothing -> pure ())
  [2 .. 16]
  where
    squareRootValue = round . sqrt . realToFrac

Output:

Base  2:       10² ->              100
Base  3:       22² ->             2101
Base  4:       33² ->             3201
Base  5:      243² ->           132304
Base  6:      523² ->           452013
Base  7:     1431² ->          2450361
Base  8:     3344² ->         13675420
Base  9:    11642² ->        136802574
Base 10:    32043² ->       1026753849
Base 11:   111453² ->      1240a536789
Base 12:   3966b9² ->     124a7b538609
Base 13:  3828943² ->   10254773ca86b9
Base 14:  3a9db7c² ->   10269b8c57d3a4
Base 15: 1012b857² ->  102597bace836d4
Base 16: 404a9d9b² -> 1025648cfea37bd9

J

pandigital=: [ = [: # [: ~. #.inv NB. BASE pandigital Y

   assert 10 pandigital 1234567890
   assert -. 10 pandigital 123456789

   [BASES=: 2+i.11
2 3 4 5 6 7 8 9 10 11 12

   A=: BASES pandigital&>/ *: i. 1000000  NB. A is a Boolean array marking all pandigital squares in bases 2--12 of 0--999999 squared

   +/"1 A      NB. tally of them per base
999998 999298 976852 856925 607519 324450 114943 33757 4866 416 3

   ] SOLUTION=: A (i."1) 1  NB. but we need only the first
2 8 15 73 195 561 1764 7814 32043 177565 944493

   representation=: (Num_j_ , 26 }. Alpha_j_) {~ #.inv  NB. BASE representation INTEGER

   (<;._2'base;base 10;base BASE;') , BASES ([ ; ] ; representation)&> *: SOLUTION
+----+------------+------------+
|base|base 10     |base BASE   |
+----+------------+------------+
|2   |4           |100         |
+----+------------+------------+
|3   |64          |2101        |
+----+------------+------------+
|4   |225         |3201        |
+----+------------+------------+
|5   |5329        |132304      |
+----+------------+------------+
|6   |38025       |452013      |
+----+------------+------------+
|7   |314721      |2450361     |
+----+------------+------------+
|8   |3111696     |13675420    |
+----+------------+------------+
|9   |61058596    |136802574   |
+----+------------+------------+
|10  |1026753849  |1026753849  |
+----+------------+------------+
|11  |31529329225 |1240a536789 |
+----+------------+------------+
|12  |892067027049|124a7b538609|
+----+------------+------------+

Java

Translation of: C#

import java.math.BigInteger;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Program {
    static final String ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz|";
    static byte base, bmo, blim, ic;
    static long st0;
    static BigInteger bllim, threshold;
    static Set<Byte> hs = new HashSet<>();
    static Set<Byte> o = new HashSet<>();
    static final char[] chars = ALPHABET.toCharArray();
    static List<BigInteger> limits;
    static String ms;

    static int indexOf(char c) {
        for (int i = 0; i < chars.length; ++i) {
            if (chars[i] == c) {
                return i;
            }
        }
        return -1;
    }

    // convert BigInteger to string using current base
    static String toStr(BigInteger b) {
        BigInteger bigBase = BigInteger.valueOf(base);
        StringBuilder res = new StringBuilder();
        while (b.compareTo(BigInteger.ZERO) > 0) {
            BigInteger[] divRem = b.divideAndRemainder(bigBase);
            res.append(chars[divRem[1].intValue()]);
            b = divRem[0];
        }
        return res.toString();
    }

    // check for a portion of digits, bailing if uneven
    static boolean allInQS(BigInteger b) {
        BigInteger bigBase = BigInteger.valueOf(base);
        int c = ic;
        hs.clear();
        hs.addAll(o);
        while (b.compareTo(bllim) > 0) {
            BigInteger[] divRem = b.divideAndRemainder(bigBase);
            hs.add(divRem[1].byteValue());
            c++;

            if (c > hs.size()) {
                return false;
            }
            b = divRem[0];
        }
        return true;
    }

    // check for a portion of digits, all the way to the end
    static boolean allInS(BigInteger b) {
        BigInteger bigBase = BigInteger.valueOf(base);
        hs.clear();
        hs.addAll(o);
        while (b.compareTo(bllim) > 0) {
            BigInteger[] divRem = b.divideAndRemainder(bigBase);
            hs.add(divRem[1].byteValue());
            b = divRem[0];
        }
        return hs.size() == base;
    }

    // check for all digits, bailing if uneven
    static boolean allInQ(BigInteger b) {
        BigInteger bigBase = BigInteger.valueOf(base);
        int c = 0;
        hs.clear();
        while (b.compareTo(BigInteger.ZERO) > 0) {
            BigInteger[] divRem = b.divideAndRemainder(bigBase);
            hs.add(divRem[1].byteValue());
            c++;
            if (c > hs.size()) {
                return false;
            }
            b = divRem[0];
        }
        return true;
    }

    // check for all digits, all the way to the end
    static boolean allIn(BigInteger b) {
        BigInteger bigBase = BigInteger.valueOf(base);
        hs.clear();
        while (b.compareTo(BigInteger.ZERO) > 0) {
            BigInteger[] divRem = b.divideAndRemainder(bigBase);
            hs.add(divRem[1].byteValue());
            b = divRem[0];
        }
        return hs.size() == base;
    }

    // parse a string into a BigInteger, using current base
    static BigInteger to10(String s) {
        BigInteger bigBase = BigInteger.valueOf(base);
        BigInteger res = BigInteger.ZERO;
        for (int i = 0; i < s.length(); ++i) {
            char c = s.charAt(i);
            int idx = indexOf(c);
            BigInteger bigIdx = BigInteger.valueOf(idx);
            res = res.multiply(bigBase).add(bigIdx);
        }
        return res;
    }

    // returns the minimum value string, optionally inserting extra digit
    static String fixup(int n) {
        String res = ALPHABET.substring(0, base);
        if (n > 0) {
            StringBuilder sb = new StringBuilder(res);
            sb.insert(n, n);
            res = sb.toString();
        }
        return "10" + res.substring(2);
    }

    // checks the square against the threshold, advances various limits when needed
    static void check(BigInteger sq) {
        if (sq.compareTo(threshold) > 0) {
            o.remove((byte) indexOf(ms.charAt(blim)));
            blim--;
            ic--;
            threshold = limits.get(bmo - blim - 1);
            bllim = to10(ms.substring(0, blim + 1));
        }
    }

    // performs all the calculations for the current base
    static void doOne() {
        limits = new ArrayList<>();
        bmo = (byte) (base - 1);
        byte dr = 0;
        if ((base & 1) == 1) {
            dr = (byte) (base >> 1);
        }
        o.clear();
        blim = 0;
        byte id = 0;
        int inc = 1;
        long st = System.nanoTime();
        byte[] sdr = new byte[bmo];
        byte rc = 0;
        for (int i = 0; i < bmo; i++) {
            sdr[i] = (byte) ((i * i) % bmo);
            rc += sdr[i] == dr ? (byte) 1 : (byte) 0;
            sdr[i] += sdr[i] == 0 ? bmo : (byte) 0;
        }
        long i = 0;
        if (dr > 0) {
            id = base;
            for (i = 1; i <= dr; i++) {
                if (sdr[(int) i] >= dr) {
                    if (id > sdr[(int) i]) {
                        id = sdr[(int) i];
                    }
                }
            }
            id -= dr;
            i = 0;
        }
        ms = fixup(id);
        BigInteger sq = to10(ms);
        BigInteger rt = BigInteger.valueOf((long) (Math.sqrt(sq.doubleValue()) + 1));
        sq = rt.multiply(rt);
        if (base > 9) {
            for (int j = 1; j < base; j++) {
                limits.add(to10(ms.substring(0, j) + String.valueOf(chars[bmo]).repeat(base - j + (rc > 0 ? 0 : 1))));
            }
            Collections.reverse(limits);
            while (sq.compareTo(limits.get(0)) < 0) {
                rt = rt.add(BigInteger.ONE);
                sq = rt.multiply(rt);
            }
        }
        BigInteger dn = rt.shiftLeft(1).add(BigInteger.ONE);
        BigInteger d = BigInteger.ONE;
        if (base > 3 && rc > 0) {
            while (sq.remainder(BigInteger.valueOf(bmo)).compareTo(BigInteger.valueOf(dr)) != 0) {
                rt = rt.add(BigInteger.ONE);
                sq = sq.add(dn);
                dn = dn.add(BigInteger.TWO);
            } // aligns sq to dr
            inc = bmo / rc;
            if (inc > 1) {
                dn = dn.add(rt.multiply(BigInteger.valueOf(inc - 2)).subtract(BigInteger.ONE));
                d = BigInteger.valueOf(inc * inc);
            }
            dn = dn.add(dn).add(d);
        }
        d = d.shiftLeft(1);
        if (base > 9) {
            blim = 0;
            while (sq.compareTo(limits.get(bmo - blim - 1)) < 0) {
                blim++;
            }
            ic = (byte) (blim + 1);
            threshold = limits.get(bmo - blim - 1);
            if (blim > 0) {
                for (byte j = 0; j <= blim; j++) {
                    o.add((byte) indexOf(ms.charAt(j)));
                }
            }
            if (blim > 0) {
                bllim = to10(ms.substring(0, blim + 1));
            } else {
                bllim = BigInteger.ZERO;
            }
            if (base > 5 && rc > 0)
                while (!allInQS(sq)) {
                    sq = sq.add(dn);
                    dn = dn.add(d);
                    i += 1;
                    check(sq);
                }
            else {
                while (!allInS(sq)) {
                    sq = sq.add(dn);
                    dn = dn.add(d);
                    i += 1;
                    check(sq);
                }
            }
        } else {
            if (base > 5 && rc > 0) {
                while (!allInQ(sq)) {
                    sq = sq.add(dn);
                    dn = dn.add(d);
                    i += 1;
                }
            } else {
                while (!allIn(sq)) {
                    sq = sq.add(dn);
                    dn = dn.add(d);
                    i += 1;
                }
            }
        }

        rt = rt.add(BigInteger.valueOf(i * inc));
        long delta1 = System.nanoTime() - st;
        Duration dur1 = Duration.ofNanos(delta1);
        long delta2 = System.nanoTime() - st0;
        Duration dur2 = Duration.ofNanos(delta2);
        System.out.printf(
            "%3d  %2d  %2s %20s -> %-40s %10d %9s  %9s\n",
            base, inc, (id > 0 ? ALPHABET.substring(id, id + 1) : " "), toStr(rt), toStr(sq), i, format(dur1), format(dur2)
        );
    }

    private static String format(Duration d) {
        int minP = d.toMinutesPart();
        int secP = d.toSecondsPart();
        int milP = d.toMillisPart();
        return String.format("%02d:%02d.%03d", minP, secP, milP);
    }

    public static void main(String[] args) {
        System.out.println("base inc id                 root    square                                   test count    time        total");
        st0 = System.nanoTime();
        for (base = 2; base < 28; ++base) {
            doOne();
        }
    }
}

Output:

base inc id                 root    square                                   test count    time        total
  2   1                       01 -> 001                                               0 00:00.030  00:00.030
  3   1                       22 -> 1012                                              4 00:00.000  00:00.040
  4   3                       33 -> 1023                                              2 00:00.000  00:00.042
  5   1   2                  342 -> 403231                                           14 00:00.000  00:00.044
  6   5                      325 -> 310254                                           20 00:00.000  00:00.047
  7   6                     1341 -> 1630542                                          34 00:00.000  00:00.049
  8   7                     4433 -> 02457631                                         41 00:00.000  00:00.051
  9   4                    24611 -> 475208631                                       289 00:00.002  00:00.055
 10   3                    34023 -> 9483576201                                       17 00:00.023  00:00.080
 11  10                   354111 -> 987635A0421                                    1498 00:00.009  00:00.091
 12  11                   9B6693 -> 906835B7A421                                   6883 00:00.012  00:00.109
 13   1   3              3498283 -> 9B68AC37745201                                 8242 00:00.053  00:00.164
 14  13                  C7BD9A3 -> 4A3D75C8B96201                                 1330 00:00.001  00:00.166
 15  14                 758B2101 -> 4D638ECAB795201                                4216 00:00.008  00:00.175
 16  15                 B9D9A404 -> 9DB73AEFC8465201                              18457 00:00.070  00:00.247
 17   1   1            9AG28F324 -> DE753BFGC98A642101                           195112 00:00.415  00:00.664
 18  17                DAC284B44 -> 7HC9DA4GE8F5B63201                            30440 00:00.015  00:00.680
 19   6               A9E55B1101 -> 5E9A6F8IC7GBHD43201                           93021 00:00.116  00:00.797
 20  19               G3D5HIGD94 -> G8AJF596BH3IDC7E4201                       11310604 00:06.544  00:07.342
 21   1   6          F72EF5EH9C4 -> FAECK6B6J8IH9GD7543201                       601843 00:01.123  00:08.467
 22  21              F0JG88749F4 -> 5AKL7IHC84JEDGBF963201                     27804949 00:16.134  00:24.602
 23  22             CM65LE3D1101 -> 657LIJBF8MH9GKDECA43201                    17710217 00:09.976  00:34.579
 24  23             3DH0FGDH0JL4 -> 96ALDMGINJKCEFH78B543201                    4266555 00:02.115  00:36.695
 25  12            MHGHF541E1101 -> 9HN7MAIL8BFG6JKCEOD543201                  78092124 00:47.584  01:24.280
 26   5            K99MDB35N8K25 -> ABDJNHCPF97GKMEI6OL8543201                402922566 04:37.368  06:01.649
 27  26           JJBO73E11F1101 -> A6N9QC7PKGFJIBHDMOLE8543201               457555291 05:19.215  11:20.866

JavaScript

Translation of: Python

(() => {
    'use strict';

    // allDigitSquare :: Int -> Int
    const allDigitSquare = base => {
        const bools = replicate(base, false);
        return untilSucc(
            allDigitsUsedAtBase(base, bools),
            ceil(sqrt(parseInt(
                '10' + '0123456789abcdef'.slice(2, base),
                base
            )))
        );
    };

    // allDigitsUsedAtBase :: Int -> [Bool] -> Int -> Bool
    const allDigitsUsedAtBase = (base, bools) => n => {
        // Fusion of representing the square of integer N at a given base
        // with checking whether all digits of that base contribute to N^2.
        // Sets the bool at a digit position to True when used.
        // True if all digit positions have been used.
        const ds = bools.slice(0);
        let x = n * n;
        while (x) {
            ds[x % base] = true;
            x = floor(x / base);
        }
        return ds.every(x => x)
    };

    // showBaseSquare :: Int -> String
    const showBaseSquare = b => {
        const q = allDigitSquare(b);
        return justifyRight(2, ' ', str(b)) + ' -> ' +
            justifyRight(8, ' ', showIntAtBase(b, digit, q, '')) +
            ' -> ' + showIntAtBase(b, digit, q * q, '');
    };

    // TEST -----------------------------------------------
    const main = () => {
        // 1-12 only - by 15 the squares are truncated by
        // JS integer limits.

        // Returning values through console.log –
        // in separate events to avoid asynchronous disorder.
        print('Smallest perfect squares using all digits in bases 2-12:\n')
      (id > 0 ? chars.substr(id, 1) : " ")    print('Base      Root    Square')

        print(showBaseSquare(2));
        print(showBaseSquare(3));
        print(showBaseSquare(4));
        print(showBaseSquare(5));
        print(showBaseSquare(6));
        print(showBaseSquare(7));
        print(showBaseSquare(8));
        print(showBaseSquare(9));
        print(showBaseSquare(10));
        print(showBaseSquare(11));
        print(showBaseSquare(12));
    };

    // GENERIC FUNCTIONS ----------------------------------
    
    const
        ceil = Math.ceil,
        floor = Math.floor,
        sqrt = Math.sqrt;

    // Tuple (,) :: a -> b -> (a, b)
    const Tuple = (a, b) => ({
        type: 'Tuple',
        '0': a,
        '1': b,
        length: 2
    });

    // digit :: Int -> Char
    const digit = n =>
        // Digit character for given integer.
        '0123456789abcdef' [n];

    // enumFromTo :: (Int, Int) -> [Int]
    const enumFromTo = (m, n) =>
        Array.from({
            length: 1 + n - m
        }, (_, i) => m + i);

    // justifyRight :: Int -> Char -> String -> String
    const justifyRight = (n, cFiller, s) =>
        n > s.length ? (
            s.padStart(n, cFiller)
        ) : s;

    // print :: a -> IO ()
    const print = x => console.log(x)

    // quotRem :: Int -> Int -> (Int, Int)
    const quotRem = (m, n) =>
        Tuple(Math.floor(m / n), m % n);

    // replicate :: Int -> a -> [a]
    const replicate = (n, x) =>
        Array.from({
            length: n
        }, () => x);

    // showIntAtBase :: Int -> (Int -> Char) -> Int -> String -> String
    const showIntAtBase = (base, toChr, n, rs) => {
        const go = ([n, d], r) => {
            const r_ = toChr(d) + r;
            return 0 !== n ? (
                go(Array.from(quotRem(n, base)), r_)
            ) : r_;
        };
        return 1 >= base ? (
            'error: showIntAtBase applied to unsupported base'
        ) : 0 > n ? (
            'error: showIntAtBase applied to negative number'
        ) : go(Array.from(quotRem(n, base)), rs);
    };

    // Abbreviation for quick testing - any 2nd arg interpreted as indent size

    // sj :: a -> String
    function sj() {
        const args = Array.from(arguments);
        return JSON.stringify.apply(
            null,
            1 < args.length && !isNaN(args[0]) ? [
                args[1], null, args[0]
            ] : [args[0], null, 2]
        );
    }

    // str :: a -> String
    const str = x => x.toString();

    // untilSucc :: (Int -> Bool) -> Int -> Int
    const untilSucc = (p, x) => {
        // The first in a chain of successive integers
        // for which p(x) returns true.
        let v = x;
        while (!p(v)) v = 1 + v;
        return v;
    };

    // MAIN ---
    return main();
})();

Output:

Smallest perfect squares using all digits in bases 2-12:

Base      Root    Square
 2 ->       10 -> 100
 3 ->       22 -> 2101
 4 ->       33 -> 3201
 5 ->      243 -> 132304
 6 ->      523 -> 452013
 7 ->     1431 -> 2450361
 8 ->     3344 -> 13675420
 9 ->    11642 -> 136802574
10 ->    32043 -> 1026753849
11 ->   111453 -> 1240a536789
12 ->   3966b9 -> 124a7b538609

jq

Adapted from Julia

Works with jq and gojq, the C and Go implementations of jq

Some useful filters, but nothing fancy here.

With a few minor tweaks, notably replacing `sqrt` with `isqrt` (see e.g. Isqrt_(integer_square_root)_of_X#jq), the following program also works with jaq, the Rust implementation of jq.

# Input: an integral decimal number
# Output: the representation of the input in base $b as
# an array of one-character digits, with the least significant digit first.
def tobaseDigits($b):
  def digit: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[.:.+1];
  def mod: . % $b;
  def div: ((. - mod) / $b);
  def digits: recurse( select(. > 0) | div) | mod ;
  if . == 0 then "0"
  else [digits | digit][:-1]
  end;

def tobase($b):
  tobaseDigits($b) | reverse | add;

# Input: an alphanumeric string to be interpreted as a number in base $b
# Output: the corresponding decimal value
def frombase($b):
  def decimalValue:
    if   48 <= . and . <= 57 then . - 48
    elif 65 <= . and . <= 90 then . - 55  # (10+.-65)
    elif 97 <= . and . <= 122 then . - 87 # (10+.-97)
    else "decimalValue" | error
    end;
  reduce (explode|reverse[]|decimalValue) as $x ({p:1};
    .value += (.p * $x)
    | .p *= $b)
  | .value ;

def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;

# $n and $base should be decimal integers
def hasallin($n; $base):
  $base == ($n | tobaseDigits($base) | unique | length);

def squaresearch($base):
  def num: "0123456789abcdef";
  (("10" + num[2:$base]) | frombase($base)) as $highest
  | first( range( $highest|sqrt|floor; infinite)  # $highest + 1
           | select(hasallin(.*.; $base)) );

def task:
  "Base       Root N",
  (range(2;16) as $b
  | squaresearch($b)
  | "\($b|lpad(3))  \(tobase($b)|lpad(10) ) \( .*. | tobase($b))" );

task

Output:

Base       Root N
  2          10 100
  3          22 2101
  4          33 3201
  5         243 132304
  6         523 452013
  7        1431 2450361
  8        3344 13675420
  9       11642 136802574
 10       32043 1026753849
 11      111453 1240A536789
 12      3966B9 124A7B538609
 13     3828943 10254773CA86B9
 14     3A9DB7C 10269B8C57D3A4
 15    1012B857 102597BACE836D4

Julia

Runs in about 4 seconds with using occursin().

const num = "0123456789abcdef"
hasallin(n, nums, b) = (s = string(n, base=b); all(x -> occursin(x, s), nums))
 
function squaresearch(base)
    basenumerals = [c for c in num[1:base]]
    highest = parse(Int, "10" * num[3:base], base=base)
    for n in Int(trunc(sqrt(highest))):highest
        if hasallin(n * n, basenumerals, base)
            return n
        end
    end
end
 
println("Base     Root   N")
for b in 2:16
    n = squaresearch(b)
    println(lpad(b, 3), lpad(string(n, base=b), 10), "  ", string(n * n, base=b))
end

Output:

Base     Root   N
  2        10  100
  3        22  2101
  4        33  3201
  5       243  132304
  6       523  452013
  7      1431  2450361
  8      3344  13675420
  9     11642  136802574
 10     32043  1026753849
 11    111453  1240a536789
 12    3966b9  124a7b538609
 13   3828943  10254773ca86b9
 14   3a9db7c  10269b8c57d3a4
 15  1012b857  102597bace836d4
 16  404a9d9b  1025648cfea37bd9

Kotlin

Translation of: Java

import java.math.BigInteger
import java.time.Duration
import java.util.ArrayList
import java.util.HashSet
import kotlin.math.sqrt

const val ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz|"
var base: Byte = 0
var bmo: Byte = 0
var blim: Byte = 0
var ic: Byte = 0
var st0: Long = 0
var bllim: BigInteger? = null
var threshold: BigInteger? = null
var hs: MutableSet<Byte> = HashSet()
var o: MutableSet<Byte> = HashSet()
val chars = ALPHABET.toCharArray()
var limits: MutableList<BigInteger?>? = null
var ms: String? = null

fun indexOf(c: Char): Int {
    for (i in chars.indices) {
        if (chars[i] == c) {
            return i
        }
    }
    return -1
}

// convert BigInteger to string using current base
fun toStr(b: BigInteger): String {
    var b2 = b
    val bigBase = BigInteger.valueOf(base.toLong())
    val res = StringBuilder()
    while (b2 > BigInteger.ZERO) {
        val divRem = b2.divideAndRemainder(bigBase)
        res.append(chars[divRem[1].toInt()])
        b2 = divRem[0]
    }
    return res.toString()
}

// check for a portion of digits, bailing if uneven
fun allInQS(b: BigInteger): Boolean {
    var b2 = b
    val bigBase = BigInteger.valueOf(base.toLong())
    var c = ic.toInt()
    hs.clear()
    hs.addAll(o)
    while (b2 > bllim) {
        val divRem = b2.divideAndRemainder(bigBase)
        hs.add(divRem[1].toByte())
        c++
        if (c > hs.size) {
            return false
        }
        b2 = divRem[0]
    }
    return true
}

// check for a portion of digits, all the way to the end
fun allInS(b: BigInteger): Boolean {
    var b2 = b
    val bigBase = BigInteger.valueOf(base.toLong())
    hs.clear()
    hs.addAll(o)
    while (b2 > bllim) {
        val divRem = b2.divideAndRemainder(bigBase)
        hs.add(divRem[1].toByte())
        b2 = divRem[0]
    }
    return hs.size == base.toInt()
}

// check for all digits, bailing if uneven
fun allInQ(b: BigInteger): Boolean {
    var b2 = b
    val bigBase = BigInteger.valueOf(base.toLong())
    var c = 0
    hs.clear()
    while (b2 > BigInteger.ZERO) {
        val divRem = b2.divideAndRemainder(bigBase)
        hs.add(divRem[1].toByte())
        c++
        if (c > hs.size) {
            return false
        }
        b2 = divRem[0]
    }
    return true
}

// check for all digits, all the way to the end
fun allIn(b: BigInteger): Boolean {
    var b2 = b
    val bigBase = BigInteger.valueOf(base.toLong())
    hs.clear()
    while (b2 > BigInteger.ZERO) {
        val divRem = b2.divideAndRemainder(bigBase)
        hs.add(divRem[1].toByte())
        b2 = divRem[0]
    }
    return hs.size == base.toInt()
}

// parse a string into a BigInteger, using current base
fun to10(s: String?): BigInteger {
    val bigBase = BigInteger.valueOf(base.toLong())
    var res = BigInteger.ZERO
    for (element in s!!) {
        val idx = indexOf(element)
        val bigIdx = BigInteger.valueOf(idx.toLong())
        res = res.multiply(bigBase).add(bigIdx)
    }
    return res
}

// returns the minimum value string, optionally inserting extra digit
fun fixup(n: Int): String {
    var res = ALPHABET.substring(0, base.toInt())
    if (n > 0) {
        val sb = StringBuilder(res)
        sb.insert(n, n)
        res = sb.toString()
    }
    return "10" + res.substring(2)
}

// checks the square against the threshold, advances various limits when needed
fun check(sq: BigInteger) {
    if (sq > threshold) {
        o.remove(indexOf(ms!![blim.toInt()]).toByte())
        blim--
        ic--
        threshold = limits!![bmo - blim - 1]
        bllim = to10(ms!!.substring(0, blim + 1))
    }
}

// performs all the calculations for the current base
fun doOne() {
    limits = ArrayList()
    bmo = (base - 1).toByte()
    var dr: Byte = 0
    if ((base.toInt() and 1) == 1) {
        dr = (base.toInt() shr 1).toByte()
    }
    o.clear()
    blim = 0
    var id: Byte = 0
    var inc = 1
    val st = System.nanoTime()
    val sdr = ByteArray(bmo.toInt())
    var rc: Byte = 0
    for (i in 0 until bmo) {
        sdr[i] = (i * i % bmo).toByte()
        if (sdr[i] == dr) {
            rc = (rc + 1).toByte()
        }
        if (sdr[i] == 0.toByte()) {
            sdr[i] = (sdr[i] + bmo).toByte()
        }
    }
    var i: Long = 0
    if (dr > 0) {
        id = base
        i = 1
        while (i <= dr) {
            if (sdr[i.toInt()] >= dr) {
                if (id > sdr[i.toInt()]) {
                    id = sdr[i.toInt()]
                }
            }
            i++
        }
        id = (id - dr).toByte()
        i = 0
    }
    ms = fixup(id.toInt())
    var sq = to10(ms)
    var rt = BigInteger.valueOf((sqrt(sq.toDouble()) + 1).toLong())
    sq = rt.multiply(rt)
    if (base > 9) {
        for (j in 1 until base) {
            limits!!.add(to10(ms!!.substring(0, j) + chars[bmo.toInt()].toString().repeat(base - j + if (rc > 0) 0 else 1)))
        }
        limits!!.reverse()
        while (sq < limits!![0]) {
            rt = rt.add(BigInteger.ONE)
            sq = rt.multiply(rt)
        }
    }
    var dn = rt.shiftLeft(1).add(BigInteger.ONE)
    var d = BigInteger.ONE
    if (base > 3 && rc > 0) {
        while (sq.remainder(BigInteger.valueOf(bmo.toLong())).compareTo(BigInteger.valueOf(dr.toLong())) != 0) {
            rt = rt.add(BigInteger.ONE)
            sq = sq.add(dn)
            dn = dn.add(BigInteger.TWO)
        } // aligns sq to dr
        inc = bmo / rc
        if (inc > 1) {
            dn = dn.add(rt.multiply(BigInteger.valueOf(inc - 2.toLong())).subtract(BigInteger.ONE))
            d = BigInteger.valueOf(inc * inc.toLong())
        }
        dn = dn.add(dn).add(d)
    }
    d = d.shiftLeft(1)
    if (base > 9) {
        blim = 0
        while (sq < limits!![bmo - blim - 1]) {
            blim++
        }
        ic = (blim + 1).toByte()
        threshold = limits!![bmo - blim - 1]
        if (blim > 0) {
            for (j in 0..blim) {
                o.add(indexOf(ms!![j]).toByte())
            }
        }
        bllim = if (blim > 0) {
            to10(ms!!.substring(0, blim + 1))
        } else {
            BigInteger.ZERO
        }
        if (base > 5 && rc > 0) while (!allInQS(sq)) {
            sq = sq.add(dn)
            dn = dn.add(d)
            i += 1
            check(sq)
        } else {
            while (!allInS(sq)) {
                sq = sq.add(dn)
                dn = dn.add(d)
                i += 1
                check(sq)
            }
        }
    } else {
        if (base > 5 && rc > 0) {
            while (!allInQ(sq)) {
                sq = sq.add(dn)
                dn = dn.add(d)
                i += 1
            }
        } else {
            while (!allIn(sq)) {
                sq = sq.add(dn)
                dn = dn.add(d)
                i += 1
            }
        }
    }
    rt = rt.add(BigInteger.valueOf(i * inc))
    val delta1 = System.nanoTime() - st
    val dur1 = Duration.ofNanos(delta1)
    val delta2 = System.nanoTime() - st0
    val dur2 = Duration.ofNanos(delta2)
    System.out.printf(
        "%3d  %2d  %2s %20s -> %-40s %10d %9s  %9s\n",
        base, inc, if (id > 0) ALPHABET.substring(id.toInt(), id + 1) else " ", toStr(rt), toStr(sq), i, format(dur1), format(dur2)
    )
}

private fun format(d: Duration): String {
    val minP = d.toMinutesPart()
    val secP = d.toSecondsPart()
    val milP = d.toMillisPart()
    return String.format("%02d:%02d.%03d", minP, secP, milP)
}

fun main() {
    println("base inc id                 root    square                                   test count    time        total")
    st0 = System.nanoTime()
    base = 2
    while (base < 28) {
        doOne()
        ++base
    }
}

Output:

base inc id                 root    square                                   test count    time        total
  2   1                       01 -> 001                                               0 00:00.001  00:00.002
  3   1                       22 -> 1012                                              4 00:00.000  00:00.016
  4   3                       33 -> 1023                                              2 00:00.000  00:00.018
  5   1   2                  342 -> 403231                                           14 00:00.000  00:00.021
  6   5                      325 -> 310254                                           20 00:00.000  00:00.023
  7   6                     1341 -> 1630542                                          34 00:00.000  00:00.026
  8   7                     4433 -> 02457631                                         41 00:00.000  00:00.028
  9   4                    24611 -> 475208631                                       289 00:00.002  00:00.032
 10   3                    34023 -> 9483576201                                       17 00:00.017  00:00.050
 11  10                   354111 -> 987635A0421                                    1498 00:00.011  00:00.063
 12  11                   9B6693 -> 906835B7A421                                   6883 00:00.016  00:00.083
 13   1   3              3498283 -> 9B68AC37745201                                 8242 00:00.031  00:00.116
 14  13                  C7BD9A3 -> 4A3D75C8B96201                                 1330 00:00.002  00:00.120
 15  14                 758B2101 -> 4D638ECAB795201                                4216 00:00.016  00:00.138
 16  15                 B9D9A404 -> 9DB73AEFC8465201                              18457 00:00.087  00:00.226
 17   1   1            9AG28F324 -> DE753BFGC98A642101                           195112 00:00.435  00:00.664
 18  17                DAC284B44 -> 7HC9DA4GE8F5B63201                            30440 00:00.018  00:00.683
 19   6               A9E55B1101 -> 5E9A6F8IC7GBHD43201                           93021 00:00.061  00:00.745
 20  19               G3D5HIGD94 -> G8AJF596BH3IDC7E4201                       11310604 00:06.859  00:07.605
 21   1   6          F72EF5EH9C4 -> FAECK6B6J8IH9GD7543201                       601843 00:01.223  00:08.830
 22  21              F0JG88749F4 -> 5AKL7IHC84JEDGBF963201                     27804949 00:18.191  00:27.023
 23  22             CM65LE3D1101 -> 657LIJBF8MH9GKDECA43201                    17710217 00:11.143  00:38.167
 24  23             3DH0FGDH0JL4 -> 96ALDMGINJKCEFH78B543201                    4266555 00:02.381  00:40.549
 25  12            MHGHF541E1101 -> 9HN7MAIL8BFG6JKCEOD543201                  78092124 00:53.150  01:33.701
 26   5            K99MDB35N8K25 -> ABDJNHCPF97GKMEI6OL8543201                402922566 05:15.307  06:49.008
 27  26           JJBO73E11F1101 -> A6N9QC7PKGFJIBHDMOLE8543201               457555291 06:01.338  12:50.347

Mathematica / Wolfram Language

ClearAll[FirstSquare]
FirstSquare[b_Integer] := Module[{n, alldigits, digs, start},
  digs = Range[0, b - 1];
  digs[[{2, 1}]] //= Reverse;
  start = Floor[Sqrt[FromDigits[digs, b]]];
  n = start;
  alldigits = Range[0, b - 1];
  While[! ContainsAll[IntegerDigits[n^2, b], alldigits], n++];
  {b, n, start, BaseForm[n, b]}
  ]
Scan[Print@*FirstSquare, Range[2, 16]]

Output:

{2,2,1,10}
{3,8,3,22}
{4,15,8,33}
{5,73,26,243}
{6,195,91,523}
{7,561,351,1431}
{8,1764,1475,3344}
{9,7814,6657,11642}
{10,32043,31991,32043}
{11,177565,162581,111453}
{12,944493,868779,3966b9}
{13,17527045,4858932,3828943}
{14,28350530,28333238,3a9db7c}
{15,171759007,171699980,1012b857}
{16,1078631835,1078354969,404a9d9b}

Nim

Translation of: D

import algorithm, math, strformat

const Alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"


func toBaseN(num, base: Natural): string =
  doAssert(base in 2..Alphabet.len, &"base must be in 2..{Alphabet.len}")
  var num = num
  while true:
    result.add(Alphabet[num mod base])
    num = num div base
    if num == 0: break
  result.reverse()


func countUnique(str: string): int =
  var charset: set['0'..'Z']
  for ch in str: charset.incl(ch)
  result = charset.card


proc find(base: Natural) =
  var n = pow(base.toFloat, (base - 1) / 2).int
  while true:
    let sq = n * n
    let sqstr = sq.toBaseN(base)
    if sqstr.len >= base and countUnique(sqstr) == base:
      let nstr = n.toBaseN(base)
      echo &"Base {base:2d}:  {nstr:>8s}² = {sqstr:<16s}"
      break
    inc n


when isMainModule:
  for base in 2..16:
    base.find()

Output:

Base  2:        10² = 100             
Base  3:        22² = 2101            
Base  4:        33² = 3201            
Base  5:       243² = 132304          
Base  6:       523² = 452013          
Base  7:      1431² = 2450361         
Base  8:      3344² = 13675420        
Base  9:     11642² = 136802574       
Base 10:     32043² = 1026753849      
Base 11:    111453² = 1240A536789     
Base 12:    3966B9² = 124A7B538609    
Base 13:   3828943² = 10254773CA86B9  
Base 14:   3A9DB7C² = 10269B8C57D3A4  
Base 15:  1012B857² = 102597BACE836D4 
Base 16:  404A9D9B² = 1025648CFEA37BD9

Pascal

Using an array of digits to base n, to get rid of base conversions.
Starting value equals squareroot of smallest value containing all digits to base.
Than brute force.
Try it online!

program project1;
//Find the smallest number n to base b, so that n*n includes all
//digits of base b
{$IFDEF FPC}{$MODE DELPHI}{$ENDIF}
uses
  sysutils;
const
 charSet : array[0..36] of char ='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';  
type
  tNumtoBase = record 
                 ntb_dgt : array[0..31-4] of byte;
                 ntb_cnt,
                 ntb_bas  : Word;
               end;
var
  Num,
  sqr2B,
  deltaNum  : tNumtoBase;                  
 
function Minimal_n(base:NativeUint):Uint64;
//' 1023456789ABCDEFGHIJ...'
var
  i : NativeUint;
Begin
  result := base;  // aka '10'
  IF base > 2 then 
    For i := 2 to base-1 do
      result := result*base+i;
  result := trunc(sqrt(result)+0.99999);        
end;

procedure Conv2num(var num:tNumtoBase;n:Uint64;base:NativeUint);
var
  quot :UInt64;
  i :NativeUint; 
Begin
  i := 0;
  repeat
    quot := n div base;
    Num.ntb_dgt[i] := n-quot*base;
    n := quot;
    inc(i);
  until n = 0;
  Num.ntb_cnt := i;
  Num.ntb_bas := base;
  //clear upper digits
  For i := i to high(tNumtoBase.ntb_dgt) do 
     Num.ntb_dgt[i] := 0;
end;

procedure OutNum(const num:tNumtoBase);
var
  i : NativeInt;
Begin
  with num do
  Begin
    For i := 17-ntb_cnt-1 downto 0 do 
      write(' ');
    For i := ntb_cnt-1 downto 0 do
      write(charSet[ntb_dgt[i]]);
  end;  
end;

procedure IncNumBig(var add1:tNumtoBase;n:NativeUInt);
//prerequisites
//bases are the same,delta : NativeUint
var
  i,s,b,carry : NativeInt;
Begin
  b := add1.ntb_bas;
  i := 0;
  carry := 0;
  while n > 0 do
  Begin
    s := add1.ntb_dgt[i]+carry+ n MOD b;
    carry := Ord(s>=b);
    s := s- (-carry AND b);
    add1.ntb_dgt[i] := s;
    n := n div b;
    inc(i);
  end;   
  
  while carry <> 0 do
  Begin
    s := add1.ntb_dgt[i]+carry;
    carry := Ord(s>=b);
    s := s- (-carry AND b);
    add1.ntb_dgt[i] := s;
    inc(i);
  end;   

  IF add1.ntb_cnt < i then
    add1.ntb_cnt := i;
end;

procedure IncNum(var add1:tNumtoBase;carry:NativeInt);
//prerequisites: bases are the same, carry==delta < base
var
  i,s,b : NativeInt;
Begin
  b := add1.ntb_bas;
  i := 0;
  while carry <> 0 do
  Begin
    s := add1.ntb_dgt[i]+carry;
    carry := Ord(s>=b);
    s := s- (-carry AND b);
    add1.ntb_dgt[i] := s;
    inc(i);
  end;   
  IF add1.ntb_cnt < i then
    add1.ntb_cnt := i;
end;

procedure AddNum(var add1,add2:tNumtoBase);
//prerequisites
//bases are the same,add1>add2, add1 <= add1+add2;
var
  i,carry,s,b : NativeInt;
Begin
  b := add1.ntb_bas;
  carry := 0;
  For i := 0 to add2.ntb_cnt-1 do 
  begin
    s := add1.ntb_dgt[i]+add2.ntb_dgt[i]+carry;
    carry := Ord(s>=b);
    s := s- (-carry AND b);
    add1.ntb_dgt[i] := s;
  end;  
  
  i := add2.ntb_cnt;
  while carry = 1 do
  Begin
    s := add1.ntb_dgt[i]+carry;
    carry := Ord(s>=b);
    // remove of if s>b then by bit-twiddling
    s := s- (-carry AND b);
    add1.ntb_dgt[i] := s;
    inc(i);
  end;   
  
  IF add1.ntb_cnt < i then
    add1.ntb_cnt := i;
end;

procedure Test(base:NativeInt);
var
  n : Uint64;  
  i,j,TestSet : NativeInt;
Begin
  write(base:5);
  n := Minimal_n(base);
  Conv2num(sqr2B,n*n,base);
  Conv2num(Num,n,base);
  deltaNum := num;
  AddNum(deltaNum,deltaNum);
  IncNum(deltaNum,1);  
  
  i := 0;
  repeat
    //count used digits
    TestSet := 0;
    For j := sqr2B.ntb_cnt-1 downto 0 do
      TestSet := TestSet OR (1 shl sqr2B.ntb_dgt[j]);
    inc(TestSet);  
    IF (1 shl base)=TestSet  then
       BREAK;   
    //next square number
    AddNum(sqr2B,deltaNum);
    IncNum(deltaNum,2);
    inc(i);
  until false;
  IncNumBig(num,i);
  OutNum(Num);  
  OutNum(sqr2B);
  Writeln(i:14);  
end;

var
  T0: TDateTime;
  base :nativeInt;   
begin
  T0 := now;
  writeln('base                 n        square(n)       Testcnt');
  For base := 2 to 16 do
    Test(base);
  writeln((now-T0)*86400:10:3);
  {$IFDEF WINDOWS}readln;{$ENDIF}
end.

Output:

base                 n        square(n)       Testcnt
    2               10              100             0
    3               22             2101             4
    4               33             3201             6
    5              243           132304            46
    6              523           452013           103
    7             1431          2450361           209
    8             3344         13675420           288
    9            11642        136802574          1156
   10            32043       1026753849            51
   11           111453      1240A536789         14983
   12           3966B9     124A7B538609         75713
   13          3828943   10254773CA86B9      12668112
   14          3A9DB7C   10269B8C57D3A4         17291
   15         1012B857  102597BACE836D4         59026
   16         404A9D9B 1025648CFEA37BD9        276865
     0.401

Inserted nearly all optimizations found by Hout and Nigel Galloway

I use now gmp to calculate the start values.Check Chai Wah Wu list on oeis.org/A260182
Now multithreaded at bases > 20 .Inserted StartOffset to run later on.For bases> 28 an intermediate stage of the minimal advanced thread is saved every minute.This is the candidate to start with again.
GetThreadCount needs improvement for Linux

The runtime is on my 6-Core PC AMD Ryzen 2200G ( 3.7 Ghz on all 4 cores Linux64 with SMT= off)

program Pandigital;
//Find the smallest number n to base b, so that n*n includes all
//digits of base b aka pandigital

{$IFDEF FPC}
//{$R+,O+}
  {$MODE DELPHI}
  {$Optimization ON,ALL}
  {$CODEALIGN proc=8,loop=1}// Ryzen Zen loop=1
{$ElSE}
  {$APPTYPE CONSOLE}
{$ENDIF}
uses
  {$IFDEF UNIX}
    unix,
    cthreads,
  {$ENDIF}
  gmp,// to calculate start values
  SysUtils;

type
  tRegion32 = 0..31;
  tSolSet32 = set of tRegion32;
  tMask32   = array[tRegion32] of Uint32;
  tpMask32  = ^tMask32;

  tRegion64 = 0..63;
  tSolSet64 = set of tRegion64;
  tMask64   = array[tRegion64] of Uint64;
  tpMask64  = ^tMask64;
const
  // has hyperthreading
  SMT = 0;
{$ALIGN 32}
  //set Bit 0 til Bit 63
  cOr_Mask64: tMask64 =
    (1 shl  0,1 shl  1,1 shl  2,1 shl  3,1 shl  4,1 shl  5,1 shl  6,1 shl  7,
     1 shl  8,1 shl  9,1 shl 10,1 shl 11,1 shl 12,1 shl 13,1 shl 14,1 shl 15,
     1 shl 16,1 shl 17,1 shl 18,1 shl 19,1 shl 20,1 shl 21,1 shl 22,1 shl 23,
     1 shl 24,1 shl 25,1 shl 26,1 shl 27,1 shl 28,1 shl 29,1 shl 30,1 shl 31,
     1 shl 32,1 shl 33,1 shl 34,1 shl 35,1 shl 36,1 shl 37,1 shl 38,1 shl 39,
     1 shl 40,1 shl 41,1 shl 42,1 shl 43,1 shl 44,1 shl 45,1 shl 46,1 shl 47,
     1 shl 48,1 shl 49,1 shl 50,1 shl 51,1 shl 52,1 shl 53,1 shl 54,1 shl 55,
     1 shl 56,1 shl 57,1 shl 58,1 shl 59,1 shl 60,1 shl 61,1 shl 62,1 shl 63);

  charSet: array[0..62] of char =
    '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
type
  tRegion1 = 0..63 - 2 * SizeOf(byte);

  tNumtoBase = packed record
    ntb_dgt: array[tRegion1] of byte;
    ntb_cnt,
    ntb_bas: Byte;
  end;

  tDgtRootSqr = packed record
    drs_List: array[tRegion64] of byte;
    drs_SetOfSol: tSolSet64;
    drs_bas: byte;
    drs_Sol: byte;
    drs_SolCnt: byte;
    drs_Dgt2Add: byte;
    drs_NeedsOneMoreDigit: boolean;
  end;

  tCombineForOneThread = record
    cft_sqr2b,
    cft_deltaNextSqr,
    cft_delta: tNumtoBase;
    cft_count : Uint64;
    cft_offset: Uint64;// unused but doubles speed especially for base 25
    cft_ThreadID: NativeUint;
    cft_ThreadHandle: NativeUint;
    //Alignment = 32
    //Base 25 test every 12    0.539 s Testcount :       78092125
    //Alignment = 24
    //Base 25 test every 12    1.316 s Testcount :       78092125
  end;

  procedure AddNum(var add1: tNumtoBase; const add2: tNumtoBase); forward;
  function AddNumSqr(var add1, add2: tNumtoBase): Uint64;  forward;

var
  ThreadBlocks: array of tCombineForOneThread;
{$ALIGN 32}
  Num, sqr2B, deltaNextSqr, delta: tNumtoBase;
{$ALIGN 32}
  DgtRtSqr: tDgtRootSqr;
{$ALIGN 8}
  gblThreadCount,
  Finished: Uint32;

  function GetCoreCount:NativeInt;
  // from lazarus forum
  var
    t: Text;
    s: string;
  begin
    result := 1;
    try
      POpen(t, 'nproc', 'R');
      while not Eof(t) do
        Readln(t, s);
    finally
      PClose(t);
    end;
    result := StrToInt(s);
  end;

  function GetThreadCount: NativeUInt;
  begin
    {$IFDEF Windows}
      Result := GetCpuCount;
    {$ELSE}
      Result := GetCoreCount;//GetCpuCount is not working under Linux ???
    {$ENDIF}
    if SMT = 1 then
      Result := (Result+1) div 2;
  end;

  procedure OutNum(const num: tNumtoBase);
  var
    i: NativeInt;
  begin
    with num do
    begin
      for i := ntb_cnt - 1 downto 0 do
        Write(charSet[ntb_dgt[i]]);
    end;
    Write(' ');
  end;

  procedure OutNumSqr;
  begin
    Write(' Num ');OutNum(Num);
    Write(' sqr ');OutNum(sqr2B);
    writeln;
  end;

  function getDgtRtNum(const num: tNumtoBase): NativeInt;
  var
    i: NativeInt;
  begin
    with num do
    begin
      Result := 0;
      for i := 0 to num.ntb_cnt - 1 do
        Inc(Result, ntb_dgt[i]);
      Result := Result mod (ntb_bas - 1);
    end;
  end;

  procedure CalcDgtRootSqr(base: NativeUInt);
  var
    ChkSet: array[tRegion64] of tSolSet64;
    ChkCnt: array[tRegion64] of byte;
    i, j: NativeUInt;
    PTest: tSolSet64;
  begin
    for i := low(ChkCnt) to High(ChkCnt) do
    begin
      ChkCnt[i] := 0;
      ChkSet[i] := [];
    end;
    ptest := [];
    with DgtRtSqr do
    begin
      //pandigtal digital root (sum all digits of base) mod (base-1)
      drs_bas := base;
      if Odd(base) then
        drs_Sol := base div 2
      else
        drs_Sol := 0;

      base := base - 1;
      //calc which dgt root the square of the number will become
      for i := 0 to base - 1 do
        drs_List[i] := (i * i) mod base;
      //searching for solution
      drs_SolCnt := 0;
      for i := 0 to base - 1 do
        if drs_List[i] = drs_Sol then
        begin
          include(ptest, i);
          Inc(drs_SolCnt);
        end;
      //if not found then NeedsOneMoreDigit
      drs_NeedsOneMoreDigit := drs_SolCnt = 0;
      if drs_NeedsOneMoreDigit then
      begin
        for j := 1 to Base do
          for i := 0 to Base do
            if drs_List[j] = (drs_Sol + i) mod BASE then
            begin
              include(ptest, i);
              include(ChkSet[i], j);
              Inc(ChkCnt[i]);
            end;
        i := 1;
        repeat
          if i in pTest then
          begin
            drs_Dgt2Add := i;
            BREAK;
          end;
          Inc(i);
        until i > base;
        write(' insert ', i);
      end;
    end;
  end;

  procedure conv_ui_num(base: NativeUint; ui: Uint64; var Num: tNumtoBase);
  var
    i: NativeUInt;
  begin
    for i := 0 to high(tNumtoBase.ntb_dgt) do
      Num.ntb_dgt[i] := 0;
    with num do
    begin
      ntb_bas := base;
      ntb_cnt := 0;
      if ui = 0 then
        EXIT;
      i := 0;
      repeat
        ntb_dgt[i] := ui mod base;
        ui := ui div base;
        Inc(i);
      until ui = 0;
      ntb_cnt := i;
    end;
  end;

  procedure conv2Num(base: NativeUint; var Num: tNumtoBase; var s: mpz_t);
  var
    tmp: mpz_t;
    i: NativeUInt;
  begin
    mpz_init_set(tmp, s);
    for i := 0 to high(tNumtoBase.ntb_dgt) do
      Num.ntb_dgt[i] := 0;
    with num do
    begin
      ntb_bas := base;
      i := 0;
      repeat
        ntb_dgt[i] := mpz_tdiv_q_ui(s, s, base);
        Inc(i);
      until mpz_cmp_ui(s, 0) = 0;
      ntb_cnt := i;
    end;
    mpz_clear(tmp);
  end;

  procedure StartValueCreate(base: NativeUInt);
  //create the lowest pandigital number "102345...Base-1 "
  //calc sqrt +1 and convert n new format.
  var
    sv_sqr, sv: mpz_t;
    k, dblDgt: NativeUint;

  begin
    mpz_init(sv);
    mpz_init(sv_sqr);

    mpz_init_set_si(sv_sqr, base);//"10"
    CalcDgtRootSqr(base);

    if DgtRtSqr.drs_NeedsOneMoreDigit then
    begin
      dblDgt := DgtRtSqr.drs_Dgt2Add;
      if dblDgt = 1 then
      begin
        for k := 1 to base - 1 do
        begin
          mpz_mul_ui(sv_sqr, sv_sqr, base);
          mpz_add_ui(sv_sqr, sv_sqr, k);
        end;
      end
      else
      begin
        for k := 2 to dblDgt do
        begin
          mpz_mul_ui(sv_sqr, sv_sqr, base);
          mpz_add_ui(sv_sqr, sv_sqr, k);
        end;
        for k := dblDgt to base - 1 do
        begin
          mpz_mul_ui(sv_sqr, sv_sqr, base);
          mpz_add_ui(sv_sqr, sv_sqr, k);
        end;
      end;
    end
    else
    begin
      for k := 2 to base - 1 do
      begin
        mpz_mul_ui(sv_sqr, sv_sqr, base);
        mpz_add_ui(sv_sqr, sv_sqr, k);
      end;
    end;

    mpz_sqrt(sv, sv_sqr);
    mpz_add_ui(sv, sv, 1);
    mpz_mul(sv_sqr, sv, sv);

    conv2Num(base, Num, sv);
    conv2Num(base, sqr2B, sv_sqr);

    mpz_clear(sv_sqr);
    mpz_clear(sv);
  end;

  function ExtractThreadVal(ThreadNr: NativeInt ): Uint64;
  begin
    with ThreadBlocks[ThreadNr] do
    begin
      sqr2b := cft_sqr2b;
      Result := cft_count;
      cft_ThreadID := 0;
      cft_ThreadHandle := 0;
    end;
  end;

  function CheckPandigital(const n: tNumtoBase): boolean;
  var
    pMask: tpMask64;
    TestSet: Uint64;
    i: NativeInt;
  begin
    pMask := @cOr_Mask64;
    TestSet := 0;
    with n do
    begin
      for i := ntb_cnt - 1 downto 0 do
        TestSet := TestSet or pMask[ntb_dgt[i]];
      Result := (Uint64(1) shl ntb_bas - 1) = TestSet;
    end;
  end;

  procedure IncNumBig(var add1: tNumtoBase; n: Uint64);
  var
    i, s, b, carry: NativeUInt;
  begin
    b := add1.ntb_bas;
    i := 0;
    carry := 0;
    while n > 0 do
    begin
      s := add1.ntb_dgt[i] + carry + n mod b;
      carry := Ord(s >= b);
      s := s - (-carry and b);
      add1.ntb_dgt[i] := s;
      n := n div b;
      Inc(i);
    end;

    while carry <> 0 do
    begin
      s := add1.ntb_dgt[i] + carry;
      carry := Ord(s >= b);
      s := s - (-carry and b);
      add1.ntb_dgt[i] := s;
      Inc(i);
    end;

    if add1.ntb_cnt < i then
      add1.ntb_cnt := i;
  end;

  procedure IncSmallNum(var add1: tNumtoBase; carry: NativeUInt);
  //prerequisites carry < base
  var
    i, s, b: NativeUInt;
  begin
    b := add1.ntb_bas;
    i := 0;
    while carry <> 0 do
    begin
      s := add1.ntb_dgt[i] + carry;
      carry := Ord(s >= b);
      s := s - (-carry and b);
      add1.ntb_dgt[i] := s;
      Inc(i);
    end;
    if add1.ntb_cnt < i then
      add1.ntb_cnt := i;
  end;

  procedure AddNum(var add1: tNumtoBase; const add2: tNumtoBase);
  //add1 <= add1+add2;
  var
    i, base, s, carry: NativeUInt;
  begin
    carry := 0;
    base := add1.ntb_bas;

    for i := 0 to add2.ntb_cnt - 1 do
    begin
      s := add1.ntb_dgt[i] + add2.ntb_dgt[i] + carry;
      carry := Ord(s >= base);
      s := s - (-carry and base);
      add1.ntb_dgt[i] := s;
    end;

    i := add2.ntb_cnt;
    while carry = 1 do
    begin
      s := add1.ntb_dgt[i] + carry;
      carry := Ord(s >= base);
      s := s - (-carry and base);
      add1.ntb_dgt[i] := s;
      Inc(i);
    end;

    if add1.ntb_cnt < i then
      add1.ntb_cnt := i;
  end;

  procedure Mul_num_ui(var n: tNumtoBase; ui: Uint64);
  var
    dbl: tNumtoBase;
  begin
    dbl := n;
    conv_ui_num(n.ntb_bas, 0, n);
    while ui > 0 do
    begin
      if Ui and 1 <> 0 then
        AddNum(n, dbl);
      AddNum(dbl, dbl);
      ui := ui div 2;
    end;
  end;

  procedure CalcDeltaSqr(const num: tNumtoBase; var dnsq, dlt: tNumtoBase;
    n: NativeUInt);
  //calc  deltaNextSqr   //n*num
  begin
    dnsq := num;
    Mul_num_ui(dnsq, n);
    AddNum(dnsq, dnsq);
    IncNumBig(dnsq, n * n);
    conv_ui_num(num.ntb_bas, 2 * n * n, dlt);
  end;

  procedure PrepareThreads(thdCount,stepWidth:NativeInt);
  //starting the threads at num,num+stepWidth,..,num+(thdCount-1)*stepWidth
  //stepwith not stepWidth but thdCount*stepWidth
  var
    tmpnum,tmpsqr2B,tmpdeltaNextSqr,tmpdelta :tNumToBase;
    i : NativeInt;
  Begin
    tmpnum := num;
    tmpsqr2B := sqr2B;
    tmpdeltaNextSqr := deltaNextSqr;
    tmpdelta := delta;

    For i := 0 to thdCount-1 do
    Begin
      //init ThreadBlock
      With ThreadBlocks[i] do
      begin
        cft_sqr2b := tmpsqr2B;
        cft_count := 0;
        CalcDeltaSqr(tmpnum,cft_deltaNextSqr,cft_delta,thdCount*stepWidth);
      end;
      //Next sqr number in stepWidth
      IncSmallNum(tmpnum,stepWidth);
      AddNumSqr(tmpsqr2B,tmpdeltaNextSqr);
      IF CheckPandigital(sqr2B) then
      begin
        writeln(' solution found ');
        readln;
        Halt(-124);
      end;
      AddNum(tmpdeltaNextSqr,tmpdelta);
    end;
  end;

  function AddNumSqr(var add1, add2: tNumtoBase): Uint64;
  //add1 <= add1+add2;
  //prerequisites bases are the same,add1>=add2( cnt ),
  //out Set of used digits
  var
    pMask: tpMask64;
    i, base, s, carry: NativeInt;
  begin
    pMask := @cOr_Mask64;
    base := add1.ntb_bas;
    dec(s,s);
    Result := s;
    carry := s;

    for i := 0 to add2.ntb_cnt - 1 do
    begin
      s := add1.ntb_dgt[i] + add2.ntb_dgt[i] + carry;
      carry := Ord(s >= base);
      s := s - (-carry and base);
      Result := Result or pMask[s];
      add1.ntb_dgt[i] := s;
    end;

    i := add2.ntb_cnt;
    while carry = 1 do
    begin
      s := add1.ntb_dgt[i] + carry;
      carry := Ord(s >= base);
      s := s - (-carry and base);
      Result := Result or pMask[s];
      add1.ntb_dgt[i] := s;
      Inc(i);
    end;

    if add1.ntb_cnt < i then
      add1.ntb_cnt := i;

    for i := i to add1.ntb_cnt - 1 do
      Result := Result or pMask[add1.ntb_dgt[i]];
  end;

  procedure TestRunThd(parameter: pointer);
  var
    pSqrNum, pdeltaNextSqr, pDelta: ^tNumtoBase;
    TestSet, TestSetComplete, i: Uint64;
    ThreadBlockIdx: NativeInt;
  begin
    ThreadBlockIdx := NativeUint(parameter);
    with ThreadBlocks[ThreadBlockIdx] do
    begin
      pSqrNum       := @cft_sqr2b;
      pdeltaNextSqr := @cft_deltaNextSqr;
      pDelta        := @cft_delta;
    end;
    TestSetComplete := Uint64(1) shl pSqrNum^.ntb_bas - 1;
    i := 0;
    repeat
      //next square number
      TestSet := AddNumSqr(pSqrNum^, pdeltaNextSqr^);
      AddNum(pdeltaNextSqr^, pdelta^);
      Inc(i);
      if finished <> 0 then
        BREAK;
    until TestSetComplete = TestSet;

    if finished = 0 then
    begin
      InterLockedIncrement(finished);
      ThreadBlocks[ThreadBlockIdx].cft_count := i;
      EndThread(i);
    end
    else
      EndThread(0);
  end;

  procedure Test(base: NativeInt);
  var
    stepWidth: Uint64;
    i, j,UsedThreads: NativeInt;
  begin
    write('Base ', base);
    StartValueCreate(base);
    deltaNextSqr := num;
    AddNum(deltaNextSqr, deltaNextSqr);
    IncSmallNum(deltaNextSqr, 1);
    stepWidth := 1;
    if (Base > 4) and not (DgtRtSqr.drs_NeedsOneMoreDigit) then
    begin
      //Find first number which can get the solution
      with dgtrtsqr do
        while drs_List[getDgtRtNum(num)] <> drs_sol do
        begin
          IncSmallNum(num, 1);
          AddNum(sqr2B, deltaNextSqr);
          IncSmallNum(deltaNextSqr, 2);
        end;
      stepWidth := (Base - 1) div DgtRtSqr.drs_SolCnt;
      if stepWidth * DgtRtSqr.drs_SolCnt <> (Base - 1) then
        stepWidth := 1;
    end;
    CalcDeltaSqr(num,deltaNextSqr,delta,stepWidth);
    writeln(' test every ', stepWidth);
//  Write('Start  :');OutNumSqr;
    i := 0;
    if not (CheckPandigital(sqr2b)) then
    begin
      finished := 0;
      j := 0;
      UsedThreads := gblThreadCount;
      if base < 21 then
        UsedThreads := 1;
      PrepareThreads(UsedThreads,stepWidth);
      j := 0;
      while (j < UsedThreads) and (finished = 0) do
      begin
        with ThreadBlocks[j] do
        begin
          cft_ThreadHandle :=
          BeginThread(@TestRunThd, Pointer(j), cft_ThreadID,
              4 * 4096);
        end;
        Inc(j);
      end;
      WaitForThreadTerminate(ThreadBlocks[0].cft_ThreadHandle, -1);
      repeat
        Dec(j);
        with ThreadBlocks[j] do
        begin
          WaitForThreadTerminate(cft_ThreadHandle, -1);
          if cft_count <> 0 then
            finished := j;
        end;
      until j = 0;
      i := ExtractThreadVal(finished);
      j := i*UsedThreads+finished;//TestCount starts at original num
      IncNumBig(num,j*stepWidth);
    end;
    OutNumSqr;
  end;

var
  T: TDateTime;
  base: NativeUint;
begin
  T := now;
  gblThreadCount:= GetThreadCount;
  writeln(' Cpu Count : ', gblThreadCount);
  setlength(ThreadBlocks, gblThreadCount);
  for base := 2 to 28 do
    Test(base);
  writeln('completed in ', (now - T) * 86400: 0: 3, ' seconds');
  setlength(ThreadBlocks, 0);
  {$IFDEF WINDOWS}
  readln;
  {$ENDIF}
end.

Output:

 Cpu Count : 4
Base 2 test every 1
 Num 10  sqr 100 
Base 3 test every 1
 Num 22  sqr 2101
Base 4 test every 1
 Num 33  sqr 3201
Base 5 insert 2 test every 1
 Num 243  sqr 132304
Base 6 test every 5
 Num 523  sqr 452013
Base 7 test every 6
 Num 1431  sqr 2450361
Base 8 test every 7
 Num 3344  sqr 13675420
Base 9 test every 4
 Num 11642  sqr 136802574
Base 10 test every 3
 Num 32043  sqr 1026753849
Base 11 test every 10
 Num 111453  sqr 1240A536789
Base 12 test every 11
 Num 3966B9  sqr 124A7B538609
Base 13 insert 3 test every 1
 Num 3828943  sqr 10254773CA86B9
Base 14 test every 13
 Num 3A9DB7C  sqr 10269B8C57D3A4
Base 15 test every 14
 Num 1012B857  sqr 102597BACE836D4
Base 16 test every 15
 Num 404A9D9B  sqr 1025648CFEA37BD9
Base 17 insert 1 test every 1
 Num 423F82GA9  sqr 101246A89CGFB357ED
Base 18 test every 17
 Num 44B482CAD  sqr 10236B5F8EG4AD9CH7
Base 19 test every 6
 Num 1011B55E9A  sqr 10234DHBG7CI8F6A9E5
Base 20 test every 19
 Num 49DGIH5D3G  sqr 1024E7CDI3HB695FJA8G
Base 21 insert 6 test every 1
 Num 4C9HE5FE27F  sqr 1023457DG9HI8J6B6KCEAF
Base 22 test every 21
 Num 4F94788GJ0F  sqr 102369FBGDEJ48CHI7LKA5
Base 23 test every 22
 Num 1011D3EL56MC  sqr 10234ACEDKG9HM8FBJIL756
Base 24 test every 23
 Num 4LJ0HDGF0HD3  sqr 102345B87HFECKJNIGMDLA69
Base 25 test every 12
 Num 1011E145FHGHM  sqr 102345DOECKJ6GFB8LIAM7NH9
Base 26 test every 5
 Num 52K8N53BDM99K  sqr 1023458LO6IEMKG79FPCHNJDBA
Base 27 test every 26
 Num 1011F11E37OBJJ  sqr 1023458ELOMDHBIJFGKP7CQ9N6A
Base 28 test every 9
 Num 58A3CKP3N4CQD7  sqr 1023456CGJBIRQEDHP98KMOAN7FL
completed in 15.652 seconds

real  0m15,654s
user  1m1,007s
// Ryzen 5 1600  3.4 Ghz on 6 cores/12 threads
Base 29 test every 1 threads = 12
Start  : Num 5BAEFC5QHESPCLA  sqr 10223456789ABCDKM4JI4S470KCSHD 
    1.00 min      24099604789
    2.00 min      48201071089
    3.00 min      72295381621
Result : Num 5BAEFC62RGS0KJF  sqr 102234586REOSIGJD9PCF7HBLKANQM 
  230.632 s Testcount :    92238034003       92238034003
 Num 5EF7R2P77FFPBMR  sqr 1023456789ABCDEPPNIG6S4MJNB8C9 
Base 30 test every 29 threads = 12
Start  : Num 5EF7R2P77FFPBN5  sqr 1023456789ABCDHNHROTMC0MS6RGKP 
Result : Num 5EF7R2POS9MQRN7  sqr 1023456DMAPECBQOLSITK9FR87GHNJ 
   35.626 s Testcount :    13343410738      386958911402
 Num 1011H10BS64GFL6U  sqr 1023456789ABCDEH3122BRSP7T7G6H1 
Base 31 test every 30 threads = 12
Start  : Num 1011H10BS64GFL76  sqr 1023456789ABCDF03FNNQ29H0ULION5 
Result : Num 1011H10CDMAUP44O  sqr 10234568ABQUJGCNFP7KEM9RHDLTSOI 
   41.251 s Testcount :    15152895679      454586870370
 Num 5L6HID7BTGM6RU9L  sqr 1023456789ABCDEFGQNN3264K1GRK97P 
Base 32 test every 31 threads = 12
Start  : Num 5L6HID7BTGM6RUAA  sqr 1023456789ABCDEMULAP8DRPBULSA2B4 
Result : Num 5L6HID7BVGE2CIEC  sqr 102345678VS9CMJDRAIOPLHNFQETBUKG 
    5.626 s Testcount :     2207946558       68446343298
completed in 317.047 seconds
 Num 1011I10CLMTDCMPC1  sqr 1023456789ABCDEFHSSWJ340NGCV8MTO1 
Base 33 test every 8 threads = 12
Start  : Num 1011I10CLMTDCMPC6  sqr 1023456789ABCDEFRT6F1D7S9EA03JJD3 
 Num 1011I10CLMTDCMPC1  sqr 1023456789ABCDEFHSSWJ340NGCV8MTO1 
Base 33 test every 8 threads = 12
Start  : Num 1011I10CLMTDCMPC6  sqr 1023456789ABCDEFRT6F1D7S9EA03JJD3 
    1.00 min     184621467265
    2.00 min     369105711649
Result : Num 1011I10CLWWNS6SKS  sqr 102345678THKFAERNWJGDOSQ9BCIUVMLP 
  140.634 s Testcount :    53808573863      430468590904
 Num 5SEMXRII09S90UO6V  sqr 1023456789ABCDEFGKNK3JK9NREFLEH5Q9 
Base 34 test every 33 threads = 12
Start  : Num 5SEMXRII09S90UO7P  sqr 1023456789ABCDEFQ7HPX8WRC9L0GV31SD 
    1.00 min     747770289553
    2.00 min    1495002801997
..  8.00 min    5978195501257
    9.00 min    6725222258833
Result : Num 5SEMXRII42NG8AKSL  sqr 102345679JIESRPA8BLCVKDNMHUFTGOQWX 
  549.392 s Testcount :   205094427126     6768116095158
 Num 1011J10DE6M9QOAY42  sqr 1023456789ABCDEFGHSOEHTX34IF9YB1CG4 
Base 35 test every 34 threads = 12
Start  : Num 1011J10DE6M9QOAY42  sqr 1023456789ABCDEFGHSOEHTX34IF9YB1CG4 
    1.00 min     749708230993
    2.00 min    1496695534873
.. 27.00 min   20178502394905
   28.00 min   20925398930617  //<== > solution, because finisched tested every 1.875 seconds
Result : Num 1011J10DEFW1QTVBXR  sqr 102345678RUEPV9KGQIWFOBAXCNSLDMYJHT 
 1681.925 s Testcount :   614575698110    20895573735740
 Num 6069962AODK1L20LTW  sqr 1023456789ABCDEFGHSWJSDUGHWCR30SK5CG 
Base 36 test every 35 threads = 12
Start  : Num 6069962AODK1L20LUU  sqr 1023456789ABCDEFGT58D9PASNXYM2SLPEP0 
    1.00 min     787213111441
    2.00 min    1586599478101
..192.00 min  152890333403641
  193.00 min  153686150046241
Result : Num 6069962APW1QG36EV8  sqr 102345678RGQKMOCBLZIYHN9WDJEUXFVPATS 
11584.118 s Testcount :  4392178427722   153726244970270
completed in 11584.118 seconds

Base 37 test every 1 threads = 12
Start  : Num 638NMI7KVO4Z0LEB6K7  sqr 1023456778A35I0aGIP71DUIJIPV7Y895H0AMC
    1.00 min    8626362427597  -> offset off 550 min calc before
    2.00 min    8643195114781
...
 2740.00 min   54839279882317
 2741.00 min   54936788352145
Result : Num 638NMI7KVOKXYYLI7DN  sqr 1023456778FCLXTERSDZJ9WVHAPGaNIMYUOQKB
210398.691 s Testcount : 56097957152641    56097957152641
+33000     s for reaching 8626362427597
-> ~ 67h36m40s 
 Num 66FVHSMH0OXH39bH6LT  sqr 1023456789ABCDEFGHIV4YWaF08URZ5H135NO5 
Base 38 test every 37 threads = 12
Start  : Num 66FVHSMH0OXH39bH6MN  sqr 1023456789ABCDEFGHT7ZLWWKUXYO9YZW62QbZ 
    1.00 min     785788279813
    2.00 min    1568354438749
.. 58.00 min   45309747953833
   59.00 min   46095937872493 
Result : Num 66FVHSMH0P60WK173YQ  sqr 1023456789DRTAINWaFJCHLYMQPGEBZVOKXSbU 
 3547.633 s Testcount :  1242398966051    45968761743887
completed in 3547.634 seconds
 Num 1011L10EZ7510RFTU2Ia  sqr 1023456789ABCDEFGHIKb22ISU7MJC5GAPVLY39 
Base 39 test every 38 threads = 12
Start  : Num 1011L10EZ7510RFTU2J0  sqr 1023456789ABCDEFGHIQb8BRYWIcN3BKJ3F7A00 
    1.00 min     795117225457
    2.00 min    1589942025409
..398.00 min  315778732951561
  399.00 min  316570538706841
Result : Num 1011L10EZ76L0a5UAJOF  sqr 1023456789DCFaKJPGLcEVSIBYZRTOMAbQHWXNU 
23998.810 s Testcount :  8310508262457   315799313973366 // old version 68000s 

Perl

Library: ntheory

use strict;
use warnings;
use feature 'say';
use ntheory qw/fromdigits todigitstring/;
use utf8;
binmode('STDOUT', 'utf8');

sub first_square  {
    my $n = shift;
    my $sr = substr('1023456789abcdef',0,$n);
    my $r  = int fromdigits($sr, $n) ** .5;
    my @digits = reverse split '', $sr;
    TRY: while (1) {
        my $sq = $r * $r;
        my $cnt = 0;
        my $s = todigitstring($sq, $n);
        my $i = scalar @digits;
        for (@digits) {
            $r++ and redo TRY if (-1 == index($s, $_)) || ($i-- + $cnt < $n);
            last if $cnt++ == $n;
        }
        return sprintf "Base %2d: %10s² == %s", $n, todigitstring($r, $n),
               todigitstring($sq, $n);
    }
}

say "First perfect square with N unique digits in base N: ";
say first_square($_) for 2..16;

Output:

First perfect square with N unique digits in base N: 
Base  2:         10² == 100
Base  3:         22² == 2101
Base  4:         33² == 3201
Base  5:        243² == 132304
Base  6:        523² == 452013
Base  7:       1431² == 2450361
Base  8:       3344² == 13675420
Base  9:      11642² == 136802574
Base 10:      32043² == 1026753849
Base 11:     111453² == 1240a536789
Base 12:     3966b9² == 124a7b538609
Base 13:    3828943² == 10254773ca86b9
Base 14:    3a9db7c² == 10269b8c57d3a4
Base 15:   1012b857² == 102597bace836d4
Base 16:   404a9d9b² == 1025648cfea37bd9

Alternative solution:

Library: ntheory

use strict;
use warnings;
use ntheory qw(:all);
use List::Util qw(uniq);

sub first_square {
    my ($base) = @_;

    my $start = sqrtint(fromdigits([1, 0, 2 .. $base-1], $base));

    for (my $k = $start ; ; ++$k) {
        if (uniq(todigits($k * $k, $base)) == $base) {
            return $k * $k;
        }
    }
}

foreach my $n (2 .. 16) {
    my $s = first_square($n);
    printf("Base %2d: %10s² == %s\n", $n,
        todigitstring(sqrtint($s), $n), todigitstring($s, $n));
}

Phix

Library: Phix/mpfr

Partial translation of VB with bitmap idea from C++ and adopting the digit-array approach from pascal instead of base conversion.

-- demo\rosetta\PandigitalSquares.exw
without javascript_semantics    -- (mpz_set_str() currently only supports bases 2, 8, 10, and 16 under pwa/p2js)
include mpfr.e
atom t0 = time()
constant chars = "0123456789abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz|",
         use_hll_code = true
 
function str_conv(sequence s, integer mode=+1)
-- mode of +1: eg {1,2,3} -> "123", mode of -1 the reverse.
-- note this doesn't really care what base s/res are in.
    {sequence res,integer dcheck} = iff(mode=+1?{"",9}:{{},'9'})
    for i=1 to length(s) do
        integer d = s[i]
        d += mode*iff(d>dcheck?'a'-10:'0')
        res &= d
    end for
    return res
end function
 
procedure do_one(integer base)
-- tabulates one base
    integer bm1 = base-1,
            dr = iff(and_bits(base,1) ? floor(base/2) : 0),
            id = 0, 
            rc = 0,
            sdri
    atom st = time()
    sequence sdr = repeat(0,bm1)
    for i=0 to bm1-1 do
        sdri = mod(i*i,bm1)
        rc += (sdri==dr)
        sdr[i+1] = iff(sdri=0 ? bm1 : sdri)
    end for
    if dr>0 then
        id = base
        for i=1 to dr do
            sdri = sdr[i+1]
            if sdri>=dr
            and id>sdri then
                id = sdri
            end if
        end for
        id -= dr
    end if
    string sq = chars[1..base]
    if id>0 then sq = sq[1..id]&chars[id+1]&sq[id+1..$] end if
    sq[1..2] = "10"
    mpz sqz = mpz_init(),
        rtz = mpz_init(),
        dnz = mpz_init(),
        tmp = mpz_init()
    mpz_set_str(sqz,sq,base)
    mpz_sqrt(rtz,sqz)
    mpz_add_ui(rtz,rtz,1)       -- rtz = sqrt(sqz)+1
    mpz_mul_si(dnz,rtz,2)
    mpz_add_si(dnz,dnz,1)       -- dnz = rtz*2+1
    mpz_mul(sqz,rtz,rtz)        -- sqz = rtz * rtz
    integer d = 1,
            inc = 1
    if base>3 and rc>0 then
        while mpz_fdiv_ui(sqz,bm1)!=dr do 
            -- align sqz to dr
            mpz_add_ui(rtz,rtz,1)   -- rtz += 1
            mpz_add(sqz,sqz,dnz)    -- sqz += dnz
            mpz_add_ui(dnz,dnz,2)   -- dnz += 2
        end while
        inc = floor(bm1/rc)
        if inc>1 then
            mpz_mul_si(tmp,rtz,inc-2)
            mpz_sub_ui(tmp,tmp,1)
            mpz_add(dnz,dnz,tmp)    -- dnz += rtz*(inc-2)-1
        end if
        d = inc * inc
        mpz_add(dnz,dnz,dnz)
        mpz_add_ui(dnz,dnz,d)       -- dnz += dnz + d
    end if
    d *= 2
    atom mask, fullmask = power(2,base)-1 -- ie 0b111..
    integer icount = 0
    mpz_set_si(tmp,d)
    sequence sqi = str_conv(mpz_get_str(sqz,base), mode:=-1),
             dni = str_conv(mpz_get_str(dnz,base), mode:=-1),
             dti = str_conv(mpz_get_str(tmp,base), mode:=-1)
    while true do
        if use_hll_code then
            mask = 0
            for i=1 to length(sqi) do
                mask = or_bits(mask,power(2,sqi[i]))
            end for
        else
            ?9/0 -- see below, inline part 1
        end if
        if mask=fullmask then exit end if
        integer carry = 0, sidx, si
        if use_hll_code then
            for sidx=-1 to -length(dni) by -1 do
                si = sqi[sidx]+dni[sidx]+carry
                carry = si>=base
                sqi[sidx] = si-carry*base
            end for
            sidx += length(sqi)+1
            while carry and sidx do
                si = sqi[sidx]+carry
                carry = si>=base
                sqi[sidx] = si-carry*base
                sidx -= 1
            end while
        else
            ?9/0 --see below, inline part 2
        end if
        if carry then
            sqi = carry&sqi
        end if
        carry = 0
        for sidx=-1 to -length(dti) by -1 do
            si = dni[sidx]+dti[sidx]+carry
            carry = floor(si/base)
            dni[sidx] = remainder(si,base)
        end for
        sidx += length(dni)+1
        while carry and sidx do
            si = dni[sidx]+carry
            carry = si>=base
            dni[sidx] = si-carry*base
            sidx -= 1
        end while
        if carry then
            dni = carry&dni
        end if
        icount += 1
    end while
    mpz_set_si(tmp,icount)
    mpz_mul_si(tmp,tmp,inc)
    mpz_add(rtz,rtz,tmp)            -- rtz += icount * inc
    sq = str_conv(sqi, mode:=+1)
    string rt = mpz_get_str(rtz,base),
           idstr = iff(id?sprintf("%d",id):" "),
           ethis = elapsed_short(time()-st),
           etotal = elapsed_short(time()-t0)
    printf(1,"%3d %3d %s %18s -> %-28s %10d %8s     %8s\n",
             {base, inc, idstr, rt, sq, icount, ethis, etotal})
    {sqz,rtz,dnz,tmp} = mpz_free({sqz,rtz,dnz,tmp})
end procedure
 
puts(1,"base inc id             root -> square" &
        "                       test count    time        total\n")
for base=2 to 19 do
--for base=2 to 25 do
--for base=2 to 28 do
    do_one(base)
end for
printf(1,"completed in %s\n", {elapsed(time()-t0)})

Output:

base inc id             root -> square                       test count    time        total
  2   1                   10 -> 100                                   0       0s           0s
  3   1                   22 -> 2101                                  4       0s           0s
  4   3                   33 -> 3201                                  2       0s           0s
  5   1 2                243 -> 132304                               14       0s           0s
  6   5                  523 -> 452013                               20       0s           0s
  7   6                 1431 -> 2450361                              34       0s           0s
  8   7                 3344 -> 13675420                             41       0s           0s
  9   4                11642 -> 136802574                           289       0s           0s
 10   3                32043 -> 1026753849                           17       0s           0s
 11  10               111453 -> 1240a536789                        1498       0s           0s
 12  11               3966b9 -> 124a7b538609                       6883       0s           0s
 13   1 3            3828943 -> 10254773ca86b9                     8242       0s           0s
 14  13              3a9db7c -> 10269b8c57d3a4                     1330       0s           0s
 15  14             1012b857 -> 102597bace836d4                    4216       0s           0s
 16  15             404a9d9b -> 1025648cfea37bd9                  18457       0s           0s
 17   1 1          423f82ga9 -> 101246a89cgfb357ed               195112       0s           0s
 18  17            44b482cad -> 10236b5f8eg4ad9ch7                30440       0s           0s
 19   6           1011b55e9a -> 10234dhbg7ci8f6a9e5               93021       0s           0s
completed in 0.5s

Performance drops significantly after that:

 20  19           49dgih5d3g -> 1024e7cdi3hb695fja8g           11310604       9s          10s
 21   1 6        4c9he5fe27f -> 1023457dg9hi8j6b6kceaf           601843       0s          10s
 22  21          4f94788gj0f -> 102369fbgdej48chi7lka5         27804949      25s          36s
 23  22         1011d3el56mc -> 10234acedkg9hm8fbjil756        17710217      17s          53s
 24  23         4lj0hdgf0hd3 -> 102345b87hfeckjnigmdla69        4266555       4s          58s
 25  12        1011e145fhghm -> 102345doeckj6gfb8liam7nh9      78092125     1:16         2:14
completed in 2 minutes and 15s

It takes a little over half an hour to get to 28. We can use "with profile_time" to identify
a couple of hotspots and replace them with inline assembly (setting use_hll_code to false).
[This is probably quite a good target for improving the quality of the generated code.]
Requires version 0.8.1+, not yet shipped, which will include demo\rosetta\PandigitalSquares.exw
64 bit code omitted for clarity, the code in PandigitalSquares.exw is twice as long.

--          ?9/0 -- see below, inline part 1
            mask = length(sqi)
            #ilASM{
                    mov esi,[sqi]
                    mov edx,[mask]
                    shl esi,2
                    xor eax,eax
                  @@:
                    mov edi,1
                    mov cl,[esi]
                    shl edi,cl
                    add esi,4
                    or eax,edi
                    sub edx,1
                    jnz @b
                    mov [mask],eax
                  }
--and
--          ?9/0 --see below, inline part 2
            if length(dni)=length(sqi) then
                sqi = 0&sqi
            end if
            #ilASM{
                    mov esi,[sqi]
                    mov edi,[dni]
                    mov ecx,[ebx+esi*4-12]  -- length(sqi)
                    mov edx,[ebx+edi*4-12]  -- length(dni)
                    lea esi,[esi+ecx-1]
                    lea edi,[edi+edx-1]
                    sub ecx,edx
                    xor eax,eax
                    lea esi,[ebx+esi*4]     -- locate sqi[$]
                    lea edi,[ebx+edi*4]     -- locate dni[$]
                    push ecx
                    mov ecx,[base]
                  @@:
                    add eax,[esi]
                    add eax,[edi]
                    div cl
                    mov [esi],ah
                    xor ah,ah
                    sub esi,4
                    sub edi,4
                    sub edx,1
                    jnz @b
                    pop edx
                  @@:
                    test eax,eax
                    jz @f
                    add eax,[esi]
                    div cl
                    mov [esi],ah
                    xor ah,ah
                    sub esi,4
                    sub edx,1
                    jnz @b
                  @@:
                    mov [carry],eax
                  }

Output:

 20  19           49dgih5d3g -> 1024e7cdi3hb695fja8g           11310604       2s           3s
 21   1 6        4c9he5fe27f -> 1023457dg9hi8j6b6kceaf           601843       0s           3s
 22  21          4f94788gj0f -> 102369fbgdej48chi7lka5         27804949       7s          10s
 23  22         1011d3el56mc -> 10234acedkg9hm8fbjil756        17710217       4s          14s
 24  23         4lj0hdgf0hd3 -> 102345b87hfeckjnigmdla69        4266555       1s          15s
 25  12        1011e145fhghm -> 102345doeckj6gfb8liam7nh9      78092125      18s          34s
completed in 34.3s

It takes 7 minutes and 20s to get to 28, still not quite up to the frankly astonishing 27s 12.3s of pascal, but getting there.

Python

Works with: Python version 3.7

'''Perfect squares using every digit in a given base.'''

from itertools import count, dropwhile, repeat
from math import ceil, sqrt
from time import time


# allDigitSquare :: Int -> Int -> Int
def allDigitSquare(base, above):
    '''The lowest perfect square which
       requires all digits in the given base.
    '''
    bools = list(repeat(True, base))
    return next(
        dropwhile(
            missingDigitsAtBase(base, bools),
            count(
                max(
                    above,
                    ceil(sqrt(int(
                        '10' + '0123456789abcdef'[2:base],
                        base
                    )))
                )
            )
        )
    )


# missingDigitsAtBase :: Int -> [Bool] -> Int -> Bool
def missingDigitsAtBase(base, bools):
    '''Fusion of representing the square of integer N at a
       given base with checking whether all digits of
       that base contribute to N^2.
       Clears the bool at a digit position to False when used.
       True if any positions remain uncleared (unused).
    '''
    def go(x):
        xs = bools.copy()
        while x:
            xs[x % base] = False
            x //= base
        return any(xs)
    return lambda n: go(n * n)


# digit :: Int -> Char
def digit(n):
    '''Digit character for given integer.'''
    return '0123456789abcdef'[n]


# ------------------------- TEST -------------------------
# main :: IO ()
def main():
    '''Smallest perfect squares using all digits in bases 2-16'''

    start = time()

    print(main.__doc__ + ':\n\nBase      Root    Square')
    q = 0
    for b in enumFromTo(2)(16):
        q = allDigitSquare(b, q)
        print(
            str(b).rjust(2, ' ') + ' -> ' +
            showIntAtBase(b)(digit)(q)('').rjust(8, ' ') +
            ' -> ' +
            showIntAtBase(b)(digit)(q * q)('')
        )

    print(
        '\nc. ' + str(ceil(time() - start)) + ' seconds.'
    )


# ----------------------- GENERIC ------------------------

# enumFromTo :: (Int, Int) -> [Int]
def enumFromTo(m):
    '''Integer enumeration from m to n.'''
    return lambda n: list(range(m, 1 + n))


# showIntAtBase :: Int -> (Int -> String) -> Int -> 
# String -> String
def showIntAtBase(base):
    '''String representation of an integer in a given base,
       using a supplied function for the string representation
       of digits.
    '''
    def wrap(toChr, n, rs):
        def go(nd, r):
            n, d = nd
            r_ = toChr(d) + r
            return go(divmod(n, base), r_) if 0 != n else r_
        return 'unsupported base' if 1 >= base else (
            'negative number' if 0 > n else (
                go(divmod(n, base), rs))
        )
    return lambda toChr: lambda n: lambda rs: (
        wrap(toChr, n, rs)
    )


# MAIN ---
if __name__ == '__main__':
    main()

Output:

Smallest perfect squares using all digits in bases 2-16:

Base      Root    Square
 2 ->       10 -> 100
 3 ->       22 -> 2101
 4 ->       33 -> 3201
 5 ->      243 -> 132304
 6 ->      523 -> 452013
 7 ->     1431 -> 2450361
 8 ->     3344 -> 13675420
 9 ->    11642 -> 136802574
10 ->    32043 -> 1026753849
11 ->   111453 -> 1240a536789
12 ->   3966b9 -> 124a7b538609
13 ->  3828943 -> 10254773ca86b9
14 ->  3a9db7c -> 10269b8c57d3a4
15 -> 1012b857 -> 102597bace836d4
16 -> 404a9d9b -> 1025648cfea37bd9

c. 30 seconds.

Quackery

from, index, and end are defined at Loops/Increment loop index within loop body#Quackery.

 [ dup 1
    [ 2dup > while
      + 1 >>
      2dup / again ]
    drop nip ]            is sqrt       ( n --> n )

  [ base share bit 1 -
    0 rot
    [ dup while
      base share /mod bit
      rot | swap again ]
    drop = ]              is pandigital ( n --> b )

  [ base share
    dup 2 - times
      [ base share *
       i^ 2 + + ] ]       is firstpan   (   --> n )

  [ dup * ]               is squared    ( n --> n )

  11 times
    [ i^ 2 + base put
      firstpan sqrt from
        [ index squared
          pandigital if
            [ index end ] ]
      base share
      say "Base " decimal echo
      base release
      say ": " dup echo
      say "^" 2 echo say " = " 
      squared echo
      cr base release ]

Output:

Base 2: 10^10 = 100
Base 3: 22^2 = 2101
Base 4: 33^2 = 3201
Base 5: 243^2 = 132304
Base 6: 523^2 = 452013
Base 7: 1431^2 = 2450361
Base 8: 3344^2 = 13675420
Base 9: 11642^2 = 136802574
Base 10: 32043^2 = 1026753849
Base 11: 111453^2 = 1240A536789
Base 12: 3966B9^2 = 124A7B538609

Raku

(formerly Perl 6)

Works with: Rakudo version 2019.03

As long as you have the patience, this will work for bases 2 through 36.

Bases 2 through 19 finish quickly, (about 10 seconds on my system), 20 takes a while, 21 is pretty fast, 22 is glacial. 23 through 26 takes several hours.

Use analytical start value filtering based on observations by Hout++ and Nigel Galloway++ on the discussion page.

Try it online!

#`[

Only search square numbers that have at least N digits;
smaller could not possibly match.

Only bother to use analytics for large N. Finesse takes longer than brute force for small N.

]

unit sub MAIN ($timer = False);

sub first-square (Int $n) {
    my @start = flat '1', '0', (2 ..^ $n)».base: $n;

    if $n > 10 { # analytics
        my $root  = digital-root( @start.join, :base($n) );
        my @roots = (2..$n).map(*²).map: { digital-root($_.base($n), :base($n) ) };
        if $root ∉ @roots {
            my $offset = min(@roots.grep: * > $root ) - $root;
            @start[1+$offset] = $offset ~ @start[1+$offset];
        }
    }

    my $start = @start.join.parse-base($n).sqrt.ceiling;
    my @digits = reverse (^$n)».base: $n;
    my $sq;
    my $now  = now;
    my $time = 0;
    my $sr;
    for $start .. * {
        $sq = .²;
        my $s = $sq.base($n);
        my $f;
        $f = 1 and last unless $s.contains: $_ for @digits;
        if $timer && $n > 19 && $_ %% 1_000_000 {
            $time += now - $now;
            say "N $n:  {$_}² = $sq <$s> : {(now - $now).round(.001)}s" ~
                " : {$time.round(.001)} elapsed";
            $now = now;
        }
        next if $f;
        $sr = $_;
        last
    }
    sprintf( "Base %2d: %13s² == %-30s", $n, $sr.base($n), $sq.base($n) ) ~
        ($timer ?? ($time + now - $now).round(.001) !! '');
}

sub digital-root ($root is copy, :$base = 10) {
    $root = $root.comb.map({:36($_)}).sum.base($base) while $root.chars > 1;
    $root.parse-base($base);
}

say  "First perfect square with N unique digits in base N: ";
say .&first-square for flat
   2 .. 12, # required
  13 .. 16, # optional
  17 .. 19, # stretch
  20, # slow
  21, # pretty fast
  22, # very slow
  23, # don't hold your breath
  24, # slow but not too terrible
  25, # very slow
  26, #   "
;

Output:

First perfect square with N unique digits in base N:
Base  2:            10² == 100
Base  3:            22² == 2101
Base  4:            33² == 3201
Base  5:           243² == 132304
Base  6:           523² == 452013
Base  7:          1431² == 2450361
Base  8:          3344² == 13675420
Base  9:         11642² == 136802574
Base 10:         32043² == 1026753849
Base 11:        111453² == 1240A536789
Base 12:        3966B9² == 124A7B538609
Base 13:       3828943² == 10254773CA86B9
Base 14:       3A9DB7C² == 10269B8C57D3A4
Base 15:      1012B857² == 102597BACE836D4
Base 16:      404A9D9B² == 1025648CFEA37BD9
Base 17:     423F82GA9² == 101246A89CGFB357ED
Base 18:     44B482CAD² == 10236B5F8EG4AD9CH7
Base 19:    1011B55E9A² == 10234DHBG7CI8F6A9E5
Base 20:    49DGIH5D3G² == 1024E7CDI3HB695FJA8G
Base 21:   4C9HE5FE27F² == 1023457DG9HI8J6B6KCEAF
Base 22:   4F94788GJ0F² == 102369FBGDEJ48CHI7LKA5
Base 23:  1011D3EL56MC² == 10234ACEDKG9HM8FBJIL756
Base 24:  4LJ0HDGF0HD3² == 102345B87HFECKJNIGMDLA69
Base 25: 1011E145FHGHM² == 102345DOECKJ6GFB8LIAM7NH9
Base 26: 52K8N53BDM99K² == 1023458LO6IEMKG79FPCHNJDBA

REXX

The   REXX   language doesn't have a   sqrt   function,   nor does it have a general purpose radix (base) convertor,
so RYO versions were included here.

These REXX versions can handle up to base 36, but could be extended.

slightly optimized

/*REXX program finds/displays the first perfect square with  N  unique digits in base N.*/
numeric digits 40                                /*ensure enough decimal digits for a #.*/
parse arg LO HI .                                /*obtain optional argument from the CL.*/
if LO==''            then do;  LO=2;  HI=16; end /*not specified?  Then use the default.*/
if LO==','           then      LO=2              /*not specified?  Then use the default.*/
if HI=='' | HI==","  then             HI=LO      /*not specified?  Then use the default.*/
@start= 1023456789abcdefghijklmnopqrstuvwxyz     /*contains the start # (up to base 36).*/
                                                 /* [↓]  find the smallest square with  */
    do j=LO  to HI;        beg= left(@start, j)  /*      N  unique digits in base  N.   */
       do k=iSqrt( base(beg,10,j) )  until #==0  /*start each search from smallest sqrt.*/
       $= base(k*k, j, 10)                       /*calculate square, convert to base J. */
       $u= $;              upper $u              /*get an uppercase version fast count. */
       #= verify(beg, $u)                        /*count differences between 2 numbers. */
       end   /*k*/
    say 'base'            right(j, length(HI) )                   "   root="   ,
                   lower( right( base(k, j, 10), max(5, HI) ) )   '   square='    lower($)
    end      /*j*/
exit                                             /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
base: procedure;  arg x 1 #,toB,inB              /*obtain:  three arguments.            */
      @l= '0123456789abcdefghijklmnopqrstuvwxyz' /*lowercase (Latin or English) alphabet*/
      @u= @l;     upper @u                       /*uppercase    "    "    "         "   */
      if inb\==10  then                          /*only convert if  not  base 10.       */
         do 1;  #= 0                             /*result of converted  X  (in base 10).*/
         if inb==2   then do; #= b2d(x); leave; end  /*convert   binary    to decimal.  */
         if inb==16  then do; #= x2d(x); leave; end  /*   "    hexadecimal  "    "      */
           do j=1  for length(x)                 /*convert  X:   base inB  ──► base 10. */
           #= # * inB + pos(substr(x,j,1), @u)-1 /*build a new number,  digit by digit. */
           end    /*j*/                          /* [↑]  this also verifies digits.     */
         end
      y=                                         /*the value of  X  in base  B (so far).*/
      if tob==10  then return #                  /*if TOB is ten,  then simply return #.*/
      if tob==2   then return d2b(#)             /*convert base 10 number to binary.    */
      if tob==16  then return lower( d2x(#) )    /*   "      "   "    "    " hexadecimal*/
         do  while  # >= toB                     /*convert #:    decimal  ──►  base toB.*/
         y= substr(@l, (# // toB) + 1, 1)y       /*construct the output number.         */
         #= # % toB                              /*      ··· and whittle  #  down also. */
         end    /*while*/                        /* [↑]  algorithm may leave a residual.*/
      return substr(@l, # + 1, 1)y               /*prepend the residual, if any.        */
/*──────────────────────────────────────────────────────────────────────────────────────*/
iSqrt: procedure; parse arg x;  r=0;  q=1;             do while q<=x;  q=q*4;  end
        do while q>1; q=q%4; _=x-r-q; r=r%2; if _>=0 then do;x=_;r=r+q; end; end; return r
/*──────────────────────────────────────────────────────────────────────────────────────*/
b2d:   return x2d( b2x( arg(1) ) )               /*convert binary      number to decimal*/
d2b:   return x2b( d2x( arg(1) ) )  +  0         /*   "    hexadecimal    "    "    "   */
lower: @abc= 'abcdefghijklmnopqrstuvwxyz'; return translate(arg(1), @abc, translate(@abc))

output   when using the default input:

base  2    root=               10    square= 100
base  3    root=               22    square= 2101
base  4    root=               33    square= 3201
base  5    root=              243    square= 132304
base  6    root=              523    square= 452013
base  7    root=             1431    square= 2450361
base  8    root=             3344    square= 13675420
base  9    root=            11642    square= 136802574
base 10    root=            32043    square= 1026753849
base 11    root=           111453    square= 1240a536789
base 12    root=           3966b9    square= 124a7b538609
base 13    root=          3828943    square= 10254773ca86b9
base 14    root=          3a9db7c    square= 10269b8c57d3a4
base 15    root=         1012b857    square= 102597bace836d4
base 16    root=         404a9d9b    square= 1025648cfea37bd9

more optimized

This REXX version uses a highly optimized   base   function since it was that particular function that was consuming the majority of the CPU time.

It is about   10%   faster.

/*REXX program finds/displays the first perfect square with  N  unique digits in base N.*/
numeric digits 40                                /*ensure enough decimal digits for a #.*/
parse arg LO HI .                                /*obtain optional argument from the CL.*/
if LO==''            then do;  LO=2;  HI=16; end /*not specified?  Then use the default.*/
if LO==','           then      LO=2              /* "      "         "   "   "     "    */
if HI=='' | HI==","  then             HI=LO      /* "      "         "   "   "     "    */
@start= 1023456789abcdefghijklmnopqrstuvwxyz     /*contains the start # (up to base 36).*/
call base                                        /*initialize 2 arrays for BASE function*/
                                                 /* [↓]  find the smallest square with  */
    do j=LO  to HI;        beg= left(@start, j)  /*      N  unique digits in base  N.   */
       do k=iSqrt( base(beg,10,j) )  until #==0  /*start each search from smallest sqrt.*/
       $= base(k*k, j, 10)                       /*calculate square, convert to base J. */
       #= verify(beg, $)                         /*count differences between 2 numbers. */
       end   /*k*/
    say 'base'            right(j, length(HI) )                   "   root="   ,
                   lower( right( base(k, j, 10), max(5, HI) ) )   '   square='    lower($)
    end      /*j*/
exit                                             /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
base: procedure expose !. !!.; arg x 1 #,toB,inB /*obtain:  three arguments.            */
      @= 0123456789abcdefghijklmnopqrstuvwxyz    /*the characters for the Latin alphabet*/
      if x==''  then do i=1  for length(@);   _= substr(@, i, 1);    m= i - 1;    !._= m
                     !!.m= substr(@, i, 1)
                     if i==length(@) then return /*Done with shortcuts?  Then go back.  */
                     end   /*i*/                 /* [↑]  assign shortcut radix values.  */
      if inb\==10  then                          /*only convert if  not  base 10.       */
         do 1;  #= 0                             /*result of converted  X  (in base 10).*/
         if inb==2   then do; #= b2d(x); leave; end  /*convert   binary    to decimal.  */
         if inb==16  then do; #= x2d(x); leave; end  /*   "    hexadecimal  "    "      */
           do j=1  for length(x)                 /*convert  X:   base inB  ──► base 10. */
           _= substr(x, j, 1);  #= # * inB + !._ /*build a new number,  digit by digit. */
           end    /*j*/                          /* [↑]  this also verifies digits.     */
         end
      y=                                         /*the value of  X  in base  B (so far).*/
      if tob==10  then return #                  /*if TOB is ten,  then simply return #.*/
      if tob==2   then return d2b(#)             /*convert base 10 number to binary.    */
      if tob==16  then return d2x(#)             /*   "      "   "    "    " hexadecimal*/
         do  while  # >= toB                     /*convert #:    base 10  ──►  base toB.*/
         _= # // toB;           y= !!._ || y     /*construct the output number.         */
         #= # % toB                              /*      ··· and whittle  #  down also. */
         end    /*while*/                        /* [↑]  algorithm may leave a residual.*/
      return !!.# || y                           /*prepend the residual, if any.        */
/*──────────────────────────────────────────────────────────────────────────────────────*/
iSqrt: procedure; parse arg x;  r=0;  q=1;             do while q<=x;  q=q*4;  end
        do while q>1; q=q%4; _=x-r-q; r=r%2; if _>=0 then do;x=_;r=r+q; end; end; return r
/*──────────────────────────────────────────────────────────────────────────────────────*/
b2d:   return x2d( b2x( arg(1) ) )               /*convert binary      number to decimal*/
d2b:   return x2b( d2x( arg(1) ) )  +  0         /*   "    hexadecimal    "    "    "   */
lower: @abc= 'abcdefghijklmnopqrstuvwxyz'; return translate(arg(1), @abc, translate(@abc))

output   is identical to the 1^st REXX version.

Ring

basePlus = []
decList = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
baseList = ["0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"]

see "working..." + nl

for base = 2 to 10
for n = 1 to 40000 
    basePlus = []
    nrPow = pow(n,2)
    str = decimaltobase(nrPow,base)
    ln = len(str)
    for m = 1 to ln
        nr = str[m]
        ind = find(baseList,nr)
        num = decList[ind]
        add(basePlus,num)
    next
    flag = 1
    basePlus = sort(basePlus)
    if len(basePlus) = base
       for p = 1 to base
           if basePlus[p] = p-1
              flag = 1
           else
              flag = 0
              exit
           ok 
       next
       if flag = 1
          see "in base: " + base + " root: " + n + " square: " + nrPow + " perfect square: " + str + nl
          exit
       ok
     ok        
next
next
see "done..." + nl

func decimaltobase(nr,base)
     binList = [] 
     binary = 0
     remainder = 1
     while(nr != 0)
          remainder = nr % base
          ind = find(decList,remainder)
          rem = baseList[ind]
          add(binList,rem)
          nr = floor(nr/base) 
     end
     binlist = reverse(binList)
     binList = list2str(binList)
     binList = substr(binList,nl,"")  
     return binList

Output:

in base: 4 root: 15 square: 225 perfect square: 3201
in base: 6 root: 195 square: 38025 perfect square: 452013
in base: 7 root: 561 square: 314721 perfect square: 2450361
in base: 8 root: 1764 square: 3111696 perfect square: 13675420
in base: 9 root: 7814 square: 61058596 perfect square: 136802574
in base: 10 root: 32043 square: 1026753849 perfect square: 1026753849
done...

RPL

Works with: HP version 49

≪ → base
  ≪ { } base + 0 CON SWAP
     WHILE DUP REPEAT
        base IDIV2
        ROT SWAP 1 + DUP PUT SWAP
     END
     DROP OBJ→ 1 GET →LIST ΠLIST
≫ ≫ 'PANB?' STO @ ( number base → boolean ) 

≪ → base
  ≪ ""
     WHILE OVER REPEAT
        SWAP base IDIV2
        "0123456789ABCDEF" SWAP 1 + DUP SUB
        ROT +
     END
     SWAP DROP
≫ ≫ '→B' STO @ ( number_10 base → "number_base" )

≪ → base
  ≪ 0
     1 base 1 - FOR j   @ this loop generates the smallest pandigital number for the base
        base 
        IF j 2 == THEN SQ END
        * j + 
     NEXT
     √ IP
     WHILE DUP SQ base PANB? NOT REPEAT 1 + END
     base ": " +
     OVER base →B + "² = " +
     SWAP SQ base →B +
 ≫ ≫ ‘SQPAN’ STO @ ( → "base: n² = pandigital" )

≪ { }
   2 15 FOR b
      base SQPAN + NEXT
 ≫ ‘TASK’ STO

The above code can be run on a HP-48G if IDIV2 is implemented such as : ≪ MOD LASTARG / IP SWAP ≫

Output:

1: { "2: 10² = 100" "3: 22² = 2101" "4: 33² = 3201" "5: 243² = 132304" "6: 523² = 452013" "7: 1431² = 2450361"
"8: 3344² = 13675420" "9: 11642² = 136802574" "10: 32043² = 1026753849" "11: 111453² = 1240A536789" "12: 3966B9² = 124A7B538609" "13: 3828943² = 10254773CA86B9" "14: 3A9DB7C² = 10269B8C57D3A4" "15: 1012B857² = 102597BACE836D4" }

Ruby

Takes about 15 seconds on my dated PC, most are spent calculating base 13.

DIGITS = "1023456789abcdefghijklmnopqrstuvwxyz"

2.upto(16) do |n|
  start = Integer.sqrt( DIGITS[0,n].to_i(n) )
  res = start.step.detect{|i| (i*i).digits(n).uniq.size == n }
  puts "Base %2d:%10s² = %-14s" % [n, res.to_s(n), (res*res).to_s(n)]
end

Output:

Base  2:        10² = 100           
Base  3:        22² = 2101          
Base  4:        33² = 3201          
Base  5:       243² = 132304        
Base  6:       523² = 452013        
Base  7:      1431² = 2450361       
Base  8:      3344² = 13675420      
Base  9:     11642² = 136802574     
Base 10:     32043² = 1026753849    
Base 11:    111453² = 1240a536789   
Base 12:    3966b9² = 124a7b538609  
Base 13:   3828943² = 10254773ca86b9
Base 14:   3a9db7c² = 10269b8c57d3a4
Base 15:  1012b857² = 102597bace836d4
Base 16:  404a9d9b² = 1025648cfea37bd9

Sidef

func first_square(b) {

    var start = [1, 0, (2..^b)...].flip.map_kv{|k,v| v * b**k }.sum.isqrt

    start..Inf -> first_by {|k|
        k.sqr.digits(b).freq.len == b
    }.sqr
}

for b in (2..16) {
    var s = first_square(b)
    printf("Base %2d: %10s² == %s\n", b, s.isqrt.base(b), s.base(b))
}

Output:

Base  2:         10² == 100
Base  3:         22² == 2101
Base  4:         33² == 3201
Base  5:        243² == 132304
Base  6:        523² == 452013
Base  7:       1431² == 2450361
Base  8:       3344² == 13675420
Base  9:      11642² == 136802574
Base 10:      32043² == 1026753849
Base 11:     111453² == 1240a536789
Base 12:     3966b9² == 124a7b538609
Base 13:    3828943² == 10254773ca86b9
Base 14:    3a9db7c² == 10269b8c57d3a4
Base 15:   1012b857² == 102597bace836d4
Base 16:   404a9d9b² == 1025648cfea37bd9

Uiua

No integer arithmetic in Uiua, so it's a bit slow...

BaseN ← setinv(↘2⍢(⊂⊂:⊙(⊃(↙1)(↘2))⊂⊃(⌊÷)◿°⊟↙2.)(>0 ⊢↘1)⊟|/+×ⁿ:⊙(⇌⇡⧻.))
IsPan ← =⧻◴: # IsPan 3 [0 1 2]
# Smallest pan number for given base
# = [1 0 2 3 4...] in base n
MinPanBase ← °BaseN ⟜(↙:⊂[1 0]↘2⇡+1.)
MinPanSqrBase ← ⊙◌⍢(+1)(¬IsPan :BaseN ,×.) ⌊√MinPanBase.
ShowMinPan ← (
  ≡(
    &pf "\t" &pf . &pf "Base "
    MinPanSqrBase .
    &p BaseN : &pf "\t" &pf. × &pf "\t" &pf. .
  )
)

⍜now (ShowMinPan ↘2⇡13)

Output:

stdout:
Base 2	2	4	[1 0 0]
Base 3	8	64	[2 1 0 1]
Base 4	15	225	[3 2 0 1]
Base 5	73	5329	[1 3 2 3 0 4]
Base 6	195	38025	[4 5 2 0 1 3]
Base 7	561	314721	[2 4 5 0 3 6 1]
Base 8	1764	3111696	[1 3 6 7 5 4 2 0]
Base 9	7814	61058596	[1 3 6 8 0 2 5 7 4]
Base 10	32043	1026753849	[1 0 2 6 7 5 3 8 4 9]
Base 11	177565	31529329225	[1 2 4 0 10 5 3 6 7 8 9]
Base 12	944493	892067027049	[1 2 4 10 7 11 5 3 8 6 0 9]

17.243999999999915 [ooof]

Visual Basic .NET

Library: System.Numerics

This is faster than the Go version, but not as fast as the Pascal version. The Pascal version uses an array of integers to represent the square, as it's more efficient to increment and check that way.
This Visual Basic .NET version uses BigInteger variables for computation. It's quick enough for up to base19, tho.

Imports System.Numerics

Module Program
    Dim base, bm1 As Byte, hs As New HashSet(Of Byte), st0 As DateTime
    Const chars As String = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz|"

    ' converts base10 to string, using current base
    Function toStr(ByVal b As BigInteger) As String
        toStr = "" : Dim re As BigInteger : While b > 0
            b = BigInteger.DivRem(b, base, re) : toStr = chars(CByte(re)) & toStr : End While
    End Function

    ' checks for all digits present, checks every one (use when extra digit is present)
    Function allIn(ByVal b As BigInteger) As Boolean
        Dim re As BigInteger : hs.Clear() : While b > 0 : b = BigInteger.DivRem(b, base, re)
            hs.Add(CByte(re)) : End While : Return hs.Count = base
    End Function

    ' checks for all digits present, bailing when duplicates occur (can't use when extra digit is present)
    Function allInQ(ByVal b As BigInteger) As Boolean
        Dim re As BigInteger, c As Integer = 0 : hs.Clear() : While b > 0 : b = BigInteger.DivRem(b, base, re)
            hs.Add(CByte(re)) : c += 1 : If c <> hs.Count Then Return False
        End While : Return True
    End Function

    ' converts string to base 10, using current base
    Function to10(s As String) As BigInteger
        to10 = 0 : For Each i As Char In s : to10 = to10 * base + chars.IndexOf(i) : Next
    End Function

    ' returns minimum string representation, optionally inserting a digit
    Function fixup(n As Integer) As String
        fixup = chars.Substring(0, base)
        If n > 0 Then fixup = fixup.Insert(n, n.ToString)
        fixup = "10" & fixup.Substring(2)
    End Function

    ' returns close approx.
    Function IntSqRoot(v As BigInteger) As BigInteger
        IntSqRoot = New BigInteger(Math.Sqrt(CDbl(v))) : Dim term As BigInteger
        Do : term = v / IntSqRoot : If BigInteger.Abs(term - IntSqRoot) < 2 Then Exit Do
            IntSqRoot = (IntSqRoot + term) / 2 : Loop Until False
    End Function

    ' tabulates one base
    Sub doOne()
        bm1 = base - 1 : Dim dr As Byte = 0 : If (base And 1) = 1 Then dr = base >> 1
        Dim id As Integer = 0, inc As Integer = 1, i As Long = 0, st As DateTime = DateTime.Now
        Dim sdr(bm1 - 1) As Byte, rc As Byte = 0 : For i = 0 To bm1 - 1 : sdr(i) = (i * i) Mod bm1
            rc += If(sdr(i) = dr, 1, 0) : sdr(i) += If(sdr(i) = 0, bm1, 0) : Next : i = 0
        If dr > 0 Then
            id = base : For i = 1 To dr : If sdr(i) >= dr Then If id > sdr(i) Then id = sdr(i)
            Next : id -= dr : i = 0 : End If
        Dim sq As BigInteger = to10(fixup(id)), rt As BigInteger = IntSqRoot(sq) + 0,
            dn As BigInteger = (rt << 1) + 1, d As BigInteger = 1
        sq = rt * rt : If base > 3 AndAlso rc > 0 Then
            While sq Mod bm1 <> dr : rt += 1 : sq += dn : dn += 2 : End While ' alligns sq to dr
            inc = bm1 \ rc : If inc > 1 Then dn += rt * (inc - 2) - 1 : d = inc * inc
            dn += dn + d
        End If : d <<= 1 : If base > 5 AndAlso rc > 0 Then : Do : If allInQ(sq) Then Exit Do
                sq += dn : dn += d : i += 1 : Loop Until False : Else : Do : If allIn(sq) Then Exit Do
                sq += dn : dn += d : i += 1 : Loop Until False : End If : rt += i * inc
        Console.WriteLine("{0,3} {1,3} {2,2} {3,20} -> {4,-38} {5,10} {6,8:0.000}s   {7,8:0.000}s",
                          base, inc, If(id = 0, " ", id.ToString), toStr(rt), toStr(sq), i,
                          (DateTime.Now - st).TotalSeconds, (DateTime.Now - st0).TotalSeconds)
    End Sub

    Sub Main(args As String())
        st0 = DateTime.Now
        Console.WriteLine("base inc id                root    square" & _
            "                                 test count    time        total")
        For base = 2 To 28 : doOne() : Next
        Console.WriteLine("Elasped time was {0,8:0.00} minutes", (DateTime.Now - st0).TotalMinutes)
    End Sub
End Module

Output:

This output is on a somewhat modern PC. For comparison, it takes TIO.run around 30 seconds to reach base20, so TIO.run is around 3 times slower there.

base inc id                root    square                                 test count    time        total
  2   1                      10 -> 100                                             1    0.007s      0.057s
  3   1                      22 -> 2101                                            5    0.000s      0.057s
  4   3                      33 -> 3201                                            2    0.001s      0.058s
  5   1  2                  243 -> 132304                                         15    0.000s      0.058s
  6   5                     523 -> 452013                                         20    0.000s      0.059s
  7   6                    1431 -> 2450361                                        35    0.000s      0.059s
  8   7                    3344 -> 13675420                                       41    0.000s      0.059s
  9   4                   11642 -> 136802574                                     289    0.000s      0.059s
 10   3                   32043 -> 1026753849                                     17    0.000s      0.059s
 11  10                  111453 -> 1240A536789                                  1498    0.001s      0.060s
 12  11                  3966B9 -> 124A7B538609                                 6883    0.005s      0.065s
 13   1  3              3828943 -> 10254773CA86B9                               8243    0.013s      0.078s
 14  13                 3A9DB7C -> 10269B8C57D3A4                               1330    0.000s      0.078s
 15  14                1012B857 -> 102597BACE836D4                              4216    0.003s      0.081s
 16  15                404A9D9B -> 1025648CFEA37BD9                            18457    0.012s      0.093s
 17   1  1            423F82GA9 -> 101246A89CGFB357ED                         195113    0.341s      0.434s
 18  17               44B482CAD -> 10236B5F8EG4AD9CH7                          30440    0.022s      0.456s
 19   6              1011B55E9A -> 10234DHBG7CI8F6A9E5                         93021    0.068s      0.524s
 20  19              49DGIH5D3G -> 1024E7CDI3HB695FJA8G                     11310604    8.637s      9.162s
 21   1  6          4C9HE5FE27F -> 1023457DG9HI8J6B6KCEAF                     601844    1.181s     10.342s
 22  21             4F94788GJ0F -> 102369FBGDEJ48CHI7LKA5                   27804949   21.677s     32.020s
 23  22            1011D3EL56MC -> 10234ACEDKG9HM8FBJIL756                  17710217   14.292s     46.312s
 24  23            4LJ0HDGF0HD3 -> 102345B87HFECKJNIGMDLA69                  4266555    3.558s     49.871s
 25  12           1011E145FHGHM -> 102345DOECKJ6GFB8LIAM7NH9                78092125   69.914s    119.785s
 26   5           52K8N53BDM99K -> 1023458LO6IEMKG79FPCHNJDBA              402922569  365.929s    485.714s
 27  26          1011F11E37OBJJ -> 1023458ELOMDHBIJFGKP7CQ9N6A             457555293  420.607s    906.321s
 28   9          58A3CKP3N4CQD7 -> 1023456CGJBIRQEDHP98KMOAN7FL            749593055  711.660s   1617.981s
Elasped time was    26.97 minutes

Base29 seems to take an order of magnitude longer. I'm looking into some shortcuts.

Wren

Translation of: Go

Library: Wren-big

Library: Wren-math

Library: Wren-fmt

Base 21 is as far as we can reasonably fly here though (unsurprisingly) base 20 takes a long time.

import "./big" for BigInt
import "./math" for Nums
import "./fmt" for Conv, Fmt

var maxBase  = 21
var minSq36  = "1023456789abcdefghijklmnopqrstuvwxyz"
var minSq36x = "10123456789abcdefghijklmnopqrstuvwxyz"

var containsAll = Fn.new { |sq, base|
    var found = List.filled(maxBase, 0)
    var le = sq.count
    var reps = 0
    for (r in sq) {
        var d = r.bytes[0] - 48
        if (d > 38) d = d - 39
        found[d] = found[d] + 1
        if (found[d] > 1) {
            reps = reps + 1
            if (le - reps < base) return false
        }
    }
    return true
}

var sumDigits = Fn.new { |n, base|
    var sum = BigInt.zero
    while (n > 0) {
        sum = sum + (n%base)
        n = n/base
    }
    return sum
}

var digitalRoot = Fn.new { |n, base|
    while (n > base - 1) n = sumDigits.call(n, base)
    return n.toSmall
}

var minStart = Fn.new { |base|
    var ms = minSq36[0...base]
    var nn = BigInt.fromBaseString(ms, base)
    var bdr = digitalRoot.call(nn, base)
    var drs = []
    var ixs = []
    for (n in 1...2*base) {
        nn = BigInt.new(n*n)
        var dr = digitalRoot.call(nn, base)
        if (dr == 0) dr = n * n
        if (dr == bdr) ixs.add(n)
        if (n < base && dr >= bdr) drs.add(dr)
    }
    var inc = 1
    if (ixs.count >= 2 && base != 3) inc = ixs[1] - ixs[0]
    if (drs.count == 0) return [ms, inc, bdr]
    var min = Nums.min(drs)
    var rd = min - bdr
    if (rd == 0) return [ms, inc, bdr]
    if (rd == 1) return [minSq36x[0..base], 1, bdr]
    var ins = minSq36[rd]
    return [(minSq36[0...rd] + ins + minSq36[rd..-1])[0..base], inc, bdr]
}

var start = System.clock
var n = 2
var k = 1
var base = 2
while (true) {
    if (base == 2 || (n % base) != 0) {
        var nb = BigInt.new(n)
        var sq = nb.square.toBaseString(base)
        if (containsAll.call(sq, base)) {
            var ns = Conv.itoa(n, base)
            var tt = System.clock - start
            Fmt.print("Base $2d:$15s² = $-27s in $8.3fs", base, ns, sq, tt)
            if (base == maxBase) break
            base = base + 1
            var res = minStart.call(base)
            var ms = res[0]
            var inc = res[1]
            var bdr = res[2]
            k = inc
            var nn = BigInt.fromBaseString(ms, base)
            nb = nn.isqrt
            if (nb < n + 1) nb = BigInt.new(n+1)
            if (k != 1) {
                while (true) {
                    nn = nb.square
                    var dr = digitalRoot.call(nn, base)
                    if (dr == bdr) {
                        n = nb.toSmall - k
                        break
                    }
                    nb = nb.inc                
                }
            } else {
                n = nb.toSmall - k
            }
        }
    }
    n = n + k
}

Output:

Base  2:             10² = 100                         in    0.000s
Base  3:             22² = 2101                        in    0.000s
Base  4:             33² = 3201                        in    0.001s
Base  5:            243² = 132304                      in    0.001s
Base  6:            523² = 452013                      in    0.002s
Base  7:           1431² = 2450361                     in    0.003s
Base  8:           3344² = 13675420                    in    0.004s
Base  9:          11642² = 136802574                   in    0.011s
Base 10:          32043² = 1026753849                  in    0.011s
Base 11:         111453² = 1240a536789                 in    0.044s
Base 12:         3966b9² = 124a7b538609                in    0.201s
Base 13:        3828943² = 10254773ca86b9              in    0.426s
Base 14:        3a9db7c² = 10269b8c57d3a4              in    0.501s
Base 15:       1012b857² = 102597bace836d4             in    0.651s
Base 16:       404a9d9b² = 1025648cfea37bd9            in    1.351s
Base 17:      423f82ga9² = 101246a89cgfb357ed          in   10.534s
Base 18:      44b482cad² = 10236b5f8eg4ad9ch7          in   12.008s
Base 19:     1011b55e9a² = 10234dhbg7ci8f6a9e5         in   18.055s
Base 20:     49dgih5d3g² = 1024e7cdi3hb695fja8g        in  696.567s
Base 21:    4c9he5fe27f² = 1023457dg9hi8j6b6kceaf      in  735.738s

XPL0

Base 14 is the largest that can be calculated using double precision floating point (14^13 = 7.9e14; 15^14 = 2.9e16). Runs in about 38 seconds on Pi4.

real Base;                      \Number Base used [2..14]

proc NumOut(N);                 \Display N in the specified Base
real N;
int  Remain;
[Remain:= fix(Mod(N, Base));
N:= Floor(N/Base);
if N # 0. then NumOut(N);
ChOut(0, Remain + (if Remain <= 9 then ^0 else ^A-10));
];

func Pandigital(N);             \Return 'true' if N is pandigital
real N;
int  Used, Remain;
[Used:= 0;
while N # 0. do
    [Remain:= fix(Mod(N, Base));
    N:= Floor(N/Base);
    Used:= Used ! 1<<Remain;
    ];
return Used = 1<<fix(Base) - 1;
];

real N;
[Base:= 2.;
Format(2, 0);
repeat  N:= Floor(Sqrt(Pow(Base, Base-1.)));
        loop    [if Pandigital(N*N) then
                    [RlOut(0, Base);  Text(0, ": ");
                    NumOut(N);  Text(0, "^^2 = ");
                    NumOut(N*N);  CrLf(0);
                    quit;
                    ];
                N:= N + 1.;
                ];
        Base:= Base + 1.;
until   Base > 14.;
]

Output:

 2: 10^2 = 100
 3: 22^2 = 2101
 4: 33^2 = 3201
 5: 243^2 = 132304
 6: 523^2 = 452013
 7: 1431^2 = 2450361
 8: 3344^2 = 13675420
 9: 11642^2 = 136802574
10: 32043^2 = 1026753849
11: 111453^2 = 1240A536789
12: 3966B9^2 = 124A7B538609
13: 3828943^2 = 10254773CA86B9
14: 3A9DB7C^2 = 10269B8C57D3A4

zkl

Translation of: Julia

fcn squareSearch(B){
   basenumerals:=B.pump(String,T("toString",B)); // 13 --> "0123456789abc"
   highest:=("10"+basenumerals[2,*]).toInt(B);   // 13 --> "10" "23456789abc"
   foreach n in ([highest.toFloat().sqrt().toInt() .. highest]){
     ns:=(n*n).toString(B);
     if(""==(basenumerals - ns) ) return(n.toString(B),ns);
  }
  Void
}

println("Base     Root   N");
foreach b in ([2..16])
  { println("%2d %10s  %s".fmt(b,squareSearch(b).xplode())) }

Output:

Base     Root   N
 2         10  100
 3         22  2101
 4         33  3201
 5        243  132304
 6        523  452013
 7       1431  2450361
 8       3344  13675420
 9      11642  136802574
10      32043  1026753849
11     111453  1240a536789
12     3966b9  124a7b538609
13    3828943  10254773ca86b9
14    3a9db7c  10269b8c57d3a4
15   1012b857  102597bace836d4
16   404a9d9b  1025648cfea37bd9