Rosetta Code

Smallest numbers: Difference between revisions

Page Discussion

Smallest numbers (view source)

Revision as of 12:34, 6 February 2024

4,011 bytes added ,  3 months ago
m
→‎{{header|Wren}}: Changed to Wren S/H
(Added Python implementation)
m (→‎{{header|Wren}}: Changed to Wren S/H)
 
(10 intermediate revisions by 8 users not shown)
Line 4:
Smallest positive integer &nbsp; '''k''' &nbsp; such that the decimal expansion of &nbsp; '''k<sup>k</sup>''' &nbsp; contains &nbsp; '''n''', &nbsp; where &nbsp; '''n &nbsp;&lt;&nbsp; 51'''
<br><br>
 
=={{header|11l}}==
{{trans|Python}}
 
<syntaxhighlight lang="11l">V numLimit = 51
 
[Int = Int] resultSet
 
V base = 1
 
L resultSet.len != numLimit
V result = String(BigInt(base) ^ base)
 
L(i) 0 .< numLimit
I String(i) C result & i !C resultSet
resultSet[i] = base
 
base++
 
L(i) sorted(resultSet.keys())
print(resultSet[i], end' ‘ ’)</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|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}
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.
<langsyntaxhighlight 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 34 ⟶ 60:
IF i MOD 10 = 9 THEN print( ( newline ) ) FI
OD
END</langsyntaxhighlight>
{{out}}
<pre>
Line 46 ⟶ 72:
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight 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>
{{out}}
<pre>
Line 58 ⟶ 84:
=={{header|Factor}}==
{{works with|Factor|0.99 2021-02-05}}
<langsyntaxhighlight lang="factor">USING: formatting grouping io kernel lists lists.lazy
math.functions present sequences ;
 
Line 65 ⟶ 91:
 
51 <iota> [ smallest ] map 10 group
[ [ "%3d" printf ] each nl ] each</langsyntaxhighlight>
{{out}}
<pre>
Line 78 ⟶ 104:
=={{header|FreeBASIC}}==
Reuses some code from [[Arbitrary-precision_integers_(included)#FreeBASIC]].
<langsyntaxhighlight lang="freebasic">#Include once "gmp.bi"
Dim Shared As Zstring * 100000000 outtext
Line 112 ⟶ 138:
loop until is_substring( Power(str(k), k), str(i) )
print k;" ";
next i</langsyntaxhighlight>
{{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}}==
{{trans|Wren}}
<langsyntaxhighlight lang="go">package main
 
import (
Line 148 ⟶ 174:
}
}
}</langsyntaxhighlight>
 
{{out}}
Line 157 ⟶ 183:
18 7 17 15 9 18 16 17 9 7 12 28 6 23 9 24 23
</pre>
 
=={{header|J}}==
N,K:
<syntaxhighlight lang="j"> (,.1>.{.@I.@(+./@E.&":"0/ ^~))i.51x
0 9
1 1
2 3
3 5
4 2
5 4
6 4
7 3
8 7
9 9
10 10
11 11
12 5
13 19
14 22
15 26
16 8
17 17
18 16
19 19
20 9
21 8
22 13
23 7
24 17
25 4
26 17
27 3
28 11
29 18
30 13
31 5
32 23
33 17
34 18
35 7
36 17
37 15
38 9
39 18
40 16
41 17
42 9
43 7
44 12
45 28
46 6
47 23
48 9
49 24
50 23</syntaxhighlight>
 
=={{header|jq}}==
'''Works with gojq, the Go implementation of jq'''
 
The integer precision of stedolan jq is insufficient for this task.<langsyntaxhighlight 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 168 ⟶ 249:
tostring as $n
| first( range(1; infinite) | select( power(.) | tostring | contains($n))) ;
</syntaxhighlight>
</lang>
<syntaxhighlight lang="jq">
<lang jq>
# Formatting
 
Line 177 ⟶ 258:
def n: if length <= $n then . else .[0:$n] , (.[$n:] | n) end;
n;
</langsyntaxhighlight>The task:<syntaxhighlight lang ="jq">
def task($n):
[range(0; $n) | smallest_k | lpad(3) ]
Line 183 ⟶ 264:
| join(" ");
 
task(51)</langsyntaxhighlight>
{{out}}
As for Factor, for example.
 
=={{header|Julia}}==
<langsyntaxhighlight 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)))
</langsyntaxhighlight>{{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|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">ClearAll[FindSmallestk]
FindSmallestk[n_Integer] := Module[{digs, id, out},
id = IntegerDigits[n];
Do[
digs = IntegerDigits[k^k];
If[Length[SequenceCases[digs, id, 1]] > 0, out = k; Break[]]
,
{k, 1, \[Infinity]}
];
out
]
Multicolumn[FindSmallestk /@ Range[0, 50], Appearance -> "Horizontal"]</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|Nim}}==
{{libheader|bignum}}
<langsyntaxhighlight Nimlang="nim">import strformat, strutils
import bignum
 
Line 217 ⟶ 322:
for n, k in results:
stdout.write &"{n:2} → {k:<2} ", if (n + 1) mod 9 == 0: '\n' else: ' '
echo()</langsyntaxhighlight>
 
{{out}}
Line 231 ⟶ 336:
{{works with|Free Pascal}}
made like Phix but own multiplikation to BASE 1E9 [[Smallest_power_of_6_whose_decimal_expansion_contains_n#Pascal|here]]
<langsyntaxhighlight lang="pascal">program K_pow_K;
//First occurence of a numberstring with max DIGTIS digits in k^k
{$IFDEF FPC}
Line 408 ⟶ 513:
Out_Results(number,found);
end.
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 445 ⟶ 550:
</pre>
===gmp-version===
<langsyntaxhighlight lang="pascal">program K_pow_K_gmp;
//First occurence of a numberstring with max DIGTIS digits in k^k
{$IFDEF FPC}
Line 552 ⟶ 657:
until number>9604;// found >=decLimit;
Out_Results(number,found);
end.</langsyntaxhighlight>
{{out}}
<pre>
Line 564 ⟶ 669:
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">use strict;
use warnings;
use feature 'say';
Line 571 ⟶ 676:
 
sub smallest { first { ipow($_,$_) =~ /$_[0]/ } 1..1e4 }
say join ' ', map { smallest($_) } 0..50;</langsyntaxhighlight>
{{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>
Line 579 ⟶ 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]])
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">lim</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">51</span> <span style="color: #000080;font-style:italic;">-- (tested to 1,000,000)</span>
Line 618 ⟶ 723:
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join_by</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">30</span><span style="color: #0000FF;">),</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">))</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 630 ⟶ 735:
Testing to 1,000,000 took 12mins 35s.
===gmp version===
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">lim</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">51</span> <span style="color: #000080;font-style:italic;">-- (tested to 1,000,000)</span>
Line 660 ⟶ 765:
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join_by</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">30</span><span style="color: #0000FF;">),</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">))</span>
<!--</langsyntaxhighlight>-->
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 :
<syntaxhighlight lang="python">
<lang Python>
#Aamrun, 4th October 2021
 
Line 690 ⟶ 795:
 
[print(resultSet[i], end=' ') for i in sorted(resultSet)]
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 696 ⟶ 801:
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|Quackery}}==
 
<syntaxhighlight lang="Quackery">
[ stack ] is candidates ( --> s )
[ stack ] is results ( --> s )
 
[ [] swap times
[ i^ number$
nested join ]
candidates put
[] results put
0
[ 1+ dup
dup ** number$
candidates share
reverse witheach
[ over 2dup findseq
swap found iff
[ dip over
$->n drop
join nested
results take
join
results put
candidates take
i pluck drop
candidates put ]
else drop ]
drop
candidates share
[] = until ]
drop
candidates release
results take
sortwith
[ 1 peek swap 1 peek < ]
[] swap
witheach [ 0 peek join ] ] is task ( n --> [ )
 
51 task echo</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|Raku}}==
<syntaxhighlight lang="raku" perl6line>sub smallest ( $n ) {
state @powers = '', |map { $_ ** $_ }, 1 .. *;
 
Line 703 ⟶ 854:
}
 
.say for (^51).map(&smallest).batch(10)».fmt('%2d');</langsyntaxhighlight>
{{out}}
<pre>
Line 716 ⟶ 867:
=={{header|REXX}}==
Code was added to display the count of unique numbers found.
<langsyntaxhighlight 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 744 ⟶ 895:
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 default inputs:}}
<pre>
Line 761 ⟶ 912:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
load "bignumber.ring"
Line 794 ⟶ 945:
num2 = string(num2)
return FuncPower(num1,num2)
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 806 ⟶ 957:
23
done...
</pre>
 
=={{header|RPL}}==
{{works with|HP|49}}
« { }
0 50 '''FOR''' n
1
'''WHILE''' DUP DUP ^ →STR n →STR POS NOT
'''REPEAT''' 1 + '''END'''
+
'''NEXT'''
» '<span style="color:blue">TASK</span>' STO
{{out}}
<pre>
1: {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|Ruby}}==
Using a hash as memo:
<syntaxhighlight lang="ruby">memo = Hash.new{|h, k| h[k] = (k**k).to_s }
res = (0..50).map{|n| (1..).detect{|m| memo[m].include? n.to_s} }
res.each_slice(10){|slice| puts "%4d"*slice.size % slice }
</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|Sidef}}==
<langsyntaxhighlight lang="ruby">0..50 -> map {|n| 1..Inf -> first {|k| Str(k**k).contains(n) } }.say</langsyntaxhighlight>
{{out}}
<pre>
Line 817 ⟶ 998:
=={{header|Wren}}==
{{libheader|Wren-big}}
{{libheader|Wren-seq}}
{{libheader|Wren-fmt}}
<langsyntaxhighlight ecmascriptlang="wren">import "./big" for BigInt
import "./seqfmt" for LstFmt
import "/fmt" for Fmt
 
var res = []
Line 836 ⟶ 1,015:
}
System.print("The smallest positive integers K where K ^ K contains N (0..50) are:")
for (chunk in Lst.chunks(res, 17)) Fmt.printtprint("$2d", chunkres, 17)</langsyntaxhighlight>
 
{{out}}
PureFox
9,476

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/311396...354746"