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

 

;Task:

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

 

=={{header|11l}}==

{{trans|Python}}

 

{{out}}

 

=={{header|Ada}}==

with Ada.Numerics.Big_Numbers.Big_Integers;

 

Root := @ + 10**(N + 1);

end loop;

{{out}}

<pre> 3 9

=={{header|ALGOL 68}}==

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

LONG INT n := 0;

FOR i TO 8 DO

n *:= 10 +:= 1

OD

{{out}}

<pre>

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;

INT pos := 0;

STRING pattern := "123456790";

WHILE string in string( pattern, pos, v ) DO

v := v[ 1 : pos - 1 ] + "A" + v[ pos + p len : ]

n *:= 10 +:= 1

OD

 

{{out}}

111 AAAAAAAAAAAA12387654320ZZZZZZZZZZZ98769

</pre>

=={{header|AWK}}==

BEGIN {

}

}

{{out}}

<pre>

7 11111113^2 123,456,832,098,769

</pre>

 

=={{header|C}}==

#include <stdint.h>

 

}

return 0;

{{out}}

<pre> 3^2 = 9

13^2 = 169

{{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)

{{out}}

<pre> 9 3

 

=={{header|CLU}}==

r: int := 0

for i: int in int$from_to(1, n) do

stream$putl(po, "")

end

{{out}}

<pre> 3^2 = 9

 

=={{header|COBOL}}==

PROGRAM-ID. ONES-THREE-SQUARED.

 

ADD-ONE.

MULTIPLY 10 BY ONES-3.

{{out}}

<pre> 3^2 = 9

1111113^2 = 1234572098769

11111113^2 = 123456832098769</pre>

 

=={{header|F_Sharp|F#}}==

[3L;13L;113L;1113L;11113L;111113L;1111113L;11111113L;111111113L]|>List.iter(fun n->printfn "%10d->%d" n (n*n))

{{out}}

<pre>

<big>{{math|a(<var>n</var>) &#61; ((10^{<var>n</var>+1} - 1) / 9 + 2)² }}</big>

{{works with|Factor|0.99 2021-02-05}}

 

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

 

{{out}}

<pre>

 

=={{header|Fermat}}==

{{out}}

<pre>

1111113 1234572098769

11111113 123456832098769

</pre>

 

=={{header|Forth}}==

0 swap

begin dup while

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

 

0 swap

begin over over < while

 

8 show-upto

 

{{out}}

<pre>3 ^2 = 9

13 ^2 = 169

1111113 ^2 = 1234572098769

11111113 ^2 = 123456832098769</pre>

 

=={{header|Go}}==

{{trans|Wren}}

 

import (

a(n)

}

 

{{out}}

 

=={{header|Haskell}}==

 

onesPlusThree :: [Integer]

main =

(putStr . unlines . take 8) $

{{out}}

<pre> 3^2 = 9

13^2 = 169

1111113^2 = 1234572098769

11111113^2 = 123456832098769</pre>

 

=={{header|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);

(range(0;8) as $n

| ((("1"*$n) + "3") | tonumber) as $number

{{out}}

<pre>

'''For 100 <= n <= 105'''

 

| ((("1"*$n) + "3") | tonumber) as $number

| ($n|lpad(4)) + " "

+ ($number|power(2)|tostring| gsub("123456790";"A") | gsub("987654320";"Z") | gsub("9876";"N") | lpad(40))

{{out}}

<pre>

 

=={{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

7 11111113 123456832098769

</pre>

=={{header|MAD}}==

VECTOR VALUES FMT = $I8,7H **2 = ,I15*$

THROUGH LOOP, FOR I=0, 1, I.G.7

N = N*10 + 3

LOOP PRINT FORMAT FMT,N,N*N

{{out}}

<pre> 3**2 = 9

11111113**2 = 123456832098769</pre>

 

 

{{out}}<pre>

 

=={{header|Nim}}==

 

iterator genNumbers(maxOnes: Natural): int =

 

for i in genNumbers(7):

 

{{out}}

1111113 1234572098769

11111113 123456832098769</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.

Repeat.

Wait for the escape key.

{{out}}

<pre>

=={{header|Python}}==

===One Liner===

[print("( " + "1"*i + "3 ) ^ 2 = " + str(int("1"*i + "3")**2)) for i in range(0,8)]

{{out}}

<pre>

( 11111113 ) ^ 2 = 123456832098769

</pre>

===Procedural===

 

def make13(n):

 

 

===Functional===

Taking the first n terms from an infinite series:

 

from itertools import islice

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre> 3^2 = 9

 

=={{header|Quackery}}==

$->n drop ] is 1's+3 ( n -> n )

 

8 times

 

{{out}}

<pre>3 --> 9

13 --> 169

1111113 --> 1234572098769

11111113 --> 123456832098769</pre>

 

=={{header|Raku}}==

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

{{out}}

<pre>3, 9

=={{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.*/

exit 0 /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> 37 </tt>}}

 

 

=={{header|Ring}}==

load "stdlib.ring"

 

for n = 1 to limit

if n = 1

res = pow(strn,2)

see "{" + strn + "," + res + "}" + nl

else

str = "1" + strn

res = pow(strn,2)

see "{" + strn + "," + res + "}" + nl

next

 

see "done..." + nl

{{out}}

<pre>

{11111113,123456832098769}

done...

</pre>

 

=={{header|Seed7}}==

 

const proc: main is func

writeln(a <& " " <& a * a);

end for;

{{out}}

<pre>

 

=={{header|Sidef}}==

var k = ((10**(n+1) - 1)/9 + 2)

say [k, k**2]

{{out}}

<pre>

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

var a = Fn.new { |n|

}

 

 

{{out}}

=={{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);

CrLf(0);

];

 

{{out}}