Jump to content

Show the (decimal) value of a number of 1s appended with a 3, then squared

From Rosetta Code
(Redirected from N 1's followed by a 3)
Show the (decimal) value of a number of 1s appended with a 3, then squared 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.
Task

Show here (on this page) the decimal numbers formed by:

(n   1's   appended by the digit   3)   and then square the result,     where   0   <=   n   <   8
See also


11l

Translation of: Python
L(i) 0..7 {print(‘( ’(‘1’ * i)‘3 ) ^ 2 = ’(Int64((‘1’ * i)‘3’) ^ 2))}
Output:
( 3 ) ^ 2 = 9
( 13 ) ^ 2 = 169
( 113 ) ^ 2 = 12769
( 1113 ) ^ 2 = 1238769
( 11113 ) ^ 2 = 123498769
( 111113 ) ^ 2 = 12346098769
( 1111113 ) ^ 2 = 1234572098769
( 11111113 ) ^ 2 = 123456832098769

Ada

with Ada.Text_Io;
with Ada.Numerics.Big_Numbers.Big_Integers;

procedure Ones_Plus_Three is
   use Ada.Numerics.Big_Numbers.Big_Integers;
   use Ada.Text_Io;

   Root    : Big_Natural := 3;
   Squared : Big_Natural;
begin
   for N in 0 .. 8 loop
      Squared := Root**2;

      Put (To_String (Root, Width => 12));
      Put ("  ");
      Put (To_String (Squared, Width => 20));
      New_Line;

      Root := @ + 10**(N + 1);
   end loop;
end Ones_Plus_Three;
Output:
           3                     9
          13                   169
         113                 12769
        1113               1238769
       11113             123498769
      111113           12346098769
     1111113         1234572098769
    11111113       123456832098769
   111111113     12345679432098769

ALGOL 68

Assuming LONG INT is large enough (as in e.g. ALGOL 68G).

BEGIN
    LONG INT n := 0;
    TO 8 DO
        LONG INT n3 = ( n * 10 ) + 3;
        print( ( whole( n3, 0 ), " ", whole( n3 * n3, 0 ), newline ) );
        n *:= 10 +:= 1
    OD
END
Output:
3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
1111113 1234572098769
11111113 123456832098769

Alternative version that shows the values for higher numbers of ones.

Works with: ALGOL 68G version Any - tested with release 2.8.3.win32
BEGIN
    PR precision 250 PR
    LONG LONG INT n := 0;
    FOR i FROM 0 TO 111 DO
        LONG LONG INT n3 = ( n * 10 ) + 3;
        IF i > 84 THEN
            STRING v := whole( n3 * n3, 0 );
            INT pos := 0;
            STRING pattern := "123456790";
            INT    p len   := ( UPB pattern - LWB pattern ) + 1;
            WHILE string in string( pattern, pos, v ) DO
                v := v[ 1 : pos - 1 ] + "A" + v[ pos + p len : ]
            OD;
            pattern := "987654320";
            WHILE string in string( pattern, pos, v ) DO
                v := v[ 1 : pos - 1 ] + "Z" + v[ pos + p len : ]
            OD;
            print( ( whole( i, -3 ), " ", v, newline ) )
        FI;
        n *:= 10 +:= 1
    OD
END
Output:

As the 111...113^2 values get rather large, the code above replaces "123456790" with "A" and "987654320" with "Z". The number of ones is shown on the left.

 85 AAAAAAAAA1234ZZZZZZZZZ98769
 86 AAAAAAAAA123460ZZZZZZZZZ98769
 87 AAAAAAAAA12345720ZZZZZZZZZ98769
 88 AAAAAAAAA1234568320ZZZZZZZZZ98769
 89 AAAAAAAAA123456794320ZZZZZZZZZ98769
 90 AAAAAAAAAA54320ZZZZZZZZZ98769
 91 AAAAAAAAAA1654320ZZZZZZZZZ98769
 92 AAAAAAAAAA127654320ZZZZZZZZZ98769
 93 AAAAAAAAAA12387654320ZZZZZZZZZ98769
 94 AAAAAAAAAA1234ZZZZZZZZZZ98769
 95 AAAAAAAAAA123460ZZZZZZZZZZ98769
 96 AAAAAAAAAA12345720ZZZZZZZZZZ98769
 97 AAAAAAAAAA1234568320ZZZZZZZZZZ98769
 98 AAAAAAAAAA123456794320ZZZZZZZZZZ98769
 99 AAAAAAAAAAA54320ZZZZZZZZZZ98769
100 AAAAAAAAAAA1654320ZZZZZZZZZZ98769
101 AAAAAAAAAAA127654320ZZZZZZZZZZ98769
102 AAAAAAAAAAA12387654320ZZZZZZZZZZ98769
103 AAAAAAAAAAA1234ZZZZZZZZZZZ98769
104 AAAAAAAAAAA123460ZZZZZZZZZZZ98769
105 AAAAAAAAAAA12345720ZZZZZZZZZZZ98769
106 AAAAAAAAAAA1234568320ZZZZZZZZZZZ98769
107 AAAAAAAAAAA123456794320ZZZZZZZZZZZ98769
108 AAAAAAAAAAAA54320ZZZZZZZZZZZ98769
109 AAAAAAAAAAAA1654320ZZZZZZZZZZZ98769
110 AAAAAAAAAAAA127654320ZZZZZZZZZZZ98769
111 AAAAAAAAAAAA12387654320ZZZZZZZZZZZ98769

Arturo

loop 0..7 'x [
    num: to :integer(repeat "1" x) ++ "3"
    print [num num^2]
]
Output:
3 9 
13 169 
113 12769 
1113 1238769 
11113 123498769 
111113 12346098769 
1111113 1234572098769 
11111113 123456832098769

AWK

BEGIN {
    m = 2
    for (n = 0; n != 8; ++n) {
        m = m * 10 - 17
        printf "%u %9u^2 %'20u\n", n, m, m * m
    }
}
Output:
0         3^2                    9
1        13^2                  169
2       113^2               12,769
3      1113^2            1,238,769
4     11113^2          123,498,769
5    111113^2       12,346,098,769
6   1111113^2    1,234,572,098,769
7  11111113^2  123,456,832,098,769

BASIC

BASIC256

Translation of: Yabasic
for n = 0 to 7
	m = make13(n) ^ 2

	print rjust(string(make13(n)), 9); "^2 = "; ljust(string(m), 15)
next n
end

function make13 (n)
	t = 0
	while n
		t = 10 * (t + 1)
		n -= 1
	end while
	return t + 3
end function

Chipmunk Basic

Translation of: Yabasic
Works with: Chipmunk Basic version 3.6.4
100 cls
110 sub make13(n)
120   t = 0
130   while n
140     t = 10*(t+1)
150     n = n-1
160   wend
170   make13 = t+3
180 end sub
190 for n = 0 to 7
200   m = make13(n)^2
210   print using "#########";make13(n);"^2 = ";
220   print using "###############";m
230 next n
240 end
Output:
Similar to Yabasic entry.

Gambas

Translation of: Yabasic
Public Function make13(n As Integer) As Integer

  Dim t As Integer = 0 
  While n 
    t = 10 * (t + 1) 
    n -= 1 
  Wend 
  Return t + 3

End Function

Public Sub Main()

  Dim m As Long
  For n As Integer = 0 To 7 
    m = make13(n) ^ 2 
    Print Format(make13(n), "#########"); "^2 = "; Format(m, "###############")
  Next 

End
Output:
Similar to Yabasic entry.

PureBasic

Translation of: Yabasic
Procedure.i make13 (n.i)
  Define t.i = 0
  While n
    t = 10 * (t + 1)
    n - 1
  Wend
  ProcedureReturn t + 3
EndProcedure

OpenConsole()
Define m.i

For n.i = 0 To 7
  m = Pow(make13(n), 2)
  PrintN(Right(Space(9) + Str(make13(n)), 9) + "^2 = " + StrU(m))
Next n

PrintN("---Program done, press RETURN---"): Input()
Output:
Same as Yabasic entry.

QB64

Translation of: Yabasic
Dim m As _Integer64
Dim n As Integer

For n = 0 To 7
    m = make13(n) ^ 2
    Print Using "#########^2 = ###############"; make13(n); m
Next n
End

Function make13 (n)
    Dim t As _Integer64
    t = 0
    While n
        t = 10 * (t + 1)
        n = n - 1
    Wend
    make13 = t + 3
End Function
Output:
Similar to Yabasic entry.

Run BASIC

Translation of: Yabasic
Works with: Just BASIC
Works with: Liberty BASIC
for n = 0 to 7
    m = make13(n)^2
    print using("#########", make13(n)) + "^2 = " + using("###############", m)
next n
end

function make13(n)
    t = 0
    while n
        t = 10 *(t +1)
        n = n -1
    wend
    make13 = t+3
end function
Output:
Similar to Yabasic entry.

Yabasic

Translation of: FreeBASIC
for n = 0 to 7
    m = make13(n)^2
    print make13(n) using "#########", "^2 = ", m using "###############"
next n
end

sub make13(n)
    local t
	
	t = 0
    while n
        t = 10*(t+1)
        n = n - 1
    wend
    return t+3
end sub
Output:
        3^2 =               9
       13^2 =             169
      113^2 =           12769
     1113^2 =         1238769
    11113^2 =       123498769
   111113^2 =     12346098769
  1111113^2 =   1234572098769
 11111113^2 = 123456832098769

bc

x = 2
for (n = 0; n != 8; ++n) {
    x = x * 10 - 17
    x
    " -> "
    x * x
}
Output:
3
 -> 9
13
 -> 169
113
 -> 12769
1113
 -> 1238769
11113
 -> 123498769
111113
 -> 12346098769
1111113
 -> 1234572098769
11111113
 -> 123456832098769

BQN

˘(ט) 2(¯17)` 810
Output:
┌─
╵        3               9
        13             169
       113           12769
      1113         1238769
     11113       123498769
    111113     12346098769
   1111113   1234572098769
  11111113 123456832098769
                           ┘

C

#include <stdio.h>
#include <stdint.h>

uint64_t ones_plus_three(uint64_t ones) {
    uint64_t r = 0;
    while (ones--) r = r*10 + 1;
    return r*10 + 3;
}

int main() {
    uint64_t n;
    for (n=0; n<8; n++) {
        uint64_t x = ones_plus_three(n);
        printf("%8lu^2 = %15lu\n", x, x*x);
    }
    return 0;
}
Output:
       3^2 =               9
      13^2 =             169
     113^2 =           12769
    1113^2 =         1238769
   11113^2 =       123498769
  111113^2 =     12346098769
 1111113^2 =   1234572098769
11111113^2 = 123456832098769

C#

For 0 <= n < 22

using System; using BI = System.Numerics.BigInteger;
class Program { static void Main(string[] args) {
    for (BI x = 3; BI.Log10(x) < 22; x = (x - 2) * 10 + 3)
      Console.WriteLine("{1,43} {0,-20}", x, x * x); } }
Output:
                                          9 3                   
                                        169 13                  
                                      12769 113                 
                                    1238769 1113                
                                  123498769 11113               
                                12346098769 111113              
                              1234572098769 1111113             
                            123456832098769 11111113            
                          12345679432098769 111111113           
                        1234567905432098769 1111111113          
                      123456790165432098769 11111111113         
                    12345679012765432098769 111111111113        
                  1234567901238765432098769 1111111111113       
                123456790123498765432098769 11111111111113      
              12345679012346098765432098769 111111111111113     
            1234567901234572098765432098769 1111111111111113    
          123456790123456832098765432098769 11111111111111113   
        12345679012345679432098765432098769 111111111111111113  
      1234567901234567905432098765432098769 1111111111111111113 
    123456790123456790165432098765432098769 11111111111111111113
  12345679012345679012765432098765432098769 111111111111111111113
1234567901234567901238765432098765432098769 1111111111111111111113

C++

#include <cstdint>
#include <iomanip>
#include <iostream>

int main() {
	for ( uint32_t i = 0; i < 8; ++i ) {
		const uint64_t ones = std::stol(std::string(i, '1') + "3");
	    std::cout << std::setw(9) << ones << "^2 = " << ones * ones << std::endl;
	}
}
Output:
        3^2 = 9
       13^2 = 169
      113^2 = 12769
     1113^2 = 1238769
    11113^2 = 123498769
   111113^2 = 12346098769
  1111113^2 = 1234572098769
 11111113^2 = 123456832098769

CLU

ones_plus_three = proc (n: int) returns (int)
    r: int := 0
    for i: int in int$from_to(1, n) do
        r := r*10 + 1
    end
    return(r*10 + 3)
end ones_plus_three

start_up = proc ()
    po: stream := stream$primary_output()
    
    for i: int in int$from_to(0, 7) do
        n: int := ones_plus_three(i)
        nsq: int := n**2
        
        stream$putright(po, int$unparse(n), 8)
        stream$puts(po, "^2 = ")
        stream$putright(po, int$unparse(nsq), 15)
        stream$putl(po, "")
    end
end start_up
Output:
       3^2 =               9
      13^2 =             169
     113^2 =           12769
    1113^2 =         1238769
   11113^2 =       123498769
  111113^2 =     12346098769
 1111113^2 =   1234572098769
11111113^2 = 123456832098769

COBOL

       IDENTIFICATION DIVISION.
       PROGRAM-ID. ONES-THREE-SQUARED.

       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 VARIABLES.
          03 N                  PIC 9.
          03 ONES-3             PIC 9(9).
          03 SQUARE             PIC 9(15).
       01 FMT.
          03 FMT-ONES-3         PIC Z(7)9.
          03 FILLER             PIC X(5) VALUE "^2 = ".
          03 FMT-SQUARE         PIC Z(14)9.

       PROCEDURE DIVISION.
       BEGIN.
           PERFORM N-ONES-3 VARYING N FROM 0 BY 1 UNTIL N IS EQUAL TO 8.
           STOP RUN.

       N-ONES-3.
           MOVE ZERO TO ONES-3.
           PERFORM ADD-ONE N TIMES.
           MULTIPLY 10 BY ONES-3.
           ADD 3 TO ONES-3.
           MULTIPLY ONES-3 BY ONES-3 GIVING SQUARE.
           MOVE ONES-3 TO FMT-ONES-3.
           MOVE SQUARE TO FMT-SQUARE.
           DISPLAY FMT.

       ADD-ONE.
           MULTIPLY 10 BY ONES-3.
           ADD 1 TO ONES-3.
Output:
       3^2 =               9
      13^2 =             169
     113^2 =           12769
    1113^2 =         1238769
   11113^2 =       123498769
  111113^2 =     12346098769
 1111113^2 =   1234572098769
11111113^2 = 123456832098769

Dart

Translation of: C++
import 'dart:core';

void main() {
  for (int i = 0; i < 8; ++i) {
    final ones = int.parse('1' * i + '3');
    print('${ones.toString().padLeft(9)}^2 = ${ones * ones}');
  }
}
Output:
Same as C++ entry.

dc

2[10*17-p[ -> ]Pdd*pZ15>l]dslx
Output:
3
 -> 9
13
 -> 169
113
 -> 12769
1113
 -> 1238769
11113
 -> 123498769
111113
 -> 12346098769
1111113
 -> 1234572098769
11111113
 -> 123456832098769

Delphi

Works with: Delphi version 6.0
procedure OnesPlusThree(Memo: TMemo);
{Create pattern: 3, 13, 113, 1113, and square}
var NS: string;
var I: integer;
var NV: int64;
begin
{Start with 3 in number string}
NS:='3';
for I:=1 to 7 do
	begin
	{Convert to a number}
	NV:=StrToInt(NS);
	Memo.Lines.Add(Format('%2D - %10d^2 =%18.0n',[I,NV,NV*NV+0.0]));
	{Add a "1" to the number string}
	NS:='1'+NS;
	end;
end;
Output:
 1 -          3^2 =                 9
 2 -         13^2 =               169
 3 -        113^2 =            12,769
 4 -       1113^2 =         1,238,769
 5 -      11113^2 =       123,498,769
 6 -     111113^2 =    12,346,098,769
 7 -    1111113^2 = 1,234,572,098,769
Elapsed Time: 8.668 ms.

EasyLang

n = 3
pre = 1
for i to 8
   print n & " " & pow n 2
   pre *= 10
   n += pre
.
Output:
3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
1111113 1234572098769
11111113 123456832098769

F#

[3L;13L;113L;1113L;11113L;111113L;1111113L;11111113L;111111113L]|>List.iter(fun n->printfn "%10d->%d" n (n*n))
Output:
         3->9
        13->169
       113->12769
      1113->1238769
     11113->123498769
    111113->12346098769
   1111113->1234572098769
  11111113->123456832098769
 111111113->12345679432098769

Factor

a(n) = ((10n+1 - 1) / 9 + 2)2

Works with: Factor version 0.99 2021-02-05
USING: io kernel math math.functions prettyprint ;

: a ( n -- e m ) 1 + 10^ 1 - 9 / 2 + dup sq ;

8 [ a swap pprint bl . ] each-integer
Output:
3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
1111113 1234572098769
11111113 123456832098769

Fermat

Func Make13(n) = m:=0; while n>0 do m:=10*(m+1);n:=n-1; od; m:=3+m; m.
for i=0 to 7 do !Make13(i);!'   ';!Make13(i)^2;!!'' od
Output:
3   9
13   169
113   12769
1113   1238769
11113   123498769
111113   12346098769
1111113   1234572098769
11111113   123456832098769

Forth

: 1s+3
    0 swap
    begin dup while
        swap 10 * 1+ swap 1-
    repeat
    drop 10 * 3 +
;

: sqr dup * ;
: show dup . ." ^2 = " sqr . cr ;

: show-upto
    0 swap
    begin over over < while
        swap dup 1s+3 show 1+ swap
    repeat
    2drop
;

8 show-upto
bye
Output:
3 ^2 = 9
13 ^2 = 169
113 ^2 = 12769
1113 ^2 = 1238769
11113 ^2 = 123498769
111113 ^2 = 12346098769
1111113 ^2 = 1234572098769
11111113 ^2 = 123456832098769

FreeBASIC

function make13(n as uinteger) as uinteger
    dim as uinteger t = 0
    while n
        t = 10*(t+1)
        n-=1
    wend
    return t+3
end function

dim as ulongint m

for n as uinteger = 0 to 7
    m = make13(n)^2
    print make13(n), m
next n
Output:
3             9
13            169
113           12769
1113          1238769
11113         123498769
111113        12346098769
1111113       1234572098769
11111113      123456832098769

Go

Translation of: Wren
package main

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

func a(n int) {
    s, _ := strconv.Atoi(strings.Repeat("1", n) + "3")
    t := s * s
    fmt.Printf("%d %d\n", s, t)
}

func main() {
    for n := 0; n <= 7; n++ {
        a(n)
    }
}
Output:
3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
1111113 1234572098769
11111113 123456832098769

Haskell

import Text.Printf (printf)

onesPlusThree :: [Integer]
onesPlusThree =
  (3 +) . (10 *)
    <$> iterate (succ . (10 *)) 0

format :: Integer -> String
format = printf "%8lu^2 = %15lu" <*> (^ 2)

main :: IO ()
main =
  (putStr . unlines . take 8) $
    format <$> onesPlusThree
Output:
       3^2 =               9
      13^2 =             169
     113^2 =           12769
    1113^2 =         1238769
   11113^2 =       123498769
  111113^2 =     12346098769
 1111113^2 =   1234572098769
11111113^2 = 123456832098769

J

   (,. *:) (9 %~ 17 + 10x ^ >:) i. 8
       3               9
      13             169
     113           12769
    1113         1238769
   11113       123498769
  111113     12346098769
 1111113   1234572098769
11111113 123456832098769

Java

public final class ShowTheDecimalValueOfANumberOf1sAppendedWithA3ThenSquared {

	public final static void main(String[] args) {
		for ( int i = 0; i < 8; i++ ) {
			final long value = Long.valueOf("1".repeat(i) + "3");
			System.out.println(String.format("%9s%s", value, " => " + value * value));
		}
	}
	
}
Output:
        3 => 9
       13 => 169
      113 => 12769
     1113 => 1238769
    11113 => 123498769
   111113 => 12346098769
  1111113 => 1234572098769
 11111113 => 123456832098769

JavaScript

'use strict'
let n = 0
for( let i = 1; i < 8; i ++ )
{
    let n3 = ( n * 10 ) + 3
    console.log( n3 + " " + ( n3 * n3 ) )
    n *= 10
    n += 1
}
Output:
3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
1111113 1234572098769

jq

Works with: jq

Works with gojq, the Go implementation of jq

For large values of n, the unbounded-precision integer arithmetic of gojq will ensure accuracy.

# For gojq
def power($b): . as $in | reduce range(0;$b) as $i (1; . * $in);

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

"  n    number            number^2",
(range(0;8) as $n
 | ((("1"*$n) + "3") | tonumber) as $number
 | ($n|lpad(3)) + ($number|lpad(10)) + ($number|power(2)|lpad(20)) )
Output:
  n    number            number^2
  0         3                   9
  1        13                 169
  2       113               12769
  3      1113             1238769
  4     11113           123498769
  5    111113         12346098769
  6   1111113       1234572098769
  7  11111113     123456832098769

For 100 <= n <= 105

Encoding "123456790" as "A", "987654320" as Z", and lastly "9876" as "N":

range(100; 106) as $n
| ((("1"*$n) + "3") | tonumber) as $number
| ($n|lpad(4)) + " "
 +  ($number|power(2)|tostring| gsub("123456790";"A") | gsub("987654320";"Z") | gsub("9876";"N") | lpad(40))
Output:
 100           AAAAAAAAAAA1654320ZZZZZZZZZZN9
 101         AAAAAAAAAAA127654320ZZZZZZZZZZN9
 102       AAAAAAAAAAA12387654320ZZZZZZZZZZN9
 103             AAAAAAAAAAA1234ZZZZZZZZZZZN9
 104           AAAAAAAAAAA123460ZZZZZZZZZZZN9
 105         AAAAAAAAAAA12345720ZZZZZZZZZZZN9

Julia

println("n  (10^(n+1) - 1) ÷ 9 + 2)       squared")
for n in 0:7
    println(rpad(n, 14), rpad((big"10"^(n+1) - 1) ÷ 9 + 2, 19), ((big"10"^(n+1) - 1) ÷ 9 + 2)^2)
end
Output:
n  (10^(n+1) - 1) ÷ 9 + 2)       squared
0             3                  9
1             13                 169
2             113                12769
3             1113               1238769
4             11113              123498769
5             111113             12346098769
6             1111113            1234572098769
7             11111113           123456832098769

K

{x,'x*x}2(-17+*)\8#10
Output:
(3 9
 13 169
 113 12769
 1113 1238769
 11113 123498769
 111113 12346098769
 1111113 1234572098769
 11111113 123456832098769)

Lua

do
    local n = 0
    for i = 1,8 do
        local n3 = ( n * 10 ) + 3
        io.write( n3, " ", n3 * n3, "\n" )
        n = ( n * 10 ) + 1
    end
end
Output:
3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
1111113 1234572098769
11111113 123456832098769

MAD

            NORMAL MODE IS INTEGER
            VECTOR VALUES FMT = $I8,7H **2 = ,I15*$            
            THROUGH LOOP, FOR I=0, 1, I.G.7
            N = 0
            THROUGH ONES, FOR J=1, 1, J.G.I
ONES        N = N*10 + 1
            N = N*10 + 3
LOOP        PRINT FORMAT FMT,N,N*N
            END OF PROGRAM
Output:
       3**2 =               9
      13**2 =             169
     113**2 =           12769
    1113**2 =         1238769
   11113**2 =       123498769
  111113**2 =     12346098769
 1111113**2 =   1234572098769
11111113**2 = 123456832098769

Mathematica / Wolfram Language

{#, #^2} & /@ 
  Table[FromDigits[PadLeft[{3}, n, 1]], {n, 9}] // TableForm
Output:

3 9 13 169 113 12769 1113 1238769 11113 123498769 111113 12346098769 1111113 1234572098769 11111113 123456832098769 111111113 12345679432098769

Miranda

main :: [sys_message]
main = [Stdout (lay (map row [0..8]))]

row :: num->[char]
row n = rjustify 10 (show i) ++ "^2 = " ++ rjustify 20 (show (i^2))
        where i = ones_three n

ones_three :: num->num
ones_three n = 3 + sum [10^p | p<-[1..n]]
Output:
         3^2 =                    9
        13^2 =                  169
       113^2 =                12769
      1113^2 =              1238769
     11113^2 =            123498769
    111113^2 =          12346098769
   1111113^2 =        1234572098769
  11111113^2 =      123456832098769
 111111113^2 =    12345679432098769

Nim

import strformat

iterator genNumbers(maxOnes: Natural): int =
  var ones = 0
  yield 3
  for _ in 1..maxOnes:
    ones = 10 * ones + 10
    yield ones + 3

for i in genNumbers(7):
  echo &"{i:8} {i*i:18}"
Output:
       3                  9
      13                169
     113              12769
    1113            1238769
   11113          123498769
  111113        12346098769
 1111113      1234572098769
11111113    123456832098769

Nu

Works with: Nushell version 0.96.1
generate {|x| {out: {x: $x 'x * x': ($x * $x)} next: ($x * 10 - 17)} } 3 | take 8

or

..7 | each {|n| let x = 10 ** ($n + 1) // 9 + 2; {x: $x 'x * x': ($x * $x) } }
Output:
╭───┬──────────┬─────────────────╮
│ # │    x     │      x * x      │
├───┼──────────┼─────────────────┤
│ 0 │        3 │               9 │
│ 1 │       13 │             169 │
│ 2 │      113 │           12769 │
│ 3 │     1113 │         1238769 │
│ 4 │    11113 │       123498769 │
│ 5 │   111113 │     12346098769 │
│ 6 │  1111113 │   1234572098769 │
│ 7 │ 11111113 │ 123456832098769 │
╰───┴──────────┴─────────────────╯

OCaml

let make13 n =
  truncate (10. ** float n) / 9 * 10 + 3

let () =
  for n = 0 to 7 do
    let x = make13 n in Printf.printf "%9u%16u\n" x (x * x)
  done
Output:
        3               9
       13             169
      113           12769
     1113         1238769
    11113       123498769
   111113     12346098769
  1111113   1234572098769
 11111113 123456832098769

PARI/GP

Make13(n)=m=0;while(n>0,m=10*(m+1);n=n-1);m=3+m;return(m)
for(i=0,7,print(Make13(i)," ",Make13(i)^2))
Output:
3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
1111113 1234572098769
11111113 123456832098769

Pascal

Free Pascal

like Phix using byte, and convert than to ASCII. Because the values are calculated one by one, one can use addition to get rid of calculating squares, by using binomial formula. The best is shown in Algol_68 that it ends in a cyclic pattern of lenght 9.

{
  10^pot+k -> prepend a 1  1113-> 11113
  (10^pot+k)^2 = 10^(2*pot)+ 2*10^pot*k + k^2
  (10^pot+k)^2 = 10^pot*(10^pot+2*k) + k^2
  s_lastsqr = k*k
  s_DeltaSqr = (10^pot+2*k) => 1222....2226
  shift s_DeltaSqr by pot digits in SumMyDeltaSqr =>  10^pot*(10^pot+2*k) 
}
program OnesAppend3AndSquare;
const
  MAX = 3700;
type
  tmyNumb = array of byte;
var
  res :AnsiString;

procedure OutMyNumb(const n: tmyNUmb;l,w: integer);
var
  i,ofs : integer;
begin
  l += 1;
  if w < l then
    w := l+1;
  setlength(res,w);
  fillchar(res[1],w,' ');
  ofs := w-l;
  For i := 1 to l do
    res[i+ofs] := chr(n[l-i]+48);
  write(res);
end;

procedure Out_k_sqr(const k,sqr_k: tmyNUmb;pot:integer);
var
  dgtcnt : integer;
Begin
  write(pot:4);
  dgtcnt := 22;
  if pot > 10 then
    dgtcnt := 78;
  OutMyNumb(k,pot,dgtcnt-4);
  if pot > 10 then
    writeln;
  OutMyNumb(sqr_k,2*pot,dgtcnt);
  writeln;
end;
procedure SumMyDeltaSqr(var res:tmyNUmb;const s:tmyNumb;pot: integer);
//res = s_lastsqr
//s = s_DeltaSqr
//shift s by l => (10^pot) * s_DeltaSqr = 10^pot*(10^pot+2*k)
var
  i,sum,carry : integer;
begin
  carry := 0;
  For i := 0 to pot+1 do
  begin
    sum :=  res[i+pot]+s[i]+carry;
    carry := ord(sum>9);
    sum -= (-carry) AND 10;
    res[i+pot] := sum;
  end;
end;

var
  s,s_DeltaSqr,s_lastsqr : tmyNumb;
  pot: integer;
Begin
   setlength(s,MAX);
   setlength(s_DeltaSqr,Max+1);
   setlength(s_lastsqr,2*Max+1);
   pot := 0;
   s[pot] := 3;
   s_lastsqr[pot] := 9;
   repeat
     SumMyDeltaSqr(s_lastsqr,s_DeltaSqr,pot);
     if pot < 10 then
       Out_k_sqr(s,s_lastsqr,pot);
     if pot = 37 then
       Out_k_sqr(s,s_lastsqr,pot);

     if pot > 0 then
       s_DeltaSqr[pot]:= 2 // =>2*s[i] 2222...26
     else
       s_DeltaSqr[0] := 6;// =>2*s[0]  6
     inc(pot);
     s_DeltaSqr[pot]:= 1; //1...6
     s[pot] := 1;
   until pot = MAX;
   Writeln('Finished til ',MAX);
end.
@TIO.RUN:
   0                 3                     9
   1                13                   169
   2               113                 12769
   3              1113               1238769
   4             11113             123498769
   5            111113           12346098769
   6           1111113         1234572098769
   7          11111113       123456832098769
   8         111111113     12345679432098769
   9        1111111113   1234567905432098769
  37                                    11111111111111111111111111111111111113
   123456790123456790123456790123456790165432098765432098765432098765432098769
Finished til 3700
      Real time: 0.106 s CPU share: 99.03 %
@home real     0m0.016s

Perl

#!/usr/bin/perl

use strict; # https://rosettacode.org/wiki/Show_the_(decimal)_value_of_a_number_of_1s_appended_with_a_3,_then_squared
use warnings;
#use bignum; # uncomment for larger than 9 or 32-bit perls

for ( 0 .. 7 )
  {
  my $number = 1 x $_ . 3;
  print "$number  ", $number ** 2, "\n";
  }
Output:
3  9
13  169
113  12769
1113  1238769
11113  123498769
111113  12346098769
1111113  1234572098769
11111113  123456832098769

Phix

Perfect opportunity for a little string math, why not... Switches to the shorthand notation of Algol68g/jq for n>=85.

with javascript_semantics
for n=0 to 113 do
    string res = repeat('3',n)&'9'
    for i=1 to n do
        res = "0" & res
        integer digit = 3
        for j=length(res)-i to 1 by -1 do
            digit += res[j]-'0'
            res[j] = remainder(digit,10)+'0'
            digit = floor(digit/10)+1
        end for
    end for
    if n<=37 then
        printf(1,"%38s %75s\n",{repeat('1',n)&'3',res})
    elsif n>=85 then
        res = substitute_all(res,{"123456790","987654320","9876"},{"A","Z","N"})
        printf(1,"%3d %36s\n",{n,res})
    end if
end for
Output:
                                     3                                                                           9
                                    13                                                                         169
                                   113                                                                       12769
                                  1113                                                                     1238769
                                 11113                                                                   123498769
                                111113                                                                 12346098769
                               1111113                                                               1234572098769
                              11111113                                                             123456832098769
                             111111113                                                           12345679432098769
                            1111111113                                                         1234567905432098769
                           11111111113                                                       123456790165432098769
                          111111111113                                                     12345679012765432098769
                         1111111111113                                                   1234567901238765432098769
                        11111111111113                                                 123456790123498765432098769
                       111111111111113                                               12345679012346098765432098769
                      1111111111111113                                             1234567901234572098765432098769
                     11111111111111113                                           123456790123456832098765432098769
                    111111111111111113                                         12345679012345679432098765432098769
                   1111111111111111113                                       1234567901234567905432098765432098769
                  11111111111111111113                                     123456790123456790165432098765432098769
                 111111111111111111113                                   12345679012345679012765432098765432098769
                1111111111111111111113                                 1234567901234567901238765432098765432098769
               11111111111111111111113                               123456790123456790123498765432098765432098769
              111111111111111111111113                             12345679012345679012346098765432098765432098769
             1111111111111111111111113                           1234567901234567901234572098765432098765432098769
            11111111111111111111111113                         123456790123456790123456832098765432098765432098769
           111111111111111111111111113                       12345679012345679012345679432098765432098765432098769
          1111111111111111111111111113                     1234567901234567901234567905432098765432098765432098769
         11111111111111111111111111113                   123456790123456790123456790165432098765432098765432098769
        111111111111111111111111111113                 12345679012345679012345679012765432098765432098765432098769
       1111111111111111111111111111113               1234567901234567901234567901238765432098765432098765432098769
      11111111111111111111111111111113             123456790123456790123456790123498765432098765432098765432098769
     111111111111111111111111111111113           12345679012345679012345679012346098765432098765432098765432098769
    1111111111111111111111111111111113         1234567901234567901234567901234572098765432098765432098765432098769
   11111111111111111111111111111111113       123456790123456790123456790123456832098765432098765432098765432098769
  111111111111111111111111111111111113     12345679012345679012345679012345679432098765432098765432098765432098769
 1111111111111111111111111111111111113   1234567901234567901234567901234567905432098765432098765432098765432098769
11111111111111111111111111111111111113 123456790123456790123456790123456790165432098765432098765432098765432098769
 85             AAAAAAAAA1234ZZZZZZZZZN9
 86           AAAAAAAAA123460ZZZZZZZZZN9
 87         AAAAAAAAA12345720ZZZZZZZZZN9
 88       AAAAAAAAA1234568320ZZZZZZZZZN9
 89     AAAAAAAAA123456794320ZZZZZZZZZN9
 90           AAAAAAAAAA54320ZZZZZZZZZN9
 91         AAAAAAAAAA1654320ZZZZZZZZZN9
 92       AAAAAAAAAA127654320ZZZZZZZZZN9
 93     AAAAAAAAAA12387654320ZZZZZZZZZN9
 94           AAAAAAAAAA1234ZZZZZZZZZZN9
 95         AAAAAAAAAA123460ZZZZZZZZZZN9
 96       AAAAAAAAAA12345720ZZZZZZZZZZN9
 97     AAAAAAAAAA1234568320ZZZZZZZZZZN9
 98   AAAAAAAAAA123456794320ZZZZZZZZZZN9
 99         AAAAAAAAAAA54320ZZZZZZZZZZN9
100       AAAAAAAAAAA1654320ZZZZZZZZZZN9
101     AAAAAAAAAAA127654320ZZZZZZZZZZN9
102   AAAAAAAAAAA12387654320ZZZZZZZZZZN9
103         AAAAAAAAAAA1234ZZZZZZZZZZZN9
104       AAAAAAAAAAA123460ZZZZZZZZZZZN9
105     AAAAAAAAAAA12345720ZZZZZZZZZZZN9
106   AAAAAAAAAAA1234568320ZZZZZZZZZZZN9
107 AAAAAAAAAAA123456794320ZZZZZZZZZZZN9
108       AAAAAAAAAAAA54320ZZZZZZZZZZZN9
109     AAAAAAAAAAAA1654320ZZZZZZZZZZZN9
110   AAAAAAAAAAAA127654320ZZZZZZZZZZZN9
111 AAAAAAAAAAAA12387654320ZZZZZZZZZZZN9
112       AAAAAAAAAAAA1234ZZZZZZZZZZZZN9
113     AAAAAAAAAAAA123460ZZZZZZZZZZZZN9

Plain English

Only 5 entries are shown due to Plain English's 32-bit signed integers.

To run:
Start up.
Put 0 into a counter.
Loop.
If the counter is greater than 4, break.
Put 10 into a number.
Raise the number to the counter plus 1.
Subtract 1 from the number.
Divide the number by 9.
Add 2 to the number.
Put the number into a squared number.
Raise the squared number to 2.
Write the number then " " then the squared number on the console.
Bump the counter.
Repeat.
Wait for the escape key.
Shut down.
Output:
3 9
13 169
113 12769
1113 1238769
11113 123498769

Python

One Liner

The most Pythonic way...

[print("( " + "1"*i + "3 ) ^ 2 = " + str(int("1"*i + "3")**2)) for i in range(0,8)]
Output:
( 3 ) ^ 2 = 9
( 13 ) ^ 2 = 169
( 113 ) ^ 2 = 12769
( 1113 ) ^ 2 = 1238769
( 11113 ) ^ 2 = 123498769
( 111113 ) ^ 2 = 12346098769
( 1111113 ) ^ 2 = 1234572098769
( 11111113 ) ^ 2 = 123456832098769

Procedural

#!/usr/bin/python

def make13(n):
    return 10 ** (n + 1) // 9 + 2

for n in map(make13, range(8)):
    print('%9d%16d' % (n, n * n))

Functional

Taking the first n terms from an infinite series:

'''Sequence of 1s appended with a 3, then squared'''

from itertools import islice


# seriesOfOnesEndingWithThree :: [Int]
def seriesOfOnesEndingWithThree():
    '''An ordered and non-finite stream of integers
       whose decimal digits end in 3, preceded only by a
       series of (zero or more) ones.
       (3, 13, 113, 1113 ...)
    '''
    def go(n):
        return lambda x: n + 10 * x

    return fmapGen(go(3))(
        iterate(go(1))(0)
    )


# showSquare :: (Int, Int, Int) -> String
def showSquare(ew, vw, n):
    '''A string representation of the square of n,
       both as an expression and as a value, with a
       right-justfied expression column of width ew,
       and a right-justified value column of width vw.
    '''
    return f'{str(n).rjust(ew)}^2 = {str(n ** 2).rjust(vw)}'


# ------------------------- TEST -------------------------
# main :: IO ()
def main():
    '''Listing of the first 7 values of the series.'''

    xs = take(7)(
        seriesOfOnesEndingWithThree()
    )

    final = xs[-1]
    w = len(str(final))
    w1 = len(str(final ** 2))
    print('\n'.join([
        showSquare(w, w1, x) for x in xs
    ]))


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

# fmapGen <$> :: (a -> b) -> Gen [a] -> Gen [b]
def fmapGen(f):
    '''A function f mapped over a
       non finite stream of values.
    '''
    def go(g):
        while True:
            v = next(g, None)
            if None is not v:
                yield f(v)
            else:
                return
    return go


# iterate :: (a -> a) -> a -> Gen [a]
def iterate(f):
    '''An infinite list of repeated
       applications of f to x.
    '''
    def go(x):
        v = x
        while True:
            yield v
            v = f(v)
    return go


# take :: Int -> [a] -> [a]
def take(n):
    '''The first n values of xs.
    '''
    return lambda xs: list(islice(xs, n))


# MAIN ---
if __name__ == '__main__':
    main()
Output:
      3^2 =             9
     13^2 =           169
    113^2 =         12769
   1113^2 =       1238769
  11113^2 =     123498769
 111113^2 =   12346098769
1111113^2 = 1234572098769

Quackery

 [ char 1 swap of
   char 3 join
   $->n drop ] is 1's+3 ( n -> n )

  8 times
    [ i^ 1's+3
      dup echo
      say " --> "
      dup * echo cr ]
Output:
3 --> 9
13 --> 169
113 --> 12769
1113 --> 1238769
11113 --> 123498769
111113 --> 12346098769
1111113 --> 1234572098769
11111113 --> 123456832098769

Raku

In an attempt to stave of terminal ennui, Find the first 8 where a(n) is semiprime.

say "$_, {.²}" for (^∞).map({ ( 1 x $_ ~ 3)} ).grep({ .is-prime })[^8]
Output:
3, 9
13, 169
113, 12769
11113, 123498769
111111113, 12345679432098769
11111111113, 123456790165432098769
111111111111111111111113, 12345679012345679012346098765432098765432098769
111111111111111111111111111111111111111111111111111111111111111111111111111111111113, 12345679012345679012345679012345679012345679012345679012345679012345679012345679012765432098765432098765432098765432098765432098765432098765432098765432098765432098769

Refal

$ENTRY Go {
    = <Each (DispOnes3) <Iota 0 7>>;
};

DispOnes3 {
    s.I, <Ones3 s.I>: e.Ones3,
         <* (e.Ones3) e.Ones3>: e.Square
       = <Prout <Rjust 10 e.Ones3> '^2 = ' <Rjust 20 e.Square>>;
};

Ones3 {
    s.N = <Ones3 (0) s.N>;
    (e.Acc) 0 = <+ (e.Acc) 3>;
    (e.Acc) s.N = <Ones3 (<* (<+ (e.Acc) 1>) 10>) <- s.N 1>>;
};

Repeat {
    0   s.I = ;
    s.N s.I = s.I <Repeat <- s.N 1> s.I>;
};

Rjust {
    s.N e.X,
        <Repeat s.N ' '>: e.Padding,
        <Symb e.X>: e.Num,
        <Last s.N e.Padding e.Num>: (e.Y) e.Disp = e.Disp;
};

Iota {
    s.End s.End = s.End;
    s.Start s.End = s.Start <Iota <+ 1 s.Start> s.End>;
};

Each {
    (e.F) = ;
    (e.F) s.I e.X = <Mu e.F s.I> <Each (e.F) e.X>;
};
Output:
         3^2 =                    9
        13^2 =                  169
       113^2 =                12769
      1113^2 =              1238769
     11113^2 =            123498769
    111113^2 =          12346098769
   1111113^2 =        1234572098769
  11111113^2 =      123456832098769

REXX

A little extra code was added to pre-compute the biggest number to find the widths for output alignment.

/*REXX program appends a  "3"  to a number of  "1"s,  and  then squares that number.    */
numeric digits 1000                              /*be able to handle huge numbers.      */
parse arg n .                                    /*obtain optional argument from the CL.*/
if n=='' | n==","  then n= 9                     /*Not specified?  Then use the default.*/
_= copies(1, n)3                                 /*compute largest index to get width.  */
w1= length( commas(_)    )                       /*get the width of the largest index.  */
w2= length( commas(_**2) )                       /* "   "    "    "  "     "    number. */

       do #=0  to n;  _=copies(1, #)3            /*calculate prefix number for output.  */
       say right( commas(_), w1)  right( commas(_**2), w2)       /*show prefix, number. */
       end   /*#*/
exit 0                                           /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
commas: parse arg ?;  do jc=length(?)-3  to 1  by -3; ?=insert(',', ?, jc); end;  return ?
output   when using the input of:     37

(Shown at three-quarter size.)

                                                 3                                                                                                   9
                                                13                                                                                                 169
                                               113                                                                                              12,769
                                             1,113                                                                                           1,238,769
                                            11,113                                                                                         123,498,769
                                           111,113                                                                                      12,346,098,769
                                         1,111,113                                                                                   1,234,572,098,769
                                        11,111,113                                                                                 123,456,832,098,769
                                       111,111,113                                                                              12,345,679,432,098,769
                                     1,111,111,113                                                                           1,234,567,905,432,098,769
                                    11,111,111,113                                                                         123,456,790,165,432,098,769
                                   111,111,111,113                                                                      12,345,679,012,765,432,098,769
                                 1,111,111,111,113                                                                   1,234,567,901,238,765,432,098,769
                                11,111,111,111,113                                                                 123,456,790,123,498,765,432,098,769
                               111,111,111,111,113                                                              12,345,679,012,346,098,765,432,098,769
                             1,111,111,111,111,113                                                           1,234,567,901,234,572,098,765,432,098,769
                            11,111,111,111,111,113                                                         123,456,790,123,456,832,098,765,432,098,769
                           111,111,111,111,111,113                                                      12,345,679,012,345,679,432,098,765,432,098,769
                         1,111,111,111,111,111,113                                                   1,234,567,901,234,567,905,432,098,765,432,098,769
                        11,111,111,111,111,111,113                                                 123,456,790,123,456,790,165,432,098,765,432,098,769
                       111,111,111,111,111,111,113                                              12,345,679,012,345,679,012,765,432,098,765,432,098,769
                     1,111,111,111,111,111,111,113                                           1,234,567,901,234,567,901,238,765,432,098,765,432,098,769
                    11,111,111,111,111,111,111,113                                         123,456,790,123,456,790,123,498,765,432,098,765,432,098,769
                   111,111,111,111,111,111,111,113                                      12,345,679,012,345,679,012,346,098,765,432,098,765,432,098,769
                 1,111,111,111,111,111,111,111,113                                   1,234,567,901,234,567,901,234,572,098,765,432,098,765,432,098,769
                11,111,111,111,111,111,111,111,113                                 123,456,790,123,456,790,123,456,832,098,765,432,098,765,432,098,769
               111,111,111,111,111,111,111,111,113                              12,345,679,012,345,679,012,345,679,432,098,765,432,098,765,432,098,769
             1,111,111,111,111,111,111,111,111,113                           1,234,567,901,234,567,901,234,567,905,432,098,765,432,098,765,432,098,769
            11,111,111,111,111,111,111,111,111,113                         123,456,790,123,456,790,123,456,790,165,432,098,765,432,098,765,432,098,769
           111,111,111,111,111,111,111,111,111,113                      12,345,679,012,345,679,012,345,679,012,765,432,098,765,432,098,765,432,098,769
         1,111,111,111,111,111,111,111,111,111,113                   1,234,567,901,234,567,901,234,567,901,238,765,432,098,765,432,098,765,432,098,769
        11,111,111,111,111,111,111,111,111,111,113                 123,456,790,123,456,790,123,456,790,123,498,765,432,098,765,432,098,765,432,098,769
       111,111,111,111,111,111,111,111,111,111,113              12,345,679,012,345,679,012,345,679,012,346,098,765,432,098,765,432,098,765,432,098,769
     1,111,111,111,111,111,111,111,111,111,111,113           1,234,567,901,234,567,901,234,567,901,234,572,098,765,432,098,765,432,098,765,432,098,769
    11,111,111,111,111,111,111,111,111,111,111,113         123,456,790,123,456,790,123,456,790,123,456,832,098,765,432,098,765,432,098,765,432,098,769
   111,111,111,111,111,111,111,111,111,111,111,113      12,345,679,012,345,679,012,345,679,012,345,679,432,098,765,432,098,765,432,098,765,432,098,769
 1,111,111,111,111,111,111,111,111,111,111,111,113   1,234,567,901,234,567,901,234,567,901,234,567,905,432,098,765,432,098,765,432,098,765,432,098,769
11,111,111,111,111,111,111,111,111,111,111,111,113 123,456,790,123,456,790,123,456,790,123,456,790,165,432,098,765,432,098,765,432,098,765,432,098,769

Ring

load "stdlib.ring"

decimals(0)

see "working..." + nl

row = 0
limit = 8

str = "3"
for n = 1 to limit
    if n = 1
       strn = number(str)
       res = pow(strn,2)
       see "{" + strn + "," + res + "}" + nl
    else
       str = "1" + strn
       strn = number(str)
       res = pow(strn,2)
       see "{" + strn + "," + res + "}" + nl
    ok
next

see "done..." + nl
Output:
working...
{3,9}
{13,169}
{113,12769}
{1113,1238769}
{11113,123498769}
{111113,12346098769}
{1111113,1234572098769}
{11111113,123456832098769}
done...

RPL

Works with: HP version 49
≪ { }
    0 7 FOR n
       10 n ^ 1 - 9 / 10 * 3 + SQ +
    NEXT
≫ 'TASK' STO
Output:
1: { 9 169 12769 1238769 123498769 12346098769 1234572098769 123456832098769 }

Ruby

m = 8
(0..m).each do |n|
  ones3 = "1"*n +"3"
  puts ones3.ljust(m+2) + ( ones3.to_i**2).to_s
end
Output:
3         9
13        169
113       12769
1113      1238769
11113     123498769
111113    12346098769
1111113   1234572098769
11111113  123456832098769
111111113 12345679432098769

Rust

fn main() {
   let mut big_squares : Vec<u64> = Vec::new( ) ;
   let mut numberstrings : Vec<String> = Vec::new( ) ;
   for n in 0..8 {
      let mut numberstring : String = String::new( ) ;
      for i in 0..=n {
         if  i != 0  {
            numberstring.push( '1' ) ;
         }
      }
      numberstring.push('3') ;
      let number : u64 = numberstring.parse::<u64>().unwrap( ) ;
      numberstrings.push( numberstring ) ;
      big_squares.push( number.pow( 2 )) ;
   }
   for i in 0..numberstrings.len( ) {
      print!("{} ^ 2 =" , numberstrings[ i ] ) ;
      let width = 30 - (7 + i )  ;
      println!("{:>width$}" , big_squares[ i ] ) ;
   }
}
Output:
3 ^ 2 =                      9
13 ^ 2 =                   169
113 ^ 2 =                12769
1113 ^ 2 =             1238769
11113 ^ 2 =          123498769
111113 ^ 2 =       12346098769
1111113 ^ 2 =    1234572098769
11111113 ^ 2 = 123456832098769

Seed7

$ include "seed7_05.s7i";

const proc: main is func
  local
    var integer: a is 0;
    var integer: n is 0;
  begin
    for n range 0 to 7 do
      a := (10 ** (n + 1) - 1) div 9 + 2;
      writeln(a <& " " <& a * a);
    end for;
  end func;
Output:
3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
1111113 1234572098769
11111113 123456832098769

SETL

program ones_appended_with_a_3_squared;
    loop for n in [0..7] do
        k := ones_three(n);
        print(lpad(str k, 10) + "^2 = " + lpad(str(k*k), 20));
    end loop;

    proc ones_three(n);
        return 3 +/ [10**p : p in [1..n]];
    end proc;
end program;
Output:
         3^2 =                    9
        13^2 =                  169
       113^2 =                12769
      1113^2 =              1238769
     11113^2 =            123498769
    111113^2 =          12346098769
   1111113^2 =        1234572098769
  11111113^2 =      123456832098769

Sidef

0..^8 -> each {|n|
    var k = ((10**(n+1) - 1)/9 + 2)
    say [k, k**2]
}
Output:
[3, 9]
[13, 169]
[113, 12769]
[1113, 1238769]
[11113, 123498769]
[111113, 12346098769]
[1111113, 1234572098769]
[11111113, 123456832098769]

Wren

Library: Wren-fmt
import "./fmt" for Fmt

var a = Fn.new { |n|
    var s = Num.fromString("1" * n + "3")
    var t = s * s
    Fmt.print("$d $d", s, t)
}

for (n in 0..7) a.call(n)
Output:
3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
1111113 1234572098769
11111113 123456832098769

XPL0

Only 32-bit integers are available, but the standard 64-bit floating point (real) provides 15 decimal digits.

int  N, M;
real X;
[Format(16, 0);
for N:= 0 to 8-1 do
        [X:= 0.;
        for M:= 0 to N-1 do
                X:= X*10. + 1.;
        X:= X*10. + 3.;
        RlOut(0, X);
        RlOut(0, X*X);
        CrLf(0);
        ];
]
Output:
               3               9
              13             169
             113           12769
            1113         1238769
           11113       123498769
          111113     12346098769
         1111113   1234572098769
        11111113 123456832098769
Cookies help us deliver our services. By using our services, you agree to our use of cookies.