I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

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

From Rosetta Code
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



Ada[edit]

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[edit]

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

BEGIN
LONG INT n := 0;
FOR i 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

C[edit]

#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#[edit]

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

F#[edit]

 
[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[edit]

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[edit]

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

FreeBASIC[edit]

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

Forth[edit]

: 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

Haskell[edit]

import Text.Printf
import Control.Monad
 
ones_plus_three :: [Integer]
ones_plus_three = map ((3+).(10*)) $ iterate ((1+).(10*)) 0
 
format :: Integer -> String
format = printf "%8lu^2 = %15lu" `ap` (^2)
 
main :: IO ()
main = putStr $ unlines $ take 8 $ map format $ ones_plus_three
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

Julia[edit]

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

PARI/GP[edit]

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

Phix[edit]

Perfect opportunity for a little string math, why not...

for n=0 to 37 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
    printf(1,"%38s %75s\n",{repeat('1',n)&'3',res})
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

Raku[edit]

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

REXX[edit]

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[edit]

 
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...

Wren[edit]

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