Steady squares

From Rosetta Code
(Redirected from Steady Squares)
Steady squares is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.
Euler Project #284
Task


The 3-digit number 376 in the decimal numbering system is an example of numbers with the special property that its square ends with the same digits: 376*376 = 141376. Let's call a number with this property a steady square. Find steady squares under 10.000

Action!

Translation of: PROMAL
;;; find some steady squares - numbers whose squares end in the number
;;; e.g. 376^2 = 141 376

PROC Main()
  CARD p     ; the number to square, with the final digit replaced by 0
  CARD n     ; the number to square
  CARD d10   ; 10^the number of digits in p, n
  CARD s     ; the square of n modulo d10
  CARD f     ; loop counter to choose 1, 5 or 6 as the final digit of q
  CARD front ; the first 2 digits of n
  CARD back  ; the last two digits of n

  d10 = 10
  FOR p = 0 TO 10000 STEP 10 DO
    IF p = d10 THEN
       d10 ==* 10
    FI
    FOR f = 1 TO 3 DO
      IF f = 1 THEN
        n = p + 1
      ELSEIF f = 2 THEN
        n = p + 5
      ELSE
        n = p + 6
      FI
      IF n <= 255 THEN
        s = ( n * n )
      ELSE
        front = n  /  100
        back  = n MOD 100
        s = ( back * back ) + ( 200 * ( ( front * back ) MOD 100 ) )
      FI
      s ==MOD d10
      IF s = n THEN
        Put(' ) PrintC( n )
      FI
    OD
  OD
RETURN
Output:
 1 5 6 25 76 376 625 9376

ALGOL 60

Works with: GNU Marst version Any - tested with release 2.7
begin comment find steady squares - numbers whose square ends in the number
              e.g.: 376^2 = 141 376 ;

    integer powerOfTen, p;
    powerOfTen := 10;

    comment note the final digit must be 1, 5 or 6 ;
    for p := 0 step 10 until 10 000 do begin
        integer d;
        if p = powerOfTen then begin
            comment number of digits has increased ;
            powerOfTen := powerOfTen * 10
        end;
        for d := 1, 5, 6 do begin
            integer m, n, n2;
            n  := p + d;
            n2 := n * n;
            m  := n2 - ( ( n2 % powerOfTen ) * powerOfTen ) ;
            if m = n then outinteger( 1, n )
        end
    end
end
Output:
1 5 6 25 76 376 625 9376

ALGOL 68

Using the observation that the final digit must be 1, 5 or 6 (See Talk page).

BEGIN # find some steady squares - numbers whose squares end in the number    #
      # e.g. 376^2 = 141 376                                                  #
    INT max number    = 10 000; # maximum number we will consider             #
    INT power of ten := 10;
    []INT last digit = ( 1, 5, 6 );
    FOR n FROM 0 BY 10 TO max number DO
        IF n = power of ten THEN
            # the number of digits just increased                             #
            power of ten *:= 10
        FI;
        FOR d FROM LWB last digit TO UPB last digit DO
            INT nd = n + last digit[ d ];
            INT n2 = nd * nd;
            IF n2 MOD power of ten = nd THEN
                # have a steady square                                        #
                print( ( whole( nd, -5 ), "^2 = ", whole( n2, 0 ), newline ) )
            FI
        OD
    OD
END
Output:
    1^2 = 1
    5^2 = 25
    6^2 = 36
   25^2 = 625
   76^2 = 5776
  376^2 = 141376
  625^2 = 390625
 9376^2 = 87909376

ALGOL W

begin % find steady squares - numbers whose square ends in the number        %
      %      e.g.: 376^2 = 141 376                                           %

    % checks wheher n^2 mod p10 = n, i.e. n is a steady square and displays  %
    %        a message if it is                                              %
    procedure possibleSteadySuare ( integer value n, p10 ) ;
        if ( n * n ) rem p10 = n then write( i_w := 4, s_w := 0, n, "^2: ", i_w := 1, n * n );

    integer powerOfTen;
    powerOfTen := 10;

    % note the final digit must be 1, 5 or 6                                 %
    for p := 0 step 10 until 10000 do begin;
        if p = powerOfTen then begin
            % number of digits have increased                                %
            powerOfTen := powerOfTen * 10
        end if_p_eq_powerOfTen ;
        possibleSteadySuare( p + 1, powerOfTen );
        possibleSteadySuare( p + 5, powerOfTen );
        possibleSteadySuare( p + 6, powerOfTen )
    end
end.
Output:
   1^2: 1
   5^2: 25
   6^2: 36
  25^2: 625
  76^2: 5776
 376^2: 141376
 625^2: 390625
9376^2: 87909376

Arturo

Translation of: C
steady?: function [n][
    mask: 1
    d: n
    while -> d <> 0 [
        mask: mask * 10
        d: d / 10
    ]
    n = (n * n) % mask
]

loop 0..1000 'n [
    loop [1 5 6] 'd [
        r: d + 10 * n     ; only check numbers that end with 1, 5, 6
        if steady? r -> print ~"|r|^2 = |r*r|"
    ]
]
Output:
1^2 = 1
5^2 = 25
6^2 = 36
25^2 = 625
76^2 = 5776
376^2 = 141376
625^2 = 390625
9376^2 = 87909376

AWK

# syntax: GAWK -f STEADY_SQUARES.AWK
BEGIN {
    start = 1
    stop = 999999
    for (i=start; i<=stop; i++) {
      n = i ^ 2
      if (n ~ (i "$")) {
        printf("%6d^2 = %12d\n",i,n)
        count++
      }
    }
    printf("\nSteady squares %d-%d: %d\n",start,stop,count)
    exit(0)
}
Output:
     1^2 =            1
     5^2 =           25
     6^2 =           36
    25^2 =          625
    76^2 =         5776
   376^2 =       141376
   625^2 =       390625
  9376^2 =     87909376
 90625^2 =   8212890625
109376^2 =  11963109376
890625^2 = 793212890625

Steady squares 1-999999: 11

BASIC

Applesoft BASIC

Translation of: GW-BASIC
100 HOME
110 FOR n = 1 TO 10000
120  m$ = STR$(n)
130  n2$ = STR$(n*n)
140  IF RIGHT$(n2$,LEN(m$)) = m$ THEN HTAB(5-LEN(m$)): PRINT m$;"^2 = ";N2$
150 NEXT n
160 END

ASIC

Compile with the Extended math option.

Translation of: C
REM Steady squares
FOR I = 1 TO 9999
  N = I
  GOSUB CheckIfSteady:
  IF Steady <> 0 THEN
    PRINT I;
    PRINT " ^ 2 = ";
    II& = I * I
    PRINT II&
  ENDIF
NEXT I
END

CheckIfSteady:
REM Result: Steady = 1 if N * N is steady; Steady = 0 otherwise.
Mask = 1
D = N
WHILE D <> 0
  Mask = Mask * 10
  D = D / 10
WEND
NNModMask& = N * N
NNModMask& = NNModMask& MOD Mask
IF NNModMask& = N THEN
  Steady = 1
ELSE
  Steady = 0
ENDIF
RETURN
Output:
     1 ^ 2 =            1
     5 ^ 2 =           25
     6 ^ 2 =           36
    25 ^ 2 =          625
    76 ^ 2 =         5776
   376 ^ 2 =       141376
   625 ^ 2 =       390625
  9376 ^ 2 =     87909376

BASIC256

for i = 1 to 9999
	if isSteady(i) then
		print rjust(i,4); "^2 = "; rjust(i * i,8)
	end if
next i
end

function isSteady(n)
	mask = 1
	d = n
	while d <> 0
		mask *= 10
		d = int(d / 10)
	end while
	return ((n * n) mod mask = n)
end function
Output:
Same as FreeBASIC entry.

Chipmunk Basic

Translation of: GW-BASIC
10 rem Steady squares
20 for n = 1 to 10000
30 m$ = str$(n)
40 n2$ = str$(n*n)
50 if right$(n2$,len(m$)) = m$ then print m$,n2$
60 next n
70 end
Output:
1       1
5       25
6       36
25      625
76      5776
376     141376
625     390625
9376    87909376

FreeBASIC

function numdig( byval n as uinteger ) as uinteger
    'number of decimal digits in n
    dim as uinteger d=0
    while n
        d+=1
        n\=10
    wend
    return d
end function

function is_steady_square( n as const uinteger ) as boolean
    dim as integer n2 = n^2
    if n2 mod 10^numdig(n) = n then return true else return false
end function

for i as uinteger = 1 to 10000
    if is_steady_square(i) then print using "####^2 = ########";i;i^2
next i
Output:
   1^2 =        1
   5^2 =       25
   6^2 =       36
  25^2 =      625
  76^2 =     5776
 376^2 =   141376
 625^2 =   390625
9376^2 = 87909376

Gambas

Translation of: FreeBASIC
Public Sub Main() 
  
  For i As Integer = 1 To 10000 
    If is_steady_square(i) Then Print Format$(i, "####"); "^2 = "; Format$(i ^ 2, "########")
  Next
  
End 

Function numdig(n As Integer) As Integer 

  Dim d As Integer = 0 
  While n 
    d += 1 
    n \= 10 
  Wend 
  Return d 

End Function 

Function is_steady_square(n As Integer) As Boolean 

  Dim n2 As Integer = n ^ 2 
  Return IIf(n2 Mod CInt(10 ^ numdig(n)) = n, True, False) 

End Function
Output:
Same as FreeBASIC entry.

GW-BASIC

Works with: BASICA
10 FOR N = 1 TO 10000
20 M$ = STR$(N)
30 M2#=N*N
40 M$ = RIGHT$(M$,LEN(M$)-1)
50 N2$ = STR$(M2#)
60 A = LEN(M$)
70 IF RIGHT$(N2$,A)= M$ THEN PRINT M$,N2$
80 NEXT N
Output:
1              1
5              25
6              36
25             625
76             5776
376            141376
625            390625
9376           87909376

Liberty BASIC

Translation of: C
Works with: Just BASIC version any
rem Steady squares
for i = 1 to 9999
  if isSteady(i) then
    print using("####",i); " ^ 2 = "; using("########", i * i)                  
  end if
next i
end

function isSteady(n)
  mask = 1
  d = n
  while d <> 0
    mask = mask * 10
    d = int(d / 10)
  wend
  isSteady = ((n * n) mod mask = n)
end function
Output:
   1 ^ 2 =        1
   5 ^ 2 =       25
   6 ^ 2 =       36
  25 ^ 2 =      625
  76 ^ 2 =     5776
 376 ^ 2 =   141376
 625 ^ 2 =   390625
9376 ^ 2 = 87909376

MSX Basic

Translation of: GW-BASIC
10 CLS
20 FOR N = 1 TO 10000
30 M$ = STR$(N)
40 M2# = N*N
50 M$ = RIGHT$(M$,LEN(M$)-1)
60 N2$ = STR$(M2#)
70 A = LEN(M$)
80 IF RIGHT$(N2$,A)= M$ THEN LOCATE 5-LEN(M$): PRINT M$;"^2 =";N2$
90 NEXT N
100 END

QBasic

Works with: QBasic version 1.1
Works with: QuickBasic version 4.5
FUNCTION isSteady! (n!)
  mask = 1
  d = n
  WHILE d <> 0
    mask = mask * 10
    d = INT(d / 10)
  WEND
  isSteady = ((n * n) MOD mask = n)
END FUNCTION

FOR i = 1 TO 9999
  IF isSteady(i) THEN
    PRINT USING ("####^2 = ########"); i; i * i
  END IF
NEXT i
Output:
Same as FreeBASIC entry.

Run BASIC

Works with: Just BASIC
Works with: Liberty BASIC
for i = 1 to 9999
  if isSteady(i) then
    print using("####",i); "^2 = "; using("########", i * i)                  
  end if
next i
end

function isSteady(n)
  mask = 1
  d = n
  while d <> 0
    mask = mask * 10
    d = int(d / 10)
  wend
  isSteady = ((n * n) mod mask = n)
end function
Output:
Same as FreeBASIC entry.

Tiny BASIC

Works with: TinyBasic

Although TinyBASIC is limited to signed 16-bit integers, we can still handle the basic task by noting that we can split a four digit number into the first pair of digits and the seoncd pair. If we call these F and B say, then the number squared module 10000 is B*B + 200 * ( F*B MOD 100 ). Additionally, (as other samples have noted), we only need to consider numbers ending in 1, 5 or 6.

REM  P = THE NUMBER TO SQUARE, WITH THE FINAL DIGIT REPLACED BY 0
REM  X = THE FINAL DIGIT OF THE NUMBER, 1, 5 OR 6
REM  N = THE NUMBER TO BE SQUARED
REM  D = 10^THE NUMBER OF DIGITS IN N
REM  S = THE SQUARE OF N, MODULO D
REM  F = THE FRONT (FIRST TWO DIGITS) OF N
REM  B = THE BACK (LAST TWO DIGITS) OF N

   10 LET P=0
   20 LET D=10
   30 LET X=1
   40 IF D=P THEN LET D=D*10
   50 LET N=P+X
   60 LET F=N/100
   70 LET B=N-F*100
   80 LET S=B*B+200*(F*B-F*B/100*100)
   90 IF S-S/D*D=N THEN PRINT N
  100 LET X=X+4
  110 IF X=10 LET P=P+10
  120 IF X=10 LET X=1
  130 IF X=9 LET X=6
  140 IF P<9990 THEN GOTO 40
  150 END
Output:
      1
      5
      6
     25
     76
    376
    625
   9376

True BASIC

FUNCTION issteady(n)
    LET mask = 1
    LET d = n
    DO WHILE d <> 0
       LET mask = mask*10
       LET d = INT(d/10)
    LOOP
    LET res = MOD((n * n), mask)
    IF res = n THEN
       LET issteady = res
    ELSE
       LET issteady = 0
    END IF
END FUNCTION

FOR i = 1 TO 9999
    IF issteady(i) <> 0 THEN
       PRINT USING("####"):i;
       PRINT "^2 = ";
       PRINT USING("########"): i*i
    END IF
NEXT i
END
Output:
Same as FreeBASIC entry.

Yabasic

// Rosetta Code problem: http://rosettacode.org/wiki/Steady_squares
// by Galileo, 04/2022

for i = 1 to 10000
    r$ = str$(i^2, "%9.f")
    if i = val(right$(r$, len(str$(i)))) print i, "\t=", r$
next
Output:
1       =        1
5       =       25
6       =       36
25      =      625
76      =     5776
376     =   141376
625     =   390625
9376    = 87909376
---Program done, press RETURN---

C

#include <stdio.h>
#include <stdbool.h>
 
bool steady(int n)
{
    int mask = 1;
    for (int d = n; d != 0; d /= 10) 
        mask *= 10;
    return (n * n) % mask == n;
}
 
int main()
{
    for (int i = 1; i < 10000; i++)
        if (steady(i))
            printf("%4d^2 = %8d\n", i, i * i);
    return 0;
}
Output:
   1^2 =        1
   5^2 =       25
   6^2 =       36
  25^2 =      625
  76^2 =     5776
 376^2 =   141376
 625^2 =   390625
9376^2 = 87909376

C++

Translation of: C
#include <iostream>
using namespace std;

bool steady(int n) {
    int mask = 1;
    for (int d = n; d != 0; d /= 10) 
        mask *= 10;
    return (n * n) % mask == n;
}
 
int main() {
    for (int i = 1; i < 10000; i++)
        if (steady(i)) printf("%4d^2 = %8d\n", i, i * i);
}
Output:
Same as C entry.

CLU

n_digits = proc (n: int) returns (int)
    i: int := 0
    while n>0 do
        i := i+1
        n := n/10
    end
    return(i)
end n_digits

steady = proc (n: int) returns (bool)
    sq: int := n ** 2
    return (sq // 10**n_digits(n) = n)
end steady

start_up = proc ()
    po: stream := stream$primary_output()
    for i: int in int$from_to(1, 10000) do
        if ~steady(i) then continue end
        stream$putright(po, int$unparse(i), 4)
        stream$puts(po, "^2 = ")
        stream$putright(po, int$unparse(i**2), 8)
        stream$putl(po, "")
    end
end start_up
Output:
   1^2 =        1
   5^2 =       25
   6^2 =       36
  25^2 =      625
  76^2 =     5776
 376^2 =   141376
 625^2 =   390625
9376^2 = 87909376

Dart

Translation of: C
bool steady(int n) {
  int mask = 1;
  for (int d = n; d != 0; d ~/= 10) mask *= 10;
  return (n * n) % mask == n;
}

void main() {
  for (int i = 1; i < 10000; i++) if (steady(i)) print('$i^2 = ${i * i}');
}
Output:
1^2 = 1
5^2 = 25
6^2 = 36
25^2 = 625
76^2 = 5776
376^2 = 141376
625^2 = 390625
9376^2 = 87909376

Delphi

Works with: Delphi version 6.0


{This routine is normally part of a separate library, but it is included here for clarity}

procedure GetDigits(N: integer; var IA: TIntegerDynArray);
{Get an array of the integers in a number}
{Numbers returned from least to most significant}
var T,I,DC: integer;
begin
DC:=Trunc(Log10(N))+1;
SetLength(IA,DC);
for I:=0 to DC-1 do
	begin
	T:=N mod 10;
	N:=N div 10;
	IA[I]:=T;
	end;
end;



function IsSteadySquare(N: integer): boolean;
{compare digits of N and N^2 and see if they matchs}
var Dig1,Dig2: TIntegerDynArray;
var I: integer;
begin
Result:=False;
{Get digits}
GetDigits(N,Dig1);
GetDigits(N*N,Dig2);
{Compare digits}
for I:=0 to High(Dig1) do
 if Dig1[I]<>Dig2[I] then exit;
Result:=True
end;


procedure ShowSteadySquares(Memo: TMemo);
var I: integer;
begin
for I:=1 to 10000-1 do
 if IsSteadySquare(I) then
 Memo.Lines.Add(Format('%6.0n^2 = %10.0n',[I+0.0,I*I+0.0]));
end;
Output:
     1^2 =          1
     5^2 =         25
     6^2 =         36
    25^2 =        625
    76^2 =      5,776
   376^2 =    141,376
   625^2 =    390,625
 9,376^2 = 87,909,376
Elapsed Time: 11.168 ms.


Draco

proc nonrec steady(ulong n) bool:
    ulong mask;
    mask := 1;
    while mask <= n do mask := mask * 10 od;
    n*n % mask = n
corp

proc nonrec main() void:
    word i;
    for i from 1 upto 10000 do
        if steady(i) then
            writeln(i:4, "^2 = ", make(i,ulong)*i:8)
        fi
    od
corp
Output:
   1^2 =        1
   5^2 =       25
   6^2 =       36
  25^2 =      625
  76^2 =     5776
 376^2 =   141376
 625^2 =   390625
9376^2 = 87909376

Euler

The original Euler implementations didn't have loops built-in, however they can be constructed using labels and gotos. As procedures can take literal procedures as parameters, procedures to provide a loops can be defined. This is used here to define a "while" loop procedure.
Note that text between ` and ' is a procedure literal. The text "new while; while <- `...'" defines a new variable and assigned the while-loop procedure to it. When called, the text of the condition and loop body must be enclosed in ` and ' to make them procedures - otherwise they would not be evaluated each time as requried.
All Euler variables are declared using "new var" (only one variable per "new"), labels must be declared with "label" and procedure parametrers are declared with "formal" (again, only one label or parameter per "label" or "formal" declaration).
Everything is Euler is an expression (apart from new/label/formal) and returns a value (although the value of a "goto" can't be used), so the "else" part of an "if" is not optional, hence the "else 0"s appearing in the code below.

begin
  new maxNumber; new powerOfTen; new lastDigit; new n;
  new while;

  while <- ` formal condition; formal loopBody;
             begin
              label again;
again:        if condition then begin loopBody; goto again end else 0
             end
           '
         ;

  maxNumber  <- 10 000;
  powerOfTen <- 10;
  lastDigit  <- ( 1, 5, 6 );
  n <- -10;
  while( ` [ n <- n + 10 ] <= maxNumber '
       , ` begin
             new d;
             if n = powerOfTen then powerOfTen <- powerOfTen * 10
                               else 0;
             d <- 0;
             while( ` [ d <- d + 1 ] <= length lastDigit '
                  , ` begin
                        new nd; new n2;
                        nd <- n + lastDigit[ d ];
                        n2 <- nd * nd;
                        if n2 mod powerOfTen = nd then out nd else 0
                      end
                    '
                  )
           end
         '
       )
end
$
Output:
    NUMBER                   1
    NUMBER                   5
    NUMBER                   6
    NUMBER                  25
    NUMBER                  76
    NUMBER                 376
    NUMBER                 625
    NUMBER                9376

F#

The Function

Implements No Search Required. large values may be produced using only integers.

// Steady Squares. Nigel Galloway: December 21st., 2021
let fN g=let n=List.fold2(fun z n g->z+n*g) 0L g (g|>List.rev) in (n,g)
let five,six=(5L,[|0L..9L|]),(6L,[|0L;9L;8L;7L;6L;5L;4L;3L;2L;1L|])
let stdySq(g0,N)=let rec fG n (g,l)=seq{let i=Array.item(int((n+g)%10L)) N in yield i; yield! (fG((n+g+2L*g0*i)/10L)(fN(i::l)))}
                 seq{yield g0; yield! fG(g0*g0/10L)(0L,[])}

Some Examples

stdySq six|>Seq.take 80|>Seq.rev|>Seq.iter(printf "%d");printfn ""
stdySq five|>Seq.take 80|>Seq.rev|>Seq.iter(printf "%d");printfn ""
Output:
61490109937833490419136188999442576576769103890995893380022607743740081787109376
38509890062166509580863811000557423423230896109004106619977392256259918212890625
Confirming Phix's example for 999 digits (in 11 thousands of sec).
stdySq six|>Seq.skip 920|>Seq.take 79|>Seq.rev|>Seq.iter(printf "%d");printfn "..."
Output:
7218745998663099139651109156359761242340631780203738180821664795072958006751247...
Real: 00:00:00.011
9999 digits
stdySq six|>Seq.skip 9920|>Seq.take 79|>Seq.rev|>Seq.iter(printf "%d");printfn "...";;
Output:
8908826164991254342660560818535016604238201034937718562215376152130910068662033...
Real: 00:00:00.330
If you have 57secs to spare then do 99999 digits, I leave it to the faithless to prove that this a Steady Square.
stdySq six|>Seq.skip 99920|>Seq.take 79|>Seq.rev|>Seq.iter(printf "%d");printfn "...";;
Output:
2755643458676224038154570844433833690960332159243668007360724907611570195135435...
Real: 00:00:57.520

Factor

Only checking numbers that end with 1, 5, and 6. See Talk:Steady_Squares for more details.

Works with: Factor version 0.99 2021-06-02
USING: formatting kernel math math.functions
math.functions.integer-logs prettyprint sequences
tools.memory.private ;

: steady? ( n -- ? )
    [ sq ] [ integer-log10 1 + 10^ mod ] [ = ] tri ;

1000 <iota> { 1 5 6 } [
    [ 10 * ] dip + dup steady?
    [ dup sq commas "%4d^2 = %s\n" printf ] [ drop ] if
] cartesian-each
Output:
   1^2 = 1
   5^2 = 25
   6^2 = 36
  25^2 = 625
  76^2 = 5,776
 376^2 = 141,376
 625^2 = 390,625
9376^2 = 87,909,376

Fe

(= steadySquares
   (fn (maxNumber)                  ;                    max number to consider
       (let powerOfTen 10)          ;             10^(the number of digits in n
       (let lastDigit  (list 1 5 6));   a steady square must end with 1, 5 or 6
       (let lastResult (cons 0 nil)); latest steady square start with a dummy 0
       (let result     lastResult)  ;  list of steady squares - dummy leading 0
       (let n -10)                  ;                multiple of 10 to consider
       (while (do (= n (+ n 10))    ;       find steady squares up to maxNumber
                  (<= n maxNumber)
              )
           (if (is n powerOfTen)
               (= powerOfTen (* powerOfTen 10)); number of digits has increased
           )
           (let d lastDigit)
           (while (not (atom d))              ; try n + each possible lastDigit
                  (let nd (+ n (car d)))
                  (let n2 (* nd nd))
                  ; Fe doesn't have a mod operator, integer division or a way
                  ; to truncate a float to an integer, so we calculate
                  ; n2 mod powerOfTen using repeated subtraction - but see
                  ; FizzBuzz for an example of doing it with a C function
                  (let n2%p10 n2)
                  (let mDivisor (* powerOfTen powerOfTen))
                  (while (<= powerOfTen mDivisor)
                         (while (<= mDivisor n2%p10)
                                (= n2%p10 (- n2%p10 mDivisor))
                         )
                         (= mDivisor (/ mDivisor 10))
                  )
                  (if (is nd n2%p10)
                      (do (setcdr lastResult (cons nd nil))
                          (= lastResult (cdr lastResult))
                      )
                  )
                  (= d (cdr d))
           )
       )
       (cdr result)     ; return the list of steady squares without the dummy 0
   )
)
(print (steadySquares 10000))
Output:
(1 5 6 25 76 376 625 9376)

Fermat

Func Isstead( n ) = 
    m:=n;
    d:=1;
    while m>0 do
        d:=d*10;
        m:=m\10;
    od;
    if n^2|d=n then Return(1) else Return(0) fi.;

for i = 1 to 9999 do
    if Isstead(i) then !!(i,'^2 = ',i^2) fi;
od;
Output:
 1^2 =  1
 5^2 =  25
 6^2 =  36
 25^2 =  625
 76^2 =  5776
 376^2 =  141376
 625^2 =  390625
 9376^2 =  87909376

Go

Translation of: Wren
Library: Go-rcu
package main

import (
    "fmt"
    "rcu"
    "strconv"
    "strings"
)

func contains(list []int, s int) bool {
    for _, e := range list {
        if e == s {
            return true
        }
    }
    return false
}

func main() {
    fmt.Println("Steady squares under 10,000:")
    finalDigits := []int{1, 5, 6}
    for i := 1; i < 10000; i++ {
        if !contains(finalDigits, i%10) {
            continue
        }
        sq := i * i
        sqs := strconv.Itoa(sq)
        is := strconv.Itoa(i)
        if strings.HasSuffix(sqs, is) {
            fmt.Printf("%5s -> %10s\n", rcu.Commatize(i), rcu.Commatize(sq))
        }
    }
}
Output:
Steady squares under 10,000:
    1 ->          1
    5 ->         25
    6 ->         36
   25 ->        625
   76 ->      5,776
  376 ->    141,376
  625 ->    390,625
9,376 -> 87,909,376

Haskell

import Control.Monad (join)
import Data.List (isSuffixOf)

--------------- NUMBERS WITH STEADY SQUARES --------------

p :: Int -> Bool
p = isSuffixOf . show <*> (show . join (*))


--------------------------- TEST -------------------------
main :: IO ()
main =
  print $
    takeWhile (< 10000) $ filter p [0 ..]
Output:
[0,1,5,6,25,76,376,625,9376]


or retaining the string pair when the test succeeds:

import Control.Monad (join)
import Data.Bifunctor (bimap)
import Data.List (isSuffixOf)

---------------------- STEADY NUMBERS --------------------

steadyPair :: Int -> [(String, String)]
steadyPair n =
  [ (s, s2)
    | let (s, s2) = join bimap show (n, n * n),
      s `isSuffixOf` s2
  ]

--------------------------- TEST -------------------------
main :: IO ()
main =
  ( \xs ->
      let (w, w2) = join bimap length (last xs)
       in mapM_
            ( putStrLn . uncurry ((<>) . (<> " -> "))
                . bimap
                  (justifyRight w ' ')
                  (justifyRight w2 ' ')
            )
            xs
  )
    $ [0 .. 10000] >>= steadyPair

------------------------- GENERIC ------------------------

justifyRight :: Int -> Char -> String -> String
justifyRight n c = (drop . length) <*> (replicate n c <>)
Output:
   0 ->        0
   1 ->        1
   5 ->       25
   6 ->       36
  25 ->      625
  76 ->     5776
 376 ->   141376
 625 ->   390625
9376 -> 87909376


or obtaining the squares by addition, rather than multiplication:

import Control.Monad (join)
import Data.Bifunctor (bimap)
import Data.List (isSuffixOf)

--------------- NUMBERS WITH STEADY SQUARES --------------

steadyPair :: Int -> Int -> [(Int, (String, String))]
steadyPair a b =
  [ (a, ab)
    | let ab = join bimap show (a, b),
      uncurry isSuffixOf ab
  ]

--------------------------- TEST -------------------------
main :: IO ()
main =
  putStrLn $
    unlines
      ( uncurry ((<>) . (<> " -> ")) . snd
          <$> takeWhile
            ((10000 >) . fst)
            ( concat $
                zipWith
                  steadyPair
                  [0 ..]
                  (scanl (+) 0 [1, 3 ..])
            )
      )
Output:
0 -> 0
1 -> 1
5 -> 25
6 -> 36
25 -> 625
76 -> 5776
376 -> 141376
625 -> 390625
9376 -> 87909376

J

Implementation:
issteady=: {{ Y-:N{.":*:y[N=.-#Y=.":y }}"0
issteady=: (": -: -@#@": {. ":@*:)"0 NB. tacit alternative
Task example:
   I.issteady i.1e4
0 1 5 6 25 76 376 625 9376
Note that for larger values we would want to take advantage of the suffix characteristics of these numbers (a multi-digit steady square would have a suffix which is a steady square).

For example:

bigsteady=: {{
 Y=. 1+s=.0x
 whilst. Y < y do.
  s=. (#~ issteady) ,(Y*i.10)+/s
  Y=. Y*10
 end.
 s #~ y>s
}}

Example use:

   $bigsteady 1e20
37
   $bigsteady 1e30
54
   q:54
2 3 3 3
   9 6$bigsteady 1e30
                          0                            1                            5                             6                             25                             76
                        376                          625                         9376                         90625                         109376                         890625
                    2890625                      7109376                     12890625                      87109376                      212890625                      787109376
                 1787109376                   8212890625                  18212890625                   81787109376                   918212890625                  9918212890625
             40081787109376               59918212890625              259918212890625               740081787109376               3740081787109376               6259918212890625
          43740081787109376            56259918212890625           256259918212890625            743740081787109376            2256259918212890625            7743740081787109376
       92256259918212890625        392256259918212890625        607743740081787109376        2607743740081787109376         7392256259918212890625        22607743740081787109376
    77392256259918212890625     977392256259918212890625    9977392256259918212890625    19977392256259918212890625     80022607743740081787109376    380022607743740081787109376
619977392256259918212890625 3380022607743740081787109376 6619977392256259918212890625 93380022607743740081787109376 106619977392256259918212890625 893380022607743740081787109376

JavaScript

Procedural

Translation of: TypeScript
Translation of: C
// Steady squares

function steady(n) {
    // Result: true if n * n is steady; false otherwise.
    var mask = 1;
    for (var d = n; d != 0; d = Math.floor(d / 10))
        mask *= 10;
    return (n * n) % mask == n;
}

for (var i = 1; i < 10000; i++)
    if (steady(i))
        console.log(i.toString().padStart(4, ' ') + "^2 = " +
            (i * i).toString().padStart(8, ' '));
Output:
   1^2 =        1
   5^2 =       25
   6^2 =       36
  25^2 =      625
  76^2 =     5776
 376^2 =   141376
 625^2 =   390625
9376^2 = 87909376

Functional

(() => {
    "use strict";

    // ----------------- STEADY SQUARES ------------------

    // isSteady :: Int -> Bool
    const isSteady = n =>
        Boolean(steadyPair(n).length);


    // steadyPair :: Int -> [(String, String)]
    const steadyPair = n => {
        // An empty list if n is not steady, otherwise a
        // list containing a tuple of (n, n^2) strings.
        const
            s = `${n}`,
            s2 = `${n ** 2}`;

        return s2.endsWith(s) ? [
            [s, s2]
        ] : [];
    };

    // ---------------------- TESTS ----------------------
    const main = () => {
        const
            range = enumFromTo(0)(1E4),
            pairs = range.flatMap(steadyPair),
            [w, w2] = pairs[pairs.length - 1]
            .map(x => x.length);

        return [
                range.filter(isSteady).join(", "),

                pairs.map(([n, n2]) => {
                    const
                        steady = n.padStart(w, " "),
                        square = n2.padStart(w2, " ");

                    return `${steady} -> ${square}`;
                })
                .join("\n")
            ]
            .join("\n\n");
    };

    // --------------------- GENERIC ---------------------

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


    // MAIN ---
    return main();
})();
Output:
0, 1, 5, 6, 25, 76, 376, 625, 9376

   0 ->        0
   1 ->        1
   5 ->       25
   6 ->       36
  25 ->      625
  76 ->     5776
 376 ->   141376
 625 ->   390625
9376 -> 87909376

jq

Works with: jq

Works with gojq, the Go implementation of jq

# Input: an upper bound, or null for infinite
def steady_squares:
  range(0; . // infinite)
  | tostring as $i
  | select( .*. | tostring | endswith($i));

10000
| steady_squares
Output:
0
1
5
6
25
76
376
625
9376

Julia

issteadysquare(n) = (s = "$n"; s == "$(n * n)"[end+1-length(s):end])

println(filter(issteadysquare, 1:10000)) # [1, 5, 6, 25, 76, 376, 625, 9376]


Lua

Translation of: ALGOL W

Uses the fact the final digit can only be 1, 5 or 6 (see the talk page).

do --[[ find steady squares - numbers whose square ends in the number
         e.g.: 376^2 = 141 376
   --]]

    -- checks wheher n^2 mod p10 = n, i.e. n is a steady square and displays
    --        a message if it is
    local function possibleSteadySuare ( n, p10 )
        if ( n * n ) % p10 == n then
            io.write( string.format( "%4d", n ), "^2: ", n * n, "\n" )
        end
    end

    local powerOfTen = 10

    -- note the final digit must be 1, 5 or 6
    for p = 0,10000,10 do
        if p == powerOfTen then
            -- number of digits has increased
            powerOfTen = powerOfTen * 10
        end
        possibleSteadySuare( p + 1, powerOfTen )
        possibleSteadySuare( p + 5, powerOfTen )
        possibleSteadySuare( p + 6, powerOfTen )
    end
end
Output:
   1^2: 1
   5^2: 25
   6^2: 36
  25^2: 625
  76^2: 5776
 376^2: 141376
 625^2: 390625
9376^2: 87909376

MAD

            NORMAL MODE IS INTEGER
            VECTOR VALUES FMT = $I4,7H **2 = ,I8*$
            THROUGH LOOP, FOR I=1, 1, I.G.10000
            THROUGH POW, FOR MASK=1, 0, MASK.G.I
POW         MASK = MASK*10
            SQ = I*I
            WHENEVER SQ-SQ/MASK*MASK.E.I
                PRINT FORMAT FMT, I, SQ
            END OF CONDITIONAL
LOOP        CONTINUE
            END OF PROGRAM
Output:
   1**2 =        1
   5**2 =       25
   6**2 =       36
  25**2 =      625
  76**2 =     5776
 376**2 =   141376
 625**2 =   390625
9376**2 = 87909376

Miranda

main :: [sys_message]
main = [Stdout (lay (map showsteady (takewhile (< 10000) steadies)))]
       where showsteady n = shownum n ++ "^2 = " ++ shownum (n^2)

steadies :: [num]
steadies = filter steady [1..]

steady :: num->bool
steady n = n = n^2 mod 10^numdigits n

numdigits :: num->num
numdigits n = 1,                        if n<10
            = 1 + numdigits (n div 10), otherwise
Output:
1^2 = 1
5^2 = 25
6^2 = 36
25^2 = 625
76^2 = 5776
376^2 = 141376
625^2 = 390625
9376^2 = 87909376

Nim

import std/[algorithm, strutils]

var ends = @["1", "5", "6"]
var steady = @[1, 5, 6]
while ends.len != 0:
  var newEnds: seq[string]
  for e in ends:
    for d in '1'..'9':
      let s = d & e
      let n = parseInt(s)
      if n >= 10_000: break
      if ($(n * n)).endsWith(s):
        steady.add n
        newEnds.add s
  ends = newEnds

echo "Steady squares under 10_000: "
for n in sorted(steady):
  echo n, "² = ", n * n
Output:
Steady squares under 10_000: 
1² = 1
5² = 25
6² = 36
25² = 625
76² = 5776
376² = 141376
625² = 390625
9376² = 87909376

Perl

#!/usr/bin/perl

use strict; # https://rosettacode.org/wiki/Steady_Squares
use warnings;

($_ ** 2) =~ /$_$/ and printf "%5d  %d\n", $_, $_ ** 2 for 1 .. 10000;
Output:
    1  1
    5  25
    6  36
   25  625
   76  5776
  376  141376
  625  390625
 9376  87909376

Phix

A number n ending in 2,3,4,7,8, or 9 will have a square ending in 4,9,6,9,4 or 1 respectively.
Further a number ending in k 0s will have a square ending in 2*k 0s, and hence always fail, so all possible candidates must end in 1, 5, or 6.
Further, the square of any k-digit number n will end in the same k-1 digits as the square of the number formed from the last k-1 digits of n,
in other words every successful 3-digit n must end with one of the previously successful answers (maybe zero padded), and so on for 4 digits, etc.
I stopped after 8 digits to avoid the need to fire up gmp. Finishes near-instantly, of course.

with javascript_semantics
sequence success = {1,5,6}  -- (as above)
atom p10 = 10
for digits=2 to 8 do
    for d=1 to 9 do
        for i=1 to length(success) do
            atom cand = d*p10+success[i]
            if remainder(cand*cand,p10*10)=cand then
                success &= cand
            end if
        end for
    end for
    p10 *= 10
end for
printf(1,"%d such numbers < 100,000,000 found:\n",length(success))
for i=1 to length(success) do
    atom si = success[i]
    printf(1,"%,11d^2 = %,21d\n",{si,si*si})
end for
Output:
15 such numbers < 100,000,000 found:
          1^2 =                     1
          5^2 =                    25
          6^2 =                    36
         25^2 =                   625
         76^2 =                 5,776
        376^2 =               141,376
        625^2 =               390,625
      9,376^2 =            87,909,376
     90,625^2 =         8,212,890,625
    109,376^2 =        11,963,109,376
    890,625^2 =       793,212,890,625
  2,890,625^2 =     8,355,712,890,625
  7,109,376^2 =    50,543,227,109,376
 12,890,625^2 =   166,168,212,890,625
 87,109,376^2 = 7,588,043,387,109,376

mpz (super fast to 1000 digits)

Obsessed with the idea the series could in fact be finite, I wheeled out gmp anyway... As per the talk page, it turns out that all steady squares (apart from 1) are in fact on a 5-chain and a 6-chain, which carry on forever. The following easily finishes in less than a second.

with javascript_semantics
include mpfr.e
constant limit = 1000
sequence success = {"1","5","6"}    -- (as above)
sequence squared = {"1","25","36"}  -- (kiss)
integer count = 3
mpz ch5 = mpz_init(5),  -- the 5-chain
    ch6 = mpz_init(6),  -- the 6-chain
    p10 = mpz_init(10), 
    {d10,sqr,r10,t10,cand} = mpz_inits(5), ch
for digits=2 to limit-1 do
    for d=1 to 9 do
        ch = ch5
        mpz_mul_si(d10,p10,d)
        mpz_mul_si(t10,p10,10)
        for chain=5 to 6 do
            mpz_add(cand,d10,ch)
            mpz_mul(sqr,cand,cand)
            mpz_fdiv_r(r10,sqr,t10)
            if mpz_cmp(cand,r10)=0 then
                count += 1
                if digits<=12 or digits>=limit-3 then
                    success = append(success,shorten(mpz_get_str(cand)))
                    squared = append(squared,shorten(mpz_get_str(sqr)))
                end if
                mpz_set(ch,cand)
            end if
            ch = ch6
        end for
    end for
    mpz_mul_si(p10,p10,10)
end for
printf(1,"%d steady squares < 1e%d found:\n",{count,limit})
for i=1 to length(success) do
    printf(1,"%13s^2 = %25s\n",{success[i],squared[i]})
end for

No doubt you could significantly improve that by replacing the mul/div with mpz_powm_ui(r10, cand, 2, t10) and o/c not even trying to print any of the silly-length numbers.

Output:
1783 steady squares < 1e1000 found:
            1^2 =                         1
            5^2 =                        25
            6^2 =                        36
           25^2 =                       625
           76^2 =                      5776
          376^2 =                    141376
          625^2 =                    390625
         9376^2 =                  87909376
        90625^2 =                8212890625
       109376^2 =               11963109376
       890625^2 =              793212890625
      2890625^2 =             8355712890625
      7109376^2 =            50543227109376
     12890625^2 =           166168212890625
     87109376^2 =          7588043387109376
    212890625^2 =         45322418212890625
    787109376^2 =        619541169787109376
   1787109376^2 =       3193759921787109376
   8212890625^2 =      67451572418212890625
  18212890625^2 =     331709384918212890625
  81787109376^2 =    6689131260081787109376
 918212890625^2 =  843114912509918212890625
18745998663099139651...07743740081787109376 (997 digits)^2 = 35141246587691473110...07743740081787109376 (1,993 digits)
81254001336900860348...92256259918212890625 (997 digits)^2 = 66022127332570868008...92256259918212890625 (1,994 digits)
21874599866309913965...07743740081787109376 (998 digits)^2 = 47849811931116570591...07743740081787109376 (1,995 digits)
78125400133690086034...92256259918212890625 (998 digits)^2 = 61035781460491829128...92256259918212890625 (1,996 digits)
27812540013369008603...92256259918212890625 (999 digits)^2 = 77353738199525217326...92256259918212890625 (1,997 digits)
72187459986630991396...07743740081787109376 (999 digits)^2 = 52110293793214504525...07743740081787109376 (1,998 digits)

Note that should this produce two steady squares of the same length that begin with the same digit, the one that ends in 5 would be shown first, even if it is numerically after then one that ends in 6, not that there are any such < 1e1000. In other words add a flag that effectively swaps the ch = ch5 and ch = ch6 lines.

No Search Required using strings

with javascript_semantics
atom t0 = time()
constant limit = 9999
sequence fivesix = {"5","6"} -- (held backwards)
for chain=5 to 6 do
    string f56 = fivesix[chain-4]
    integer d0 = f56[1]-'0', d = 0, n = floor(d0*d0/10), 
            dn = iff(chain=6?10-n:n)
    f56 &= dn+'0'
    for digit=2 to limit-1 do
        n = floor((n+d+2*dn*d0)/10)
        d = 0
        for j=2 to digit do
            d += (f56[j]-'0')*(f56[-j+1]-'0')
        end for
        dn = remainder(n+d,10)
        if chain=6 and dn then dn=10-dn end if
        f56 &= dn+'0'
    end for
    fivesix[chain-4] = f56
end for
integer count = 1
printf(1,"%13s\n",{"1"})
for d=1 to limit do
    sequence r = {}
    for j=1 to 2 do
        string fj = fivesix[j]
        if fj[d]!='0' then
            count += 1
            if d<=12 then
                r &= {sprintf("%13s",{reverse(fj[1..d])})}
            elsif d=999 or d=9999 then
                r &= {sprintf("%s...%s (%d digits)",{reverse(fj[d-19..d]),reverse(fj[1..20]),d})}
            end if
        end if
    end for
    if length(r)>1 and r[2]<r[1] then r = reverse(r) end if
    for i=1 to length(r) do
        printf(1,"%s\n",{r[i]})
    end for
end for
printf(1,"%d steady squares < 1e%d found\n",{count,limit+1})
?elapsed(time()-t0)
Output:
            1
            5
            6
           25
           76
          376
          625
         9376
        90625
       109376
       890625
      2890625
      7109376
     12890625
     87109376
    212890625
    787109376
   1787109376
   8212890625
  18212890625
  81787109376
 918212890625
27812540013369008603...92256259918212890625 (999 digits)
72187459986630991396...07743740081787109376 (999 digits)
10911738350087456573...92256259918212890625 (9999 digits)
89088261649912543426...07743740081787109376 (9999 digits)
18069 steady squares < 1e10000 found
"4.0s"

Unfortunately it is not particularly fast, 7mins on a 10 year old i3 for 99,999 digits, with results that match F#. Then again, I suppose it is a near-perfect candidate for my (far future) plans to boost performance in version 2... Perhaps more for my future benefit than anyone else's, if we replace the for j=2 to digit do loop with:

        #ilASM{
            mov esi,[f56]
            mov edx,[digit]
            mov ecx,1
            shl esi,2
            sub edx,1
            xor eax,eax
            xor edi,edi
         @@:
            mov al,[esi+ecx]
            mov bl,[esi+edx]
            sub al,'0'
            sub bl,'0'
            mul bl
            add edi,eax
            xor eax,eax
            sub edx,1
            add ecx,1
            cmp edx,1
            jge @b
            mov [d],edi
            xor ebx,ebx
                }

we get the above plus

27556434586762240381...07743740081787109376 (99999 digits)
72443565413237759618...92256259918212890625 (99999 digits)
179886 steady squares < 1e100000 found
"12.2s"

Which is a whopping 35-fold speedup, so obviously all I need to do is make the compiler emit similarly efficient code...

PL/0

const maxnumber = 10000;
var   p10, n, d, nd, n2;
begin
    p10 := 10;
    n   :=  0;
    while n <= maxnumber do begin
        if n = p10 then p10 := p10 * 10;
        d := 0;
        while d < 6 do begin
            if d = 5 then d := 6;
            if d = 1 then d := 5;
            if d = 0 then d := 1;
            nd := n + d;
            n2 := nd * nd;
            n2 := n2 - ( ( n2 / p10 ) * p10 );
            if n2 = nd then ! nd
        end;
        n := n + 10
    end
end.
Output:
          1
          5
          6
         25
         76
        376
        625
       9376

PL/M

Works with: 8080 PL/M Compiler
... under CP/M (or an emulator)

Although integers are restricted to unsigned 16-bit, 8080 PL/M also allows the use of BCD values. This sample uses 8-digit BCD to find the steady squares. As with other samples, only numbers ending in 1, 5 or 6 are considered (see the Discussion page).

100H: /* FIND SOME STEADY SQUARES - NUMBERS WHOSE SQUARES END IN THE NUMBER  */
      /*      E.G. 376^2 = 141$376                                           */

   /* CP/M SYSTEM CALL AND I/O ROUTINES                                      */
   BDOS:      PROCEDURE( FN, ARG ); DECLARE FN BYTE, ARG ADDRESS; GOTO 5; END;
   PR$CHAR:   PROCEDURE( C ); DECLARE C BYTE;    CALL BDOS( 2, C );  END;
   PR$STRING: PROCEDURE( S ); DECLARE S ADDRESS; CALL BDOS( 9, S );  END;
   PR$NL:     PROCEDURE;   CALL PR$CHAR( 0DH ); CALL PR$CHAR( 0AH ); END;
   PR$NUMBER: PROCEDURE( N ); /* PRINTS A NUMBER IN THE MINIMUN FIELD WIDTH  */
      DECLARE N ADDRESS;
      DECLARE V ADDRESS, N$STR ( 6 )BYTE, W BYTE;
      V = N;
      W = LAST( N$STR );
      N$STR( W ) = '$';
      N$STR( W := W - 1 ) = '0' + ( V MOD 10 );
      DO WHILE( ( V := V / 10 ) > 0 );
         N$STR( W := W - 1 ) = '0' + ( V MOD 10 );
      END;
      CALL PR$STRING( .N$STR( W ) );
   END PR$NUMBER;

   /* BCD ARITHMETIC                                                         */

   DECLARE DEC$LAST LITERALLY '3';           /* SUBSCRIPT OF LAST DIGIT PAIR */
   DECLARE DEC$LEN  LITERALLY '4';        /* LENGTH OF AN 8-DIGIT BCD NUMBER */
   DECLARE DEC$8    LITERALLY '( DEC$LEN )BYTE';   /* TYPE DECLARATION OF AN */
                                             /* 8-DIGIT BCD NUMBER - 4 BYTES */


   PR$DEC: PROCEDURE( A$PTR );               /* PRINT AN UNSIGNED BCD NUMBER */
      DECLARE A$PTR ADDRESS;
      DECLARE A BASED A$PTR DEC$8;
      DECLARE ( D, ZERO$CHAR, I, V ) BYTE;
      ZERO$CHAR = ' ';
      DO I = 0 TO DEC$LAST - 1;
         V = A( I );
         D = SHR( V AND 0F0H, 4 );
         IF D = 0 THEN CALL PR$CHAR( ZERO$CHAR );
                  ELSE CALL PR$CHAR( D + ( ZERO$CHAR := '0' ) );
         D = V AND 0FH;
         IF D = 0 THEN CALL PR$CHAR( ZERO$CHAR );
                  ELSE CALL PR$CHAR( D + ( ZERO$CHAR := '0' ) );
      END;
      V = A( DEC$LAST );
      D = SHR( V AND 0F0H, 4 );
      IF D = 0 THEN CALL PR$CHAR( ZERO$CHAR );
               ELSE CALL PR$CHAR( D + '0' );
      D = V AND 0FH;
      CALL PR$CHAR( D + '0' );
   END PR$DEC ;

   INIT$DEC: PROCEDURE( A$PTR );             /* SETS THE BCD VALUE IN A TO 0 */
      DECLARE A$PTR ADDRESS;
      DECLARE A BASED A$PTR DEC$8;
      DECLARE I BYTE;
      DO I = 0 TO DEC$LAST;
         A( I ) = 0;
      END;
   END INIT$DEC ;

   SET$DEC: PROCEDURE( A$PTR, B );           /* SETS THE BCD VALUE IN A TO B */
      DECLARE ( A$PTR, B ) ADDRESS;
      DECLARE A BASED A$PTR DEC$8;
      DECLARE ( I, P, D1, D2 ) BYTE;
      DECLARE V ADDRESS;
      V = B;
      P = DEC$LAST;
      DO I = 0 TO DEC$LAST;
         IF V = 0
         THEN A( P ) = 0;
         ELSE DO;  
            D1 = V MOD 10;
            D2 = ( V := V / 10 ) MOD 10;
            A( P ) = SHL( D2, 4 ) OR D1;
            V = V / 10;
         END;
         P = P - 1;
      END;
   END SET$DEC ;

   MOV$DEC: PROCEDURE( A$PTR, B$PTR );     /* ASSIGN THE BCD VALUE IN B TO A */
      DECLARE ( A$PTR, B$PTR ) ADDRESS;
      DECLARE A BASED A$PTR DEC$8, B BASED B$PTR DEC$8;
      DECLARE I BYTE;
      DO I = 0 TO DEC$LAST;
         A( I ) = B( I );
      END;
   END MOV$DEC ;

   ADD$DEC: PROCEDURE( A$PTR, B$PTR );   /* 8-DIGIT BCD ADDITION RESULT IN A */
      DECLARE ( A$PTR, B$PTR ) ADDRESS;
      DECLARE A BASED A$PTR DEC$8, B BASED B$PTR DEC$8;
      DECLARE ( A0, A1, A2, A3 ) BYTE;
      DECLARE ( B0, B1, B2, B3 ) BYTE;
      /* SEPARATE THE DIGIT PAIRS                                            */
      A0 = A( 0 ); A1 = A( 1 ); A2 = A( 2 ); A3 = A( 3 );
      B0 = B( 0 ); B1 = B( 1 ); B2 = B( 2 ); B3 = B( 3 );
      /* DO THE ADDITIONS                                                    */
      A3 = DEC( A3   +  B3 );
      A2 = DEC( A2 PLUS B2 );
      A1 = DEC( A1 PLUS B1 );
      A0 = DEC( A0 PLUS B0 );
      /* RETURN THE RESULT                                                   */
      A( 0 ) = A0; A( 1 ) = A1; A( 2 ) = A2; A( 3 ) = A3;
   END ADD$DEC;

   /* 8-DIGIT BCD MULTIPLICATION BY AN UNSIGNED INTEGER VIA ETHIOPIAN        */
   /*         MULTIPLICATION, RESULT IN A                                    */
   MUL$DEC: PROCEDURE( A$PTR, B );
      DECLARE ( A$PTR, B ) ADDRESS;
      DECLARE V ADDRESS, R DEC$8, ACCUMULATOR DEC$8;
      CALL MOV$DEC( .R, A$PTR );
      V = B;
      CALL INIT$DEC( .ACCUMULATOR );
      DO WHILE( V > 0 );
         IF ( V AND 1 ) = 1 THEN DO;
            CALL ADD$DEC( .ACCUMULATOR, .R );
         END;
         V = SHR( V, 1 );
         CALL ADD$DEC( .R, .R );
      END;
      CALL MOV$DEC( A$PTR, .ACCUMULATOR );
   END MUL$DEC ;

   BIN$DEC4: PROCEDURE( A$PTR )ADDRESS;   /* CONVERT A 4-DIGIT BCD NUMBER TO */
      DECLARE A$PTR ADDRESS;                                       /* BINARY */
      DECLARE A BASED A$PTR DEC$8;
      DECLARE ( D, V, RESULT ) ADDRESS, I BYTE;
      RESULT = 0;
      DO I = DEC$LAST - 1 TO DEC$LAST;
         V = A( I );
         D = SHR( V AND 0F0H, 4 );
         RESULT = ( RESULT * 10 ) + D;
         D = V AND 0FH;
         RESULT = ( RESULT * 10 ) + D;
      END;
      RETURN RESULT;
   END BIN$DEC4 ;

   /* TASK                                                                   */

   DECLARE ( P, Q, F, POWER$OF$10 ) ADDRESS;
   DECLARE SQ  DEC$8;

   POWER$OF$10 = 10;

   DO P = 0 TO 10$000 BY 10;
      IF P = POWER$OF$10 THEN DO;
         /* REACHED THE CURRENT POWER OF TEN - THE NUMBERS NOW HAVE ANOTHER  */
         /* DIGIT                                                            */
         POWER$OF$10 = POWER$OF$10 * 10;
      END;
      DO F = 0 TO 2;
         DO CASE F;
            /* 0 */ Q = P + 1;
            /* 1 */ Q = P + 5;
            /* 2 */ Q = P + 6;
         END;
         CALL SET$DEC( .SQ, Q );
         CALL MUL$DEC( .SQ, Q );
         /* CONVERT THE LAST 4 DIGITS OF THE DECIMAL NUMBER TO BINARY        */
         /* AND COMPARE THE MODULI                                           */
         IF BIN$DEC4( .SQ ) MOD POWER$OF$10 = Q THEN DO;
            /* FOUND ANOTHER STEADY SQUARE                                   */
            IF Q <   10 THEN CALL PR$CHAR( ' ' );
            IF Q <  100 THEN CALL PR$CHAR( ' ' );
            IF Q < 1000 THEN CALL PR$CHAR( ' ' );
            CALL PR$NUMBER( Q );
            CALL PR$STRING( .'**2: $' );
            CALL PR$DEC( .SQ );
            CALL PR$NL;
         END;
      END;
   END;

EOF
Output:
   1**2:        1
   5**2:       25
   6**2:       36
  25**2:      625
  76**2:     5776
 376**2:   141376
 625**2:   390625
9376**2: 87909376

Prolog

works with swi-prolog

steadySquare([], _, []).
steadySquare([N| NTail], Modulo, SteadyList):-
	Modulo =< N,!,
	Modulo1 is Modulo * 10,
	steadySquare([N| NTail], Modulo1, SteadyList).
steadySquare([N| NTail], Modulo, [N| SteadyList]):-
	N ^ 2 mod Modulo =:= N,!,
	steadySquare(NTail, Modulo, SteadyList).
steadySquare([_| NTail], Modulo, SteadyList):-
	steadySquare(NTail, Modulo, SteadyList).

candidateList(Limit, List):-
	candidateList(5, Limit, List0),
	append([0,1], List0, List).

candidateList(N, Limit, [N, N1| Tail]):-
	N < Limit,!,
	N1 is N + 1,
	N10 is N + 10,
	candidateList(N10, Limit, Tail).
candidateList(_, _, []).

showList(_, []):-!.
showList(FrmStr, [StSquare| Tail]):-
	Sqr is StSquare ^ 2,
	format(FrmStr, [StSquare, Sqr]),
	showList(FrmStr, Tail).
	
do:- candidateList(1000000, List),
	steadySquare(List, 1, SteadySquareList),
	last(SteadySquareList, LastStSqr),
	LastLen is 1 + floor(log10(LastStSqr)),
	LastSqrLen is 1 + floor(log10(LastStSqr ^ 2)),
	swritef(FrmStr, '~|~t~d~%d+ ~|~t~d~%d+~n', [LastLen, LastSqrLen]),
	showList(FrmStr, SteadySquareList).
Output:
?- time(do).
     0            0
     1            1
     5           25
     6           36
    25          625
    76         5776
   376       141376
   625       390625
  9376     87909376
 90625   8212890625
109376  11963109376
890625 793212890625
% 900,133 inferences, 0.235 CPU in 0.235 seconds (100% CPU, 3834748 Lips)
true.

PROMAL

As with the Tiny BASIC sample, 16-bit languages must avoid overflow when solving this task. Uses long multiplication modulo the appropriate power of ten and the fact that the final digit must be 1, 5 or 6 (see the Discussion page).

PROGRAM steadySquares
INCLUDE LIBRARY

WORD p     ; the number to square, with the final digit replaced by 0
WORD n     ; the number to square
WORD d10   ; 10^the number of digits in p, n
WORD s     ; the square of n modulo d10
WORD f     ; loop counter to choose 1, 5 or 6 as the final digit of n
WORD front ; the first two digits of n
WORD back  ; the last two digits of n

BEGIN
d10 = 10
p = 0
WHILE p < 10000
  IF p = d10
     d10 = d10 * 10
  FOR f = 1 TO 3
    CHOOSE f
    1
      n = p + 1
    2
      n = p + 5
    ELSE
      n = p + 6
    IF n <= 255
      s = ( n * n )
    ELSE
      front = n / 100
      back  = n % 100
      s = ( back * back ) + ( 200 * ( ( front * back ) % 100 ) )
    s = s % d10
    IF s = n
      OUTPUT " #W", n
  p = p + 10
END
Output:
 1 5 6 25 76 376 625 9376

Python

Procedural

print("working...")
print("Steady squares under 10.000 are:")
limit = 10000

for n in range(1,limit):
    nstr = str(n)
    nlen = len(nstr)
    square = str(pow(n,2))
    rn = square[-nlen:]
    if nstr == rn:
       print(str(n) + " " + str(square))

print("done...")
Output:
working...
Steady squares under 10.000 are:
1 1
5 25
6 36
25 625
76 5776
376 141376
625 390625
9376 87909376
done...

Functional

'''Steady squares'''

from itertools import chain


# steadyPair :: Int -> [(String, String)]
def steadyPair(x):
    '''An empty list if x^2 is not suffixed, in decimal,
       by the decimal digits of x. Otherwise a list
       containing a tuple of the decimal strings of (x, x^2)
    '''
    s, s2 = str(x), str(x**2)
   
    return [(s, s2)] if s2.endswith(s) else []


# ------------------------ TESTS -------------------------
# main :: IO ()
def main():
    '''Roots of numbers with steady squares up to 10000
    '''
    ns = range(1, 1 + 10000)
    xs = concatMap(steadyPair)(ns)
    w, w2 = (len(x) for x in xs[-1])

    print([n for n in ns if steadyPair(n)])
    print()
    print(
        '\n'.join([
            f'{s.rjust(w, " ")} -> {s2.rjust(w2, " ")}'
            for (s, s2) in xs
        ])
    )


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

# concatMap :: (a -> [b]) -> [a] -> [b]
def concatMap(f):
    '''A concatenated list over which a function has been
       mapped.
       The list monad can be derived by using a function f
       which wraps its output in a list, (using an empty
       list to represent computational failure).
    '''
    def go(xs):
        return list(chain.from_iterable(map(f, xs)))
    return go


# MAIN ---
if __name__ == '__main__':
    main()
Output:
[1, 5, 6, 25, 76, 376, 625, 9376]

   1 ->        1
   5 ->       25
   6 ->       36
  25 ->      625
  76 ->     5776
 376 ->   141376
 625 ->   390625
9376 -> 87909376


Or, defining the squares as an additive accumulation:

'''Steady Squares'''

from itertools import accumulate, chain, count, takewhile
from operator import add


def main():
    '''Numbers up to 10000 which have steady squares'''
    print(
        '\n'.join(
            f'{a} -> {b}' for (a, b) in takewhile(
                lambda ab: 10000 > ab[0],
                enumerate(
                    accumulate(
                        chain([0], count(1, 2)),
                        add
                    )
                )
            ) if str(b).endswith(str(a))
        )
    )


# MAIN ---
if __name__ == '__main__':
    main()
Output:
0 -> 0
1 -> 1
5 -> 25
6 -> 36
25 -> 625
76 -> 5776
376 -> 141376
625 -> 390625
9376 -> 87909376

Raku

.say for ({$++²}…*).kv.grep( {$^v.ends-with: $^k} )[1..10]
Output:
(1 1)
(5 25)
(6 36)
(25 625)
(76 5776)
(376 141376)
(625 390625)
(9376 87909376)
(90625 8212890625)
(109376 11963109376)

Quackery

 [ 1 swap
   [ 10 / dup while
     dip 1+ again ]
   drop ]           is digitcount ( n --> n )

  [ dup 2 **
    over digitcount
    10 swap **
    mod = ]         is steady     ( n --> b )

  []
  10000 times
    [ i^ steady if [ i^ join ] ]
  echo
Output:
[ 0 1 5 6 25 76 376 625 9376 ]

Refal

$ENTRY Go {
    = <FindSteady 1 9999>;
};

FindSteady {
    s.N s.Max, <Compare s.N s.Max>: '+' = ;
    s.N s.Max, <Steady <Symb s.N>>: F = <FindSteady <+ s.N 1> s.Max>;
    s.N s.Max = <ShowSteady s.N> <FindSteady <+ s.N 1> s.Max>;
};

ShowSteady {
    s.N = <Prout <Symb s.N> '^2 = ' <* s.N s.N>>;
};

Steady {
    e.N, <Symb <* <Numb e.N> <Numb e.N>>>: e.X e.N = T;
    e.N = F;
};
Output:
1^2 = 1
5^2 = 25
6^2 = 36
25^2 = 625
76^2 = 5776
376^2 = 141376
625^2 = 390625
9376^2 = 87909376

REXX

/* REXX */
Numeric Digits 50
Call time 'R'
n=1000000000
Say 'Steady squares below' n
Do i=1 To n
  c=right(i,1)
  If pos(c,'156')>0 Then Do
    i2=i*i
    If right(i2,length(i))=i Then
      Say right(i,length(n)) i2
    End
  End
Say time('E')
Output:
Steady squares below 1000000000
         1 1
         5 25
         6 36
        25 625
        76 5776
       376 141376
       625 390625
      9376 87909376
     90625 8212890625
    109376 11963109376
    890625 793212890625
   2890625 8355712890625
   7109376 50543227109376
  12890625 166168212890625
  87109376 7588043387109376
 212890625 45322418212890625
 787109376 619541169787109376
468.422000

Ring

see "working..." +nl
see "Steady squatres under 10.000 are:" + nl
limit = 10000

for n = 1 to limit
    nstr = string(n)
    len = len(nstr)
    square = pow(n,2)
    rn = right(string(square),len)
    if nstr = rn
       see "" + n + " -> " + square + nl
    ok
next

see "done..." +nl
Output:
working...
Steady numbers under 10.000 are:
1 -> 1
5 -> 25
6 -> 36
25 -> 625
76 -> 5776
376 -> 141376
625 -> 390625
9376 -> 87909376
done...

RPL

Brute force approach

Numbers are converted into strings to make comparison easier.

≪ { 1 } 5 ROT FOR n 
     n →STR n SQ →STR 
     DUP SIZE 3 PICK SIZE - 1 + OVER SIZE SUB 
     IF == THEN n + END 
  NEXT 
≫ ‘STEDY’ STO
10000 STEDY
Output:
1: { 1 5 6 25 76 376 625 9376 }

Slight optimization

Steady numbers must end with 5 or 6, but there's no double-digits-or-more ones ending with 1: if ##b1 was the base 10 representation of such a number, the 2nd digit from the right shall be b (because of steadiness) and 2b (because of the elevation to square), which means b=0. By recurrence, all digits shall be zero.

≪ { 1 } 0 ROT FOR n 
     5 6 FOR j
        n j + →STR LAST SQ →STR 
        DUP SIZE 3 PICK SIZE - 1 + OVER SIZE SUB 
        IF == THEN n j + + END 
     NEXT
  10 STEP
≫ ‘STEDY’ STO

Ruby

p (0..10_000).select{|n| (n*n).to_s.end_with? n.to_s }
Output:
[0, 1, 5, 6, 25, 76, 376, 625, 9376]

Rust

fn is_steady_square(n: u32) -> bool {
    fn iter(n: u32, m: u32) -> u64 {
        if m <= n {iter(n, 10 * m)}
        else {m as u64}
    }
    let nl = n as u64;
    nl * nl % iter(n, 1) == nl
}

fn main() {
    let start = std::time::Instant::now();
    let limit = 10_000_000;
    let list5 = (5..=limit).step_by(10)
                .flat_map(|n|[n, n+1])
                .filter(|&n| is_steady_square(n));
    let list: Vec<u32> = (0..2).into_iter().chain(list5).collect();

    let max = *list.iter().last().unwrap();
    let maxl = max as u64;
    let duration = start.elapsed().as_millis();
    let max_len = max.to_string().len();
    let sqr_len = (maxl*maxl).to_string().len();
    println!("{:>max_len$} {:>sqr_len$}", "num", "square");
    for n in list {
        let nl = n as u64;
        println!("{:max_len$} {:sqr_len$}", n, nl*nl);
    }
    println!("time(ms): {duration}");
 }
Output:
    num         square
      0              0
      1              1
      5             25
      6             36
     25            625
     76           5776
    376         141376
    625         390625
   9376       87909376
  90625     8212890625
 109376    11963109376
 890625   793212890625
2890625  8355712890625
7109376 50543227109376
time(ms): 50

Scala

ready for Scala3

def steadySquares(cand: Seq[Int], modulo: Long, acc: Seq[Int]): Seq[Int] = {
  if (cand.isEmpty) return acc
  val num = cand.head
  val numl = num.toLong
  val modulo1 = if (modulo > numl) modulo else 10 * modulo
  val acc1 = if (numl * numl % modulo1 != numl) acc
             else acc :+ num
  steadySquares(cand.tail, modulo1, acc1)
}

val limit = 1_000_000
val candidates = Seq(0, 1) ++ (5 to limit by 10).flatMap(n => Seq(n, n + 1))
val list = steadySquares(candidates, 1, Seq())

@main def main = {
  val start = System.currentTimeMillis
  val max = list.last.toLong
  val Seq(maxLen, sqrLen) = Seq(max, max * max).map(_.toString.length)
  for (steadySquare <- list) {
    val stSqr = steadySquare.toLong
    val sqr = stSqr * stSqr
    println("%%%dd %%%dd".format(maxLen, sqrLen).format(stSqr, sqr))
  }
  val duration = System.currentTimeMillis - start
  println(s"time(ms): $duration")
}
Output:
     0            0
     1            1
     5           25
     6           36
    25          625
    76         5776
   376       141376
   625       390625
  9376     87909376
 90625   8212890625
109376  11963109376
890625 793212890625
time(ms): 7

SETL

program steady_squares;
    loop for n in [1..10000] | steady n do
        print(str n + "^2 = " + str (n**2));
    end loop;

    op steady(n);
        return n**2 mod 10**#str n = n;
    end op;
end program;
Output:
1^2 = 1
5^2 = 25
6^2 = 36
25^2 = 625
76^2 = 5776
376^2 = 141376
625^2 = 390625
9376^2 = 87909376

TypeScript

Translation of: C
// Steady squares

function steady(n: number): bool {
  // Result: true if n * n is steady; false otherwise.
  var mask = 1;
  for (var d = n; d != 0; d = Math.floor(d / 10))
    mask *= 10;
  return (n * n) % mask == n;
}

for (var i = 1; i < 10000; i++)
  if (steady(i))
    console.log(i.toString().padStart(4, ' ') + "^2 = " +
      (i * i).toString().padStart(8, ' '));
Output:
   1^2 =        1
   5^2 =       25
   6^2 =       36
  25^2 =      625
  76^2 =     5776
 376^2 =   141376
 625^2 =   390625
9376^2 = 87909376

VTL-2

Translation of: Tiny BASIC
110 P=0
120 D=10
130 X=1
140 D=D=P*9*D+D
150 N=P+X
160 F=N/100
170 B=N-(F*100)
180 S=F*B-(F*B/100*100)*200+(B*B)
190 #=S-(S/D*D)=N=0*220
200 ?=N
210 $=32
220 X=X+4
230 #=X=10=0*260
240 P=P+10
250 X=1
260 #=X=9=0*280
270 X=6
280 #=P<9990*140
Output:
1 5 6 25 76 376 625 9376

Wren

Library: Wren-fmt

Although it hardly matters for a small range such as this, one can cut down the numbers to be examined by observing that a steady square must end in 1, 5 or 6.

import "./fmt" for Fmt

System.print("Steady squares under 10,000:")
var finalDigits = [1, 5, 6]
for (i in 1..9999) {
    if (!finalDigits.contains(i % 10)) continue
    var sq = i * i
    if (sq.toString.endsWith(i.toString)) Fmt.print("$,5d -> $,10d", i, sq)
}
Output:
Steady squares under 10,000:
    1 ->          1
    5 ->         25
    6 ->         36
   25 ->        625
   76 ->      5,776
  376 ->    141,376
  625 ->    390,625
9,376 -> 87,909,376

XPL0

int  N, P;
[for N:= 0 to 10000-1 do
    [P:= 1;
    repeat P:= P*10 until P>N;
    if rem(N*N/P) = N then
        [IntOut(0, N);
        Text(0, "^^2 = ");
        IntOut(0, N*N);
        CrLf(0);
        ];
    ];
]
Output:
0^2 = 0
1^2 = 1
5^2 = 25
6^2 = 36
25^2 = 625
76^2 = 5776
376^2 = 141376
625^2 = 390625
9376^2 = 87909376