Rosetta Code

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

Page Discussion

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

20,344 bytes added ,  3 months ago
m
→‎{{header|Wren}}: Minor tidy
m (→‎{{header|Wren}}: Minor tidy)
 
(44 intermediate revisions by 25 users not shown)
Line 2:
 
;Task:
Show here (on this page) the decimal numbers formed by:
:: <big><big>(</big></big>'''n''' &nbsp; '''1''''s &nbsp; appended by the digit &nbsp; '''3'''<big><big>)</big></big> &nbsp; and then square the result, &nbsp; &nbsp; where &nbsp; <big> '''0 &nbsp; <= &nbsp; n &nbsp; < &nbsp; 8''' </big>
 
<br><br>
;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}}==
<langsyntaxhighlight Adalang="ada">with Ada.Text_Io;
with Ada.Numerics.Big_Numbers.Big_Integers;
 
Line 27 ⟶ 46:
Root := @ + 10**(N + 1);
end loop;
end Ones_Plus_Three;</langsyntaxhighlight>
{{out}}
<pre> 3 9
Line 41 ⟶ 60:
=={{header|ALGOL 68}}==
Assuming LONG INT is large enough (as in e.g. ALGOL 68G).
<langsyntaxhighlight lang="algol68">BEGIN
LONG INT n := 0;
FOR i TO 8 DO
Line 48 ⟶ 67:
n *:= 10 +:= 1
OD
END</langsyntaxhighlight>
{{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}}
<langsyntaxhighlight lang="algol68">BEGIN
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</langsyntaxhighlight>
 
{{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">
<lang AWK>
# syntax: GAWK -f SHOW_THE_DECIMAL_VALUE_OF_A_NUMBER_OF_1S_APPENDED_WITH_A_3_THEN_SQUARED.AWK
# converted from FreeBASIC
BEGIN {
form (i=0; i<=7; i++) {2
for (n m= 0; n != make13(i8; ++n) {
printf("%1d %9s^2 %'20d\n",i,m, = m *m) 10 - 17
printf "%u %9u^2 %'20u\n", n, m, m * m
}
exit(0)
}
</syntaxhighlight>
function make13(n, t) {
while (n--) {
t = 10 * (t+1)
}
return(t+3)
}
</lang>
{{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}}==
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <stdint.h>
 
Line 165 ⟶ 235:
}
return 0;
}</langsyntaxhighlight>
 
{{out}}
 
<pre> 3^2 = 9
13^2 = 169
Line 181 ⟶ 249:
{{libheader|System.Numerics}}
For 0 <= n < 22
<langsyntaxhighlight lang="csharp">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); } }</langsyntaxhighlight>
{{out}}
<pre> 9 3
Line 208 ⟶ 276:
12345679012345679012765432098765432098769 111111111111111111113
1234567901234567901238765432098765432098769 1111111111111111111113</pre>
 
=={{header|CLU}}==
<syntaxhighlight lang="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</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|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#}}==
<langsyntaxhighlight lang="fsharp">
[3L;13L;113L;1113L;11113L;111113L;1111113L;11111113L;111111113L]|>List.iter(fun n->printfn "%10d->%d" n (n*n))
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 225 ⟶ 426:
111111113->12345679432098769
</pre>
 
=={{header|Factor}}==
<big>{{math|a(<var>n</var>) &#61; ((10<sup><var>n</var>+1</sup> - 1) / 9 + 2)<sup>2</sup> }}</big>
{{works with|Factor|0.99 2021-02-05}}
<langsyntaxhighlight lang="factor">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</langsyntaxhighlight>
{{out}}
<pre>
Line 246 ⟶ 448:
 
=={{header|Fermat}}==
<langsyntaxhighlight lang="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</langsyntaxhighlight>
{{out}}
<pre>
Line 259 ⟶ 461:
11111113 123456832098769
</pre>
 
=={{header|Forth}}==
<syntaxhighlight lang="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</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|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">function make13(n as uinteger) as uinteger
dim as uinteger t = 0
while n
Line 275 ⟶ 510:
m = make13(n)^2
print make13(n), m
next n</langsyntaxhighlight>
{{out}}
<pre>
Line 288 ⟶ 523:
</pre>
 
=={{header|ForthGo}}==
{{trans|Wren}}
<lang forth>: 1s+3
<syntaxhighlight lang="go">package main
0 swap
begin dup while
swap 10 * 1+ swap 1-
repeat
drop 10 * 3 +
;
 
import (
: sqr dup * ;
"fmt"
: show dup . ." ^2 = " sqr . cr ;
"strconv"
"strings"
)
 
func a(n int) {
: show-upto
s, _ := strconv.Atoi(strings.Repeat("1", n) + "3")
0 swap
begint over:= overs <* whiles
fmt.Printf("%d %d\n", s, t)
swap dup 1s+3 show 1+ swap
}
repeat
2drop
;
 
func main() {
8 show-upto
for n := 0; n <= 7; n++ {
bye</lang>
a(n)
}
}</syntaxhighlight>
 
{{out}}
<pre>
 
<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>
</pre>
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Text.Printf (printf)
 
onesPlusThree :: [Integer]
onesPlusThree =
map ((3 +) . (10 *)) $
<$> iterate ((1 +)succ . (10 *)) 0
 
format :: Integer -> String
Line 334 ⟶ 569:
 
main :: IO ()
main =
main = putStr $ unlines $ take 8 $ map format onesPlusThree</lang>
(putStr . unlines . take 8) $
 
format <$> onesPlusThree</syntaxhighlight>
{{out}}
 
<pre> 3^2 = 9
13^2 = 169
Line 346 ⟶ 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}}==
{{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.
<syntaxhighlight lang="jq">
# 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)) )</syntaxhighlight>
{{out}}
<pre>
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
</pre>
'''For 100 <= n <= 105'''
 
Encoding "123456790" as "A", "987654320" as Z", and lastly "9876" as "N":
<syntaxhighlight lang="jq">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))
</syntaxhighlight>
{{out}}
<pre>
100 AAAAAAAAAAA1654320ZZZZZZZZZZN9
101 AAAAAAAAAAA127654320ZZZZZZZZZZN9
102 AAAAAAAAAAA12387654320ZZZZZZZZZZN9
103 AAAAAAAAAAA1234ZZZZZZZZZZZN9
104 AAAAAAAAAAA123460ZZZZZZZZZZZN9
105 AAAAAAAAAAA12345720ZZZZZZZZZZZN9
</pre>
 
=={{header|Julia}}==
<langsyntaxhighlight lang="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
</langsyntaxhighlight>{{out}}
<pre>
n (10^(n+1) - 1) ÷ 9 + 2) squared
Line 364 ⟶ 679:
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}}==
<syntaxhighlight lang="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}"</syntaxhighlight>
 
{{out}}
<pre> 3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
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}}==
<langsyntaxhighlight 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))</langsyntaxhighlight>
{{out}}
<pre>3 9
Line 377 ⟶ 803:
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}}==
<langsyntaxhighlight 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
Line 390 ⟶ 930:
my $number = 1 x $_ . 3;
print "$number ", $number ** 2, "\n";
}</langsyntaxhighlight>
{{out}}
<pre>
Line 405 ⟶ 945:
=={{header|Phix}}==
Perfect opportunity for a little string math, why not...
<!--<langsyntaxhighlight Phixlang="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>
Line 419 ⟶ 959:
<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>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 461 ⟶ 1,001:
11111111111111111111111111111111111113 123456790123456790123456790123456790165432098765432098765432098765432098769
</pre>
 
=={{header|Plain English}}==
Only 5 entries are shown due to Plain English's 32-bit signed integers.
<syntaxhighlight lang="plain english">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.</syntaxhighlight>
{{out}}
<pre>
3 9
13 169
113 12769
1113 1238769
11113 123498769
</pre>
 
=={{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>
( 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>
 
===Procedural===
<syntaxhighlight lang="python">#!/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))</syntaxhighlight>
 
===Functional===
Taking the first n terms from an infinite series:
<syntaxhighlight lang="python">'''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()</syntaxhighlight>
{{Out}}
<pre> 3^2 = 9
13^2 = 169
113^2 = 12769
1113^2 = 1238769
11113^2 = 123498769
111113^2 = 12346098769
1111113^2 = 1234572098769</pre>
 
=={{header|Quackery}}==
<syntaxhighlight lang="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 ]</syntaxhighlight>
 
{{out}}
<pre>3 --> 9
13 --> 169
113 --> 12769
1113 --> 1238769
11113 --> 123498769
111113 --> 12346098769
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>
 
<lang perl6>say "$_, {.²}" for (^∞).map({ ( 1 x $_ ~ 3)} ).grep({ .is-prime })[^8]</lang>
{{out}}
<pre>3, 9
Line 478 ⟶ 1,191:
=={{header|REXX}}==
A little extra code was added to pre-compute the biggest number to find the widths for output alignment.
<langsyntaxhighlight lang="rexx">/*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.*/
Line 491 ⟶ 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 ?</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> 37 </tt>}}
 
Line 537 ⟶ 1,250:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
 
Line 550 ⟶ 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>
</lang>
{{out}}
<pre>
Line 575 ⟶ 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}}==
<syntaxhighlight lang="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;</syntaxhighlight>
{{out}}
<pre>
3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
1111113 1234572098769
11111113 123456832098769
</pre>
 
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">0..^8 -> each {|n|
var k = ((10**(n+1) - 1)/9 + 2)
say [k, k**2]
}</syntaxhighlight>
{{out}}
<pre>
[3, 9]
[13, 169]
[113, 12769]
[1113, 1238769]
[11113, 123498769]
[111113, 12346098769]
[1111113, 1234572098769]
[11111113, 123456832098769]
</pre>
 
=={{header|Wren}}==
{{libheader|Wren-fmt}}
<langsyntaxhighlight ecmascriptlang="wren">import "./fmt" for Fmt
 
var a = Fn.new { |n|
Line 587 ⟶ 1,407:
}
 
for (n in 0..7) a.call(n)</langsyntaxhighlight>
 
{{out}}
Line 599 ⟶ 1,419:
1111113 1234572098769
11111113 123456832098769
</pre>
 
=={{header|XPL0}}==
Only 32-bit integers are available, but the standard 64-bit floating point (real) provides 15 decimal digits.
<syntaxhighlight lang="xpl0">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);
];
]</syntaxhighlight>
 
{{out}}
<pre>
3 9
13 169
113 12769
1113 1238769
11113 123498769
111113 12346098769
1111113 1234572098769
11111113 123456832098769
</pre>
PureFox
9,479

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/311025...354730"