Smallest numbers: Difference between revisions

Line 8:

<~~lang~~ 11l>V numLimit = 51

<syntaxhighlight lang="11l">V numLimit = 51

[Int = Int] resultSet

Line 24:

L(i) sorted(resultSet.keys())

print(resultSet[i], end' ‘ ’)</~~lang~~>

print(resultSet[i], end' ‘ ’)</syntaxhighlight>

Line 34:

Uses ALGOL 68G's LONG LONG INT which provides large integers (the default precision is sufficient for the task). Also uses the ALGOL 68G string in string procedure.

<~~lang~~ algol68>BEGIN # find the smallest k such that the decimal representation of k^k contains n for 0 <= n <= 50 #

<syntaxhighlight lang="algol68">BEGIN # find the smallest k such that the decimal representation of k^k contains n for 0 <= n <= 50 #

# start with powers up to 20^20, if this proves insufficient, the kk array will be extended #

FLEX[ 1 : 20 ]STRING kk;

Line 60:

IF i MOD 10 = 9 THEN print( ( newline ) ) FI

OD

END</~~lang~~>

END</syntaxhighlight>

<pre>

Line 72:

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

<~~lang~~ fsharp>

// Smallest number: Nigel Galloway. April 13th., 2021

let rec fG n g=match bigint.DivRem(n,if g<10 then 10I else 100I) with (_,n) when (int n)=g->true |(n,_) when n=0I->false |(n,_)->fG n g

{0..50}|>Seq.iter(fun g->printf "%d " (1+({1..0x0FFFFFFF}|>Seq.map(fun n->(bigint n)**n)|>Seq.findIndex(fun n->fG n g)))); printfn ""

</syntaxhighlight>

</lang>

<pre>

Line 84:

=={{header|Factor}}==

<~~lang~~ factor>USING: formatting grouping io kernel lists lists.lazy

<syntaxhighlight lang="factor">USING: formatting grouping io kernel lists lists.lazy

math.functions present sequences ;

Line 91:

51 <iota> [ smallest ] map 10 group

[ [ "%3d" printf ] each nl ] each</~~lang~~>

[ [ "%3d" printf ] each nl ] each</syntaxhighlight>

<pre>

Line 104:

=={{header|FreeBASIC}}==

Reuses some code from [[Arbitrary-precision_integers_(included)#FreeBASIC]].

<~~lang~~ freebasic>#Include once "gmp.bi"

<syntaxhighlight lang="freebasic">#Include once "gmp.bi"

Dim Shared As Zstring * 100000000 outtext

Line 138:

loop until is_substring( Power(str(k), k), str(i) )

print k;" ";

next i</~~lang~~>

next i</syntaxhighlight>

{{out}}<pre> 9 1 3 5 2 4 4 3 7 9 10 11 5 19 22 26 8 17 16 19 9 8 13 7 17 4 17 3 11 18 13 5 23 17 18 7 17 15 9 18 16 17 9 7 12 28 6 23 9 24 23</pre>

=={{header|Go}}==

<~~lang~~ go>package main

<syntaxhighlight lang="go">package main

import (

Line 174:

}

}</~~lang~~>

}</syntaxhighlight>

Line 186:

=={{header|J}}==

N,K:

<~~lang~~ J> (,.1>.{.@I.@(+./@E.&":"0/ ^~))i.51x

<syntaxhighlight lang="j"> (,.1>.{.@I.@(+./@E.&":"0/ ^~))i.51x

0 9

1 1

Line 237:

48 9

49 24

50 23</~~lang~~>

50 23</syntaxhighlight>

=={{header|jq}}==

'''Works with gojq, the Go implementation of jq'''

The integer precision of stedolan jq is insufficient for this task.<~~lang~~ jq>

The integer precision of stedolan jq is insufficient for this task.<syntaxhighlight lang="jq">

# if the input and $b are integers, then gojq will preserve precision

def power($b): . as $a | reduce range(0; $b) as $i (1; . * $a);

Line 249:

tostring as $n

| first( range(1; infinite) | select( power(.) | tostring | contains($n))) ;

</syntaxhighlight>

</lang>

# Formatting

Line 258:

def n: if length <= $n then . else .[0:$n] , (.[$n:] | n) end;

n;

</~~lang~~>The task:<lang jq>

</syntaxhighlight>The task:<syntaxhighlight lang="jq">

def task($n):

[range(0; $n) | smallest_k | lpad(3) ]

Line 264:

| join(" ");

task(51)</~~lang~~>

task(51)</syntaxhighlight>

As for Factor, for example.

=={{header|Julia}}==

<~~lang~~ julia>hasinktok(n) = for k in 1:100000 contains("$(BigInt(k)^k)", "$n") && return k end

<syntaxhighlight lang="julia">hasinktok(n) = for k in 1:100000 contains("$(BigInt(k)^k)", "$n") && return k end

foreach(p -> print(rpad(p[2], 4), p[1] % 17 == 0 ? "\n" : ""), enumerate(map(hasinktok, 0:50)))

</~~lang~~>{{out}}

</syntaxhighlight>{{out}}

<pre>

9 1 3 5 2 4 4 3 7 9 10 11 5 19 22 26 8

Line 280:

=={{header|Mathematica}}/{{header|Wolfram Language}}==

<~~lang~~ ~~Mathematica~~>ClearAll[FindSmallestk]

<syntaxhighlight lang="mathematica">ClearAll[FindSmallestk]

FindSmallestk[n_Integer] := Module[{digs, id, out},

id = IntegerDigits[n];

Line 291:

out

]

Multicolumn[FindSmallestk /@ Range[0, 50], Appearance -> "Horizontal"]</~~lang~~>

Multicolumn[FindSmallestk /@ Range[0, 50], Appearance -> "Horizontal"]</syntaxhighlight>

<pre>9 1 3 5 2 4 4

Line 305:

=={{header|Nim}}==

<~~lang~~ ~~Nim~~>import strformat, strutils

<syntaxhighlight lang="nim">import strformat, strutils

import bignum

Line 322:

for n, k in results:

stdout.write &"{n:2} → {k:<2} ", if (n + 1) mod 9 == 0: '\n' else: ' '

echo()</~~lang~~>

echo()</syntaxhighlight>

Line 336:

made like Phix but own multiplikation to BASE 1E9 [[Smallest_power_of_6_whose_decimal_expansion_contains_n#Pascal|here]]

<~~lang~~ pascal>program K_pow_K;

<syntaxhighlight lang="pascal">program K_pow_K;

//First occurence of a numberstring with max DIGTIS digits in k^k

{$IFDEF FPC}

Line 513:

Out_Results(number,found);

end.

</syntaxhighlight>

</lang>

<pre>

Line 550:

</pre>

===gmp-version===

<~~lang~~ pascal>program K_pow_K_gmp;

<syntaxhighlight lang="pascal">program K_pow_K_gmp;

//First occurence of a numberstring with max DIGTIS digits in k^k

{$IFDEF FPC}

Line 657:

until number>9604;// found >=decLimit;

Out_Results(number,found);

end.</~~lang~~>

end.</syntaxhighlight>

<pre>

Line 669:

=={{header|Perl}}==

<~~lang~~ perl>use strict;

<syntaxhighlight lang="perl">use strict;

use warnings;

use feature 'say';

Line 676:

sub smallest { first { ipow($_,$_) =~ /$_[0]/ } 1..1e4 }

say join ' ', map { smallest($_) } 0..50;</~~lang~~>

say join ' ', map { smallest($_) } 0..50;</syntaxhighlight>

Line 684:

(Related recent tasks: [[Smallest_power_of_6_whose_decimal_expansion_contains_n#Phix|here]] and

[[Show_the_(decimal)_value_of_a_number_of_1s_appended_with_a_3,_then_squared#Phix|here]])

with javascript_semantics

constant lim = 51 -- (tested to 1,000,000)

Line 723:

end while

puts(1,join_by(shorten(res,"",30),1,10))

<pre>

Line 735:

Testing to 1,000,000 took 12mins 35s.

===gmp version===

with javascript_semantics

constant lim = 51 -- (tested to 1,000,000)

Line 765:

end while

puts(1,join_by(shorten(res,"",30),1,10))

Same results, but nearly 30 times faster, finishing the 1,000,000 test in just 26.6s

=={{header|Python}}==

Interactive script which takes the upper bound as input :

#Aamrun, 4th October 2021

Line 795:

[print(resultSet[i], end=' ') for i in sorted(resultSet)]

</syntaxhighlight>

</lang>

<pre>

Line 802:

</pre>

=={{header|Raku}}==

<lang ~~perl6~~>sub smallest ( $n ) {

<syntaxhighlight lang="raku" line>sub smallest ( $n ) {

state @powers = '', |map { $_ ** $_ }, 1 .. *;

Line 808:

}

.say for (^51).map(&smallest).batch(10)».fmt('%2d');</~~lang~~>

.say for (^51).map(&smallest).batch(10)».fmt('%2d');</syntaxhighlight>

<pre>

Line 821:

=={{header|REXX}}==

Code was added to display the count of unique numbers found.

<~~lang~~ rexx>/*REXX pgm finds the smallest positive integer K where K**K contains N, N < 51 */

<syntaxhighlight lang="rexx">/*REXX pgm finds the smallest positive integer K where K**K contains N, N < 51 */

numeric digits 200 /*ensure enough decimal digs for k**k */

parse arg hi cols . /*obtain optional argument from the CL.*/

Line 849:

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 ?</~~lang~~>

commas: parse arg ?; do jc=length(?)-3 to 1 by -3; ?=insert(',', ?, jc); end; return ?</syntaxhighlight>

<pre>

Line 866:

=={{header|Ring}}==

<~~lang~~ ring>

load "bignumber.ring"

Line 899:

num2 = string(num2)

return FuncPower(num1,num2)

</syntaxhighlight>

</lang>

<pre>

Line 914:

=={{header|Sidef}}==

<~~lang~~ ruby>0..50 -> map {|n| 1..Inf -> first {|k| Str(k**k).contains(n) } }.say</~~lang~~>

<syntaxhighlight lang="ruby">0..50 -> map {|n| 1..Inf -> first {|k| Str(k**k).contains(n) } }.say</syntaxhighlight>

<pre>

Line 924:

<~~lang~~ ecmascript>import "/big" for BigInt

<syntaxhighlight lang="ecmascript">import "/big" for BigInt

import "/seq" for Lst

import "/fmt" for Fmt

Line 941:

}

System.print("The smallest positive integers K where K ^ K contains N (0..50) are:")

for (chunk in Lst.chunks(res, 17)) Fmt.print("$2d", chunk)</~~lang~~>

for (chunk in Lst.chunks(res, 17)) Fmt.print("$2d", chunk)</syntaxhighlight>