Show the (decimal) value of a number of 1s appended with a 3, then squared: Difference between revisions
Show the (decimal) value of a number of 1s appended with a 3, then squared (view source)
Revision as of 15:48, 5 February 2024
, 4 months ago→{{header|Wren}}: Minor tidy
Not a robot (talk | contribs) (Add CLU) |
m (→{{header|Wren}}: Minor tidy) |
||
(27 intermediate revisions by 15 users not shown) | |||
Line 2:
;Task:
Show here (on this page) the decimal numbers formed by:
:: <big><big>(</big></big>'''n''' '''1''''s appended by the digit '''3'''<big><big>)</big></big> and then square the result, where <big> '''0 <= n < 8''' </big>
;See also
;* [[oeis:A151997]]
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">L(i) 0..7 {print(‘( ’(‘1’ * i)‘3 ) ^ 2 = ’(Int64((‘1’ * i)‘3’) ^ 2))}</syntaxhighlight>
{{out}}
<pre>
( 3 ) ^ 2 = 9
( 13 ) ^ 2 = 169
( 113 ) ^ 2 = 12769
( 1113 ) ^ 2 = 1238769
( 11113 ) ^ 2 = 123498769
( 111113 ) ^ 2 = 12346098769
( 1111113 ) ^ 2 = 1234572098769
( 11111113 ) ^ 2 = 123456832098769
</pre>
=={{header|Ada}}==
<
with Ada.Numerics.Big_Numbers.Big_Integers;
Line 27 ⟶ 46:
Root := @ + 10**(N + 1);
end loop;
end Ones_Plus_Three;</
{{out}}
<pre> 3 9
Line 41 ⟶ 60:
=={{header|ALGOL 68}}==
Assuming LONG INT is large enough (as in e.g. ALGOL 68G).
<
LONG INT n := 0;
FOR i TO 8 DO
Line 48 ⟶ 67:
n *:= 10 +:= 1
OD
END</
{{out}}
<pre>
Line 63 ⟶ 82:
Alternative version that shows the values for higher numbers of ones.
{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}
<
PR precision 250 PR
LONG LONG INT n := 0;
Line 72 ⟶ 91:
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 : ]
Line 84 ⟶ 103:
n *:= 10 +:= 1
OD
END</
{{out}}
Line 118 ⟶ 137:
111 AAAAAAAAAAAA12387654320ZZZZZZZZZZZ98769
</pre>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">loop 0..7 'x [
num: to :integer(repeat "1" x) ++ "3"
print [num num^2]
]</syntaxhighlight>
{{out}}
<pre>3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
1111113 1234572098769
11111113 123456832098769</pre>
=={{header|AWK}}==
<syntaxhighlight lang="awk">
BEGIN {
for (n
printf "%u %9u^2 %'20u\n", n, m, m * m
}
}
</syntaxhighlight>
{{out}}
<pre>
Line 147 ⟶ 175:
7 11111113^2 123,456,832,098,769
</pre>
=={{header|bc}}==
<syntaxhighlight lang="bc">x = 2
for (n = 0; n != 8; ++n) {
x = x * 10 - 17
x
" -> "
x * x
}</syntaxhighlight>
{{out}}
<pre>
3
-> 9
13
-> 169
113
-> 12769
1113
-> 1238769
11113
-> 123498769
111113
-> 12346098769
1111113
-> 1234572098769
11111113
-> 123456832098769
</pre>
=={{header|BQN}}==
<syntaxhighlight lang="bqn">≍˘⟜(ט) 2(¯17+×)` 8⥊10</syntaxhighlight>
{{out}}
<pre>┌─
╵ 3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
1111113 1234572098769
11111113 123456832098769
┘</pre>
=={{header|C}}==
<
#include <stdint.h>
Line 165 ⟶ 235:
}
return 0;
}</
{{out}}
<pre> 3^2 = 9
13^2 = 169
Line 181 ⟶ 249:
{{libheader|System.Numerics}}
For 0 <= n < 22
<
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); } }</
{{out}}
<pre> 9 3
Line 210 ⟶ 278:
=={{header|CLU}}==
<
r: int := 0
for i: int in int$from_to(1, n) do
Line 230 ⟶ 298:
stream$putl(po, "")
end
end start_up</
{{out}}
<pre> 3^2 = 9
Line 240 ⟶ 308:
1111113^2 = 1234572098769
11111113^2 = 123456832098769</pre>
=={{header|COBOL}}==
<syntaxhighlight lang="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.</syntaxhighlight>
{{out}}
<pre> 3^2 = 9
13^2 = 169
113^2 = 12769
1113^2 = 1238769
11113^2 = 123498769
111113^2 = 12346098769
1111113^2 = 1234572098769
11111113^2 = 123456832098769</pre>
=={{header|dc}}==
<syntaxhighlight lang="dc">2[10*17-p[ -> ]Pdd*pZ15>l]dslx</syntaxhighlight>
{{out}}
<pre>
3
-> 9
13
-> 169
113
-> 12769
1113
-> 1238769
11113
-> 123498769
111113
-> 12346098769
1111113
-> 1234572098769
11111113
-> 123456832098769
</pre>
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
<syntaxhighlight lang="Delphi">
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;
</syntaxhighlight>
{{out}}
<pre>
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.
</pre>
=={{header|F_Sharp|F#}}==
<
[3L;13L;113L;1113L;11113L;111113L;1111113L;11111113L;111111113L]|>List.iter(fun n->printfn "%10d->%d" n (n*n))
</syntaxhighlight>
{{out}}
<pre>
Line 261 ⟶ 430:
<big>{{math|a(<var>n</var>) = ((10<sup><var>n</var>+1</sup> - 1) / 9 + 2)<sup>2</sup> }}</big>
{{works with|Factor|0.99 2021-02-05}}
<
: a ( n -- e m ) 1 + 10^ 1 - 9 / 2 + dup sq ;
8 [ a swap pprint bl . ] each-integer</
{{out}}
<pre>
Line 279 ⟶ 448:
=={{header|Fermat}}==
<
for i=0 to 7 do !Make13(i);!' ';!Make13(i)^2;!!'' od</
{{out}}
<pre>
Line 291 ⟶ 460:
1111113 1234572098769
11111113 123456832098769
</pre>
=={{header|Forth}}==
<
0 swap
begin dup while
Line 333 ⟶ 474:
: show dup . ." ^2 = " sqr . cr ;
: show-upto
0 swap
begin over over < while
Line 342 ⟶ 483:
8 show-upto
bye</
{{out}}
<pre>3 ^2 = 9
13 ^2 = 169
Line 354 ⟶ 494:
1111113 ^2 = 1234572098769
11111113 ^2 = 123456832098769</pre>
=={{header|FreeBASIC}}==
<syntaxhighlight lang="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</syntaxhighlight>
{{out}}
<pre>
3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
1111113 1234572098769
11111113 123456832098769
</pre>
=={{header|Go}}==
{{trans|Wren}}
<
import (
Line 375 ⟶ 543:
a(n)
}
}</
{{out}}
Line 390 ⟶ 558:
=={{header|Haskell}}==
<
onesPlusThree :: [Integer]
Line 403 ⟶ 571:
main =
(putStr . unlines . take 8) $
format <$> onesPlusThree</
{{out}}
<pre> 3^2 = 9
13^2 = 169
Line 414 ⟶ 581:
1111113^2 = 1234572098769
11111113^2 = 123456832098769</pre>
=={{header|J}}==
<syntaxhighlight lang="j"> (,. *:) (9 %~ 17 + 10x ^ >:) i. 8
3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
1111113 1234572098769
11111113 123456832098769</syntaxhighlight>
=={{header|JavaScript}}==
<syntaxhighlight lang="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
}
</syntaxhighlight>
{{out}}
<pre>
3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
1111113 1234572098769
</pre>
=={{header|jq}}==
Line 420 ⟶ 621:
For large values of n, the unbounded-precision integer arithmetic of gojq will ensure accuracy.
<syntaxhighlight lang="jq">
# For gojq
def power($b): . as $in | reduce range(0;$b) as $i (1; . * $in);
Line 430 ⟶ 631:
(range(0;8) as $n
| ((("1"*$n) + "3") | tonumber) as $number
| ($n|lpad(3)) + ($number|lpad(10)) + ($number|power(2)|lpad(20)) )</
{{out}}
<pre>
Line 445 ⟶ 646:
'''For 100 <= n <= 105'''
Encoding "123456790" as "A", "987654320" as Z", and lastly "9876" 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))
</syntaxhighlight>
{{out}}
<pre>
Line 462 ⟶ 663:
=={{header|Julia}}==
<
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
</
<pre>
n (10^(n+1) - 1) ÷ 9 + 2) squared
Line 477 ⟶ 678:
6 1111113 1234572098769
7 11111113 123456832098769
</pre>
=={{header|K}}==
<syntaxhighlight lang="k">{x,'x*x}2(-17+*)\8#10</syntaxhighlight>
{{out}}
<pre>(3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
1111113 1234572098769
11111113 123456832098769)</pre>
=={{header|Lua}}==
<syntaxhighlight lang="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</syntaxhighlight>
{{out}}
<pre>
3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
1111113 1234572098769
11111113 123456832098769
</pre>
=={{header|MAD}}==
<syntaxhighlight lang="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</syntaxhighlight>
{{out}}
<pre> 3**2 = 9
13**2 = 169
113**2 = 12769
1113**2 = 1238769
11113**2 = 123498769
111113**2 = 12346098769
1111113**2 = 1234572098769
11111113**2 = 123456832098769</pre>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">{#, #^2} & /@
Table[FromDigits[PadLeft[{3}, n, 1]], {n, 9}] // TableForm</syntaxhighlight>
{{out}}<pre>
3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
1111113 1234572098769
11111113 123456832098769
111111113 12345679432098769
</pre>
=={{header|Nim}}==
<
iterator genNumbers(maxOnes: Natural): int =
Line 490 ⟶ 761:
for i in genNumbers(7):
echo &"{i:8} {i*i:18}"</
{{out}}
Line 501 ⟶ 772:
1111113 1234572098769
11111113 123456832098769</pre>
=={{header|OCaml}}==
<syntaxhighlight lang="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</syntaxhighlight>
{{out}}
<pre> 3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
1111113 1234572098769
11111113 123456832098769</pre>
=={{header|PARI/GP}}==
<syntaxhighlight lang="parigp">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))</syntaxhighlight>
{{out}}
<pre>3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
1111113 1234572098769
11111113 123456832098769
</pre>
=={{header|Pascal}}==
==={{header|Free Pascal}}===
like [[Show_the_(decimal)_value_of_a_number_of_1s_appended_with_a_3,_then_squared#Phix|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 [[Show_the_(decimal)_value_of_a_number_of_1s_appended_with_a_3,_then_squared#ALGOL_68|Algol_68]] that it ends in a cyclic pattern of lenght 9.
<syntaxhighlight lang="pascal">{
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.
</syntaxhighlight>
{{out|@TIO.RUN}}
<pre>
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
</pre>
=={{header|Perl}}==
<syntaxhighlight lang="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";
}</syntaxhighlight>
{{out}}
<pre>
3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
1111113 1234572098769
11111113 123456832098769
</pre>
=={{header|Phix}}==
Perfect opportunity for a little string math, why not...
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">for</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">to</span> <span style="color: #000000;">37</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">'3'</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)&</span><span style="color: #008000;">'9'</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">n</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"0"</span> <span style="color: #0000FF;">&</span> <span style="color: #000000;">res</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">digit</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">3</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)-</span><span style="color: #000000;">i</span> <span style="color: #008080;">to</span> <span style="color: #000000;">1</span> <span style="color: #008080;">by</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">1</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">digit</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]-</span><span style="color: #008000;">'0'</span>
<span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #000000;">digit</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)+</span><span style="color: #008000;">'0'</span>
<span style="color: #000000;">digit</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">digit</span><span style="color: #0000FF;">/</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)+</span><span style="color: #000000;">1</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%38s %75s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">'1'</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)&</span><span style="color: #008000;">'3'</span><span style="color: #0000FF;">,</span><span style="color: #000000;">res</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
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
</pre>
=={{header|Plain English}}==
Only 5 entries are shown due to Plain English's 32-bit signed integers.
<
Start up.
Put 0 into a counter.
Line 520 ⟶ 1,020:
Repeat.
Wait for the escape key.
Shut down.</
{{out}}
<pre>
Line 532 ⟶ 1,032:
=={{header|Python}}==
===One Liner===
The most Pythonic way
<syntaxhighlight lang="python">
[print("( " + "1"*i + "3 ) ^ 2 = " + str(int("1"*i + "3")**2)) for i in range(0,8)]
</syntaxhighlight>
{{out}}
<pre>
Line 547 ⟶ 1,047:
( 11111113 ) ^ 2 = 123456832098769
</pre>
===Procedural===
<syntaxhighlight lang="python">#!/usr/bin/python
def make13(n):
return 10 ** (n + 1) // 9 + 2
for n in
print('%9d%16d' % (n, n * n))</syntaxhighlight>
===Functional===
Taking the first n terms from an infinite series:
<
from itertools import islice
Line 651 ⟶ 1,145:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre> 3^2 = 9
Line 662 ⟶ 1,156:
=={{header|Quackery}}==
<syntaxhighlight lang="quackery"> [ char 1 swap of
$->n drop ] is 1's+3 ( n -> n )
8 times
[ i^ 1's+3
dup echo
say " --> "
dup * echo cr ]</
{{out}}
<pre>3 --> 9
13 --> 169
Line 683 ⟶ 1,175:
1111113 --> 1234572098769
11111113 --> 123456832098769</pre>
=={{header|Raku}}==
In an attempt to stave of terminal ennui, Find the first 8 where a(n) is semiprime.
<syntaxhighlight lang="raku" line>say "$_, {.²}" for (^∞).map({ ( 1 x $_ ~ 3)} ).grep({ .is-prime })[^8]</syntaxhighlight>
{{out}}
<pre>3, 9
Line 797 ⟶ 1,191:
=={{header|REXX}}==
A little extra code was added to pre-compute the biggest number to find the widths for output alignment.
<
numeric digits 1000 /*be able to handle huge numbers. */
parse arg n . /*obtain optional argument from the CL.*/
Line 810 ⟶ 1,204:
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 ?</
{{out|output|text= when using the input of: <tt> 37 </tt>}}
Line 856 ⟶ 1,250:
=={{header|Ring}}==
<
load "stdlib.ring"
Line 869 ⟶ 1,263:
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
</syntaxhighlight>
{{out}}
<pre>
Line 894 ⟶ 1,288:
{11111113,123456832098769}
done...
</pre>
=={{header|RPL}}==
{{works with|HP|49}}
≪ { }
0 7 '''FOR''' n
10 n ^ 1 - 9 / 10 * 3 + SQ +
'''NEXT'''
≫ '<span style="color:blue">TASK</span>' STO
{{out}}
<pre>
1: { 9 169 12769 1238769 123498769 12346098769 1234572098769 123456832098769 }
</pre>
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">m = 8
(0..m).each do |n|
ones3 = "1"*n +"3"
puts ones3.ljust(m+2) + ( ones3.to_i**2).to_s
end</syntaxhighlight>
{{out}}
<pre>3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
1111113 1234572098769
11111113 123456832098769
111111113 12345679432098769
</pre>
=={{header|Rust}}==
<syntaxhighlight lang="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 ] ) ;
}
}</syntaxhighlight>
{{out}}
<pre>
3 ^ 2 = 9
13 ^ 2 = 169
113 ^ 2 = 12769
1113 ^ 2 = 1238769
11113 ^ 2 = 123498769
111113 ^ 2 = 12346098769
1111113 ^ 2 = 1234572098769
11111113 ^ 2 = 123456832098769
</pre>
=={{header|Seed7}}==
<
const proc: main is func
Line 908 ⟶ 1,367:
writeln(a <& " " <& a * a);
end for;
end func;</
{{out}}
<pre>
Line 922 ⟶ 1,381:
=={{header|Sidef}}==
<
var k = ((10**(n+1) - 1)/9 + 2)
say [k, k**2]
}</
{{out}}
<pre>
Line 940 ⟶ 1,399:
=={{header|Wren}}==
{{libheader|Wren-fmt}}
<
var a = Fn.new { |n|
Line 948 ⟶ 1,407:
}
for (n in 0..7) a.call(n)</
{{out}}
Line 964 ⟶ 1,423:
=={{header|XPL0}}==
Only 32-bit integers are available, but the standard 64-bit floating point (real) provides 15 decimal digits.
<
real X;
[Format(16, 0);
Line 976 ⟶ 1,435:
CrLf(0);
];
]</
{{out}}
|