Rosetta Code

Smallest power of 6 whose decimal expansion contains n: Difference between revisions

Page Discussion

Smallest power of 6 whose decimal expansion contains n (view source)

Revision as of 12:36, 6 February 2024

8,231 bytes added ,  3 months ago
m
→‎{{header|Wren}}: Minor tidy
m (→‎{{header|Raku}}: remove redundant routine)
m (→‎{{header|Wren}}: Minor tidy)
(15 intermediate revisions by 8 users not shown)
Line 10:
{{trans|Python}}
 
<langsyntaxhighlight lang="11l">F smallest_six(n)
V p = BigInt(1)
L String(n) !C String(p)
Line 17:
 
L(n) 22
print(‘#2: #.’.format(n, smallest_six(n)))</langsyntaxhighlight>
 
{{out}}
Line 48:
{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}
Uses ALGOL 68G's LONG LONG INT large integers, the default precision is sufficient for this task. Also uses the ALGOL 68G specific string in string procedure.
<langsyntaxhighlight lang="algol68">BEGIN # find the smallest k such that the decimal representation of 6^k contains n for 0 <= n <= 21 #
# returns s blank-padded on the right to at least len characters #
PROC right pad = ( STRING s, INT len )STRING:
Line 98:
OD
OD
END</langsyntaxhighlight>
{{out}}
<pre>
Line 127:
=={{header|ALGOL W}}==
Algol W doesn't have integers larger than 32 bits, however we can handle the required numbers with arrays of digits.
<langsyntaxhighlight lang="algolw">begin % find the smallest power of 6 that contains n for 0 <= n <= 21 %
% we assume that powers of 6 upto 6^32 will be sufficient %
% as Algol W does not have integers longer than 32 bits, the powers %
Line 184:
for d := digits( p ) step -1 until 1 do writeon( i_w := 1, s_w := 0, powers( p, d ) )
end for_n
end.</langsyntaxhighlight>
{{out}}
<pre>
Line 210:
21 in 6^ 3: 216
</pre>
 
=={{header|Arturo}}==
 
<syntaxhighlight lang="arturo">loop 0..22 'n [
ns: to :string n
print [pad to :string n 2 "->" 6 ^ first select.first 0..∞ 'x -> contains? to :string 6^x ns]
]</syntaxhighlight>
 
{{out}}
 
<pre> 0 -> 10077696
1 -> 1
2 -> 216
3 -> 36
4 -> 46656
5 -> 46656
6 -> 6
7 -> 7776
8 -> 2176782336
9 -> 1296
10 -> 10077696
11 -> 2821109907456
12 -> 1296
13 -> 13060694016
14 -> 6140942214464815497216
15 -> 101559956668416
16 -> 216
17 -> 60466176
18 -> 470184984576
19 -> 21936950640377856
20 -> 170581728179578208256
21 -> 216
22 -> 131621703842267136</pre>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f SMALLEST_POWER_OF_6_WHOSE_DECIMAL_EXPANSION_CONTAINS_N.AWK
BEGIN {
Line 227 ⟶ 260:
exit(0)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 256 ⟶ 289:
 
=={{header|C}}==
<langsyntaxhighlight Clang="c">#include <stdio.h>
#include <string.h>
#include <gmp.h>
Line 289 ⟶ 322:
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 317 ⟶ 350:
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">#include <iostream>
#include <iomanip>
#include <string>
Line 339 ⟶ 372:
}
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 366 ⟶ 399:
 
=={{header|CLU}}==
<langsyntaxhighlight lang="clu">% This program uses the bigint type that comes with PCLU.
% It is in "misc.lib"
%
Line 400 ⟶ 433:
stream$putl(po, "")
end
end start_up</langsyntaxhighlight>
{{out}}
<pre> 0: 6^9 = 10077696
Line 426 ⟶ 459:
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">
// Nigel Galloway. April 9th., 2021
let rec fN i g e l=match l%i=g,l/10I with (true,_)->e |(_,l) when l=0I->fN i g (e*6I) (e*6I) |(_,l)->fN i g e l
[0I..99I]|>Seq.iter(fun n->printfn "%2d %A" (int n)(fN(if n>9I then 100I else 10I) n 1I 1I))
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 538 ⟶ 571:
=={{header|Factor}}==
{{works with|Factor|0.99 2021-02-05}}
<langsyntaxhighlight lang="factor">USING: formatting kernel lists lists.lazy math math.functions
present sequences tools.memory.private ;
 
Line 547 ⟶ 580:
present powers-of-6 [ present subseq? ] with lfilter car ;
 
22 [ dup smallest commas "%2d %s\n" printf ] each-integer</langsyntaxhighlight>
{{out}}
<pre>
Line 577 ⟶ 610:
=={{header|FreeBASIC}}==
{{trans|Ring}}
<langsyntaxhighlight lang="freebasic">
Print !"\ntrabajando...\n"
Print !"M¡nima potencia de 6 cuya expansi¢n decimal contiene n:\n"
Line 597 ⟶ 630:
Print !"\n--- terminado, pulsa RETURN---"
Sleep
</syntaxhighlight>
</lang>
 
 
=={{header|Go}}==
{{trans|Wren}}
<langsyntaxhighlight lang="go">package main
 
import (
Line 644 ⟶ 677:
}
}
}</langsyntaxhighlight>
 
{{out}}
Line 674 ⟶ 707:
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Data.List (find, isInfixOf)
import Text.Printf (printf)
 
smallest :: Integer -> Integer
smallest n = d
where
Just d = find ((show n `isInfixOf`) . show) sixes
sixes :: [Integer]
sixes = iterate (* 6) 1
 
smallest :: Integer -> Integer
smallest n =
head $
filter
((show n `isInfixOf`) . show)
sixes
 
main :: IO ()
main =
putStr $
[0 .. 21] >>= printf "%2d: %d\n" <*> smallest</syntaxhighlight>
concatMap
(printf "%2d: %d\n" <*> smallest)
[0 .. 21]</lang>
 
{{out}}
 
<pre> 0: 10077696
1: 1
Line 723 ⟶ 750:
 
gojq provides unbounded-precision integer arithmetic and is therefore appropriate for this task.
<langsyntaxhighlight lang="jq"># To preserve precision:
def power($b): . as $in | reduce range(0;$b) as $i (1; . * $in);
 
Line 730 ⟶ 757:
| tostring as $n
| first(range(0;infinite) as $i | 6 | power($i) | . as $p | tostring | (index($n) // empty)
| [$in,$i,$p] )</langsyntaxhighlight>
{{out}}
<pre>
Line 759 ⟶ 786:
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">using Formatting
 
digcontains(n, dig) = contains(String(Char.(digits(n))), String(Char.(dig)))
Line 775 ⟶ 802:
println(rpad(n, 5), format(findpow6containing(n), commas=true))
end
</langsyntaxhighlight>{{out}}
<pre>
0 10,077,696
Line 802 ⟶ 829:
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">ClearAll[SmallestPowerContainingN]
SmallestPowerContainingN[n_Integer] := Module[{i = 1, test},
While[True,
Line 811 ⟶ 838:
]
]
Grid[SmallestPowerContainingN /@ Range[0, 21]]</langsyntaxhighlight>
{{out}}
<pre>0 9 10077696
Line 838 ⟶ 865:
=={{header|Nim}}==
{{libheader|bignum}}
<langsyntaxhighlight Nimlang="nim">import strformat, strutils
import bignum
 
Line 856 ⟶ 883:
echo "Smallest values of k such that 6^k contains n:"
for n, (k, s) in results:
echo &"{n:2}: 6^{k:<2} = {s}"</langsyntaxhighlight>
 
{{out}}
Line 884 ⟶ 911:
 
=={{header|Pascal}}==
==={{Works withheader|Free Pascal}}===
Doing long multiplikation like in primorial task.<BR>I used to check every numberstring one after the other on one 6^ n string.Gets really slow on high n<BR>After a closer look into [[Phix|Smallest_power_of_6_whose_decimal_expansion_contains_n#Phix]] I applied a slghtly modified version of Pete, to get down < 10 secs on my 2200G for DIGITS = 7.TIO.RUN is slower.
<langsyntaxhighlight lang="pascal">program PotOf6;
//First occurence of a numberstring with max decimal DIGTIS digits in 6^n
{$IFDEF FPC}
{$MODE DELPHI} {$Optimization ON,ALL} {$COPERATORS ON}{$CODEALIGN proc=16}
{$ENDIF}
{$Optimization ON,ALL}
{$IFDEF WINDOWS}
{$ELSE}
{$APPTYPE CONSOLE}
{$ENDIF}
Line 898 ⟶ 925:
sysutils;
const
//decimal places used by multiplication and for string conversion
POT_LIMIT = 70000;
{ DIGITS calcDigits = 8;
PowerBase = 6; // don't use 10^n ;-)
67584 99999998 46238296
 
Max power 68479
// for PowerBase = 2 maxvalues for POT_LIMIT and STRCOUNT
Found: 100000000 Time used 148.584 secs}
// DIGITS = 8;decLimit= 100*1000*1000;POT_LIMIT = 114715;STRCOUNT = 83789;
DIGITS = 7;
DIGITS = 7;decLimit= 10*1000*1000;POT_LIMIT = 32804;STRCOUNT = 24960;
// DIGITS = 6;decLimit= 1000*1000;POT_LIMIT = 9112;STRCOUNT = 7348;
// DIGITS = 5;decLimit= 100*1000;POT_LIMIT = 2750;STRCOUNT = 2148;
// DIGITS = 4;decLimit= 10*1000;POT_LIMIT = 809;STRCOUNT = 616;
// DIGITS = 3;decLimit= 1000;POT_LIMIT = 215;STRCOUNT = 175;
// DIGITS = 2;decLimit= 100;POT_LIMIT = 66;STRCOUNT = 45;
 
type
tMulElem = Uint32;
Line 911 ⟶ 945:
 
tFound = record
foundIndex: Uint32;,
foundStrfoundStrIdx :Ansistring Uint32;
end;
 
var
{$ALIGN 32}
PotArrN : tPotArrN;
StrDec4Dgts : array[0..9999] of String[4];
Pot_N_str : AnsiString;
Str_Found : array of tFound;
FoundString : array of AnsiString;
FirstMissing :NativeInt;
CheckedNum : array of boolean;
Pot_N_str : AnsiString;
FirstMissing,
FoundIdx :NativeInt;
T0 : INt64;
 
procedure Init_Mul(number:NativeInt)Init_StrDec4Dgts;
var
MaxMulIdxs : NativeIntstring[4];
i : integer;
Begin
a,b,c,d : char;
MaxMulIdx := trunc(POT_LIMIT*ln(number)/ln(10)/9+2);
setlength(PotArrN[0],MaxMulIdx);
setlength(PotArrN[1],MaxMulIdx);
PotArrN[0,0] := 1;
end;
 
function Mul_N(var Mul1,Mul2:tMul;limit,n:Uint32):NativeInt;
//Mul2 = n*Mul1. n must be < LongWordDec !
const
LongWordDec = 1000*1000*1000;
var
pM1,pM2 : tpMul;
carry,prod : Uint64;
begin
pM1i := @Mul1[0];
pM2s := @Mul2[0]'0000';
carryFor a := '0;' to '9' do
Begin
result :=0;
s[1] := a;
repeat
prodFor b := n*pM1[result]+Carry;'0' to '9' do
begin
Carry := prod Div LongWordDec;
pM2 s[result2] := Prod - Carry*LongWordDecb;
For c := '0' to '9' do
inc(result);
until result > limit; begin
IF Carry <> 0 then s[3] := c;
pM2[result] For d := Carry'0' to '9' do
begin
else
dec(result) s[4] := d;
StrDec4Dgts[i]:= s;
inc(i);
end;
end;
end;
end;
end;
 
Line 968 ⟶ 1,000:
exit;
end;
toIdx := 4*(toIdx DIV 3)+toIdx MOD 3 +1 ;
inc(toIdx);
setlength(result,toIdx);
repeat
result[toIdx] := s[FromIdx];
result[toIdx-1] := s[FromIdx-1];
result[toIdx-2] := s[FromIdx-2];
Line 985 ⟶ 1,016:
dec(fromIdx);
end;
end;
 
procedure Init_Mul(number:NativeInt);
var
dgtCount,
MaxMulIdx : NativeInt;
Begin
dgtCount := trunc(POT_LIMIT*ln(number)/ln(10))+1;
MaxMulIdx := dgtCount DIV calcDigits +2;
setlength(PotArrN[0],MaxMulIdx);
setlength(PotArrN[1],MaxMulIdx);
PotArrN[0,0] := 1;
setlength(Pot_N_str,dgtCount);
end;
 
function Mul_PowerBase(var Mul1,Mul2:tMul;limit:Uint32):NativeInt;
//Mul2 = n*Mul1. n must be < LongWordDec !
const
LongWordDec = 100*1000*1000;
var
pM1,pM2 : tpMul;
carry,prod : Uint64;
begin
pM1 := @Mul1[0];
pM2 := @Mul2[0];
carry := 0;
result :=0;
repeat
prod := PowerBase*pM1[result]+Carry;
Carry := prod Div LongWordDec;
pM2[result] := Prod - Carry*LongWordDec;
inc(result);
until result > limit;
IF Carry <> 0 then
pM2[result] := Carry
else
dec(result);
end;
 
procedure ConvToStr(var s:Ansistring;const Mul:tMul;i:NativeInt);
var
s9s8: string[9calcDigits];
pS : pChar;
j,k,d,m : NativeInt;
begin
// ij := High(MULi+1)*calcDigits;
j := (i+1)*9;
setlength(s,j+1);
pS := pChar(@s)[1];
m := Mul[i];
// fill complete with '0'
fillcharstr(pSMul[0i],j,'0's8);
j := length(s8);
str(Mul[i],S9);
move(s8[1],pS[0],j);
j := length(s9);
move(s9[1],pS[0],j);
k := j;
dec(i);
If i >= 0 then
repeat
str(Mulm := MUL[i],S9);// no leading '0'
jd := length(s9)m div 10000;
inc(k,9)m := m-10000*d;
move(StrDec4Dgts[d][1],pS[k],4);
//move to the right place, leading '0' is already there
move(s9StrDec4Dgts[m][1],pS[k-j+4],j4);
inc(k,calcDigits);
dec(i);
until i<0;
Line 1,017 ⟶ 1,084:
 
function CheckOneString(const s:Ansistring;pow:NativeInt):NativeInt;
//check every possible number from one to DIGITS digits,
//if it is still missing in the list
var
pChecked : pBoolean;
i,k,lmt,num : NativeInt;
csoneFound : Ansistringboolean;
begin
pChecked := @CheckedNum[0];
result := 0;
csoneFound := ''false;
lmt := length(s);
For i := 1 to lmt do
Line 1,032 ⟶ 1,101:
repeat
num := num*10+ Ord(s[k])-Ord('0');
IF (num >= FirstMissing) AND Not(str_FoundpChecked[num].foundIndex = 0) then
begin
//memorize that string commatized
str_Found[num].foundIndex:= pow+1;
if NOT(oneFound) then
// commatize only once. reference counted string
if cs ='' thenBegin
csoneFound := Commatize(s)true;
str_Found FoundString[numFoundIDX].foundStr := csCommatize(s);
FoundIDX += 1;
end;
pChecked[num]:= true;
with str_Found[num] do
Begin
foundIndex:= pow+1;
foundStrIdx:= FoundIDX-1;
end;
inc(result);
if num =irstMissingFirstMissing then
repeat
while str_Found[FirstMissing].foundIndex <> 0 do
inc(FirstMissing);
until str_Found[FirstMissing].foundIndex =0;
end;
inc(k)
Line 1,050 ⟶ 1,128:
 
var
i,j,numberk,toggle,MaxMulIdx,found,decLimit: Int32;
Begin
T0 := GetTickCount64;
number := 6;//<1e9 no power of 10 ;-)
decLimit := 1;
For i := 1 to digits do
decLimit *= 10;
setlength(Str_Found,decLimit);
setlength(CheckedNum,decLimit);
Init_Mul(number);
setlength(FoundString,STRCOUNT);
 
FirstMissing := 0;
FoundIdx := 0;
Init_StrDec4Dgts;
Init_Mul(PowerBase);
writeln('Init in ',(GetTickCount64-T0)/1000:8:3,' secs');
T0 := GetTickCount64;
toggle := 0;
found := 0;
FirstMissing := 0;
MaxMulIdx := 0;
k := 0;
For j := 0 to POT_LIMIT do
Begin
// if j MOD 20 = 0 then writeln;
ConvToStr(Pot_N_str,PotArrN[toggle],MaxMulIdx);
inc(found,i := CheckOneString(Pot_N_str,j));
found += i;
MaxMulIdx := Mul_N(PotArrN[toggle],PotArrN[1-toggle],MaxMulIdx,number);
if i <> 0 then
k += 1;
MaxMulIdx := Mul_PowerBase(PotArrN[toggle],PotArrN[1-toggle],MaxMulIdx);
toggle := 1-toggle;
 
if found>=decLimit then
if FirstMissing = decLimit then
Begin
writeln(#10,'Max power ',j,' with ',length(Pot_N_str),' digits');
break;
end;
// if (j and 1023) = 0 then write(#13,j:10,found:10,FirstMissing:10);
write(j:10,found:10,firstMissing:10,#13);
end;
writeln(#13#10,'Found: ',found,' in ',k,' strings. Time used ',(GetTickCount64-T0)/1000:8:3,' secs');
 
writeln(#10,'Found: ',found,' Time used ',(GetTickCount64-T0)/1000:8:3,' secs');
For i := 0 to 22 do//decLimit-1 do
with Str_Found[i] do
writeln(i:10,' ',PowerBase,'^',foundIndex-1:5,' ',(FoundString[foundStrIdx]):30);
if foundIndex >0 then
end.
writeln(i:10,' ',number,'^',foundIndex-1:5,' ',foundStr);
</syntaxhighlight>
readln;
{{out|@TIO.RUN}}
end.</lang>
{{out}}
<pre>
Init in 0.062 secs
TIO.RUN output
//Power found first missing
0 1 0
1024 751817 10020
2048 2168981 100017
3072 3733971 100017
4096 5305316 100672
5120 6747391 104835
6144 7922626 575115
7168 8776137 1000007
8192 9336696 1000015
9216 9667898 1000020
10240 9846933 1000088
11264 9935108 1000135
12288 9974783 1000204
13312 9990953 1000204
14336 9997035 1000204
15360 9999102 1000204
16384 9999744 1029358
17408 9999934 1029358
18432 9999978 1029358
19456 9999997 8091358
20480 9999999 8091358
21504 9999999 8091358
Max power 21798
 
Max power 21798 with 16963 digits
Found: 10000000 Time used 14.882 secs
0 6^ 9 10,077,696
1 6^ 0 1
2 6^ 3 216
3 6^ 2 36
4 6^ 6 46,656
5 6^ 6 46,656
6 6^ 1 6
7 6^ 5 7,776
8 6^ 12 2,176,782,336
9 6^ 4 1,296
10 6^ 9 10,077,696
11 6^ 16 2,821,109,907,456
12 6^ 4 1,296
13 6^ 13 13,060,694,016
14 6^ 28 6,140,942,214,464,815,497,216
15 6^ 18 101,559,956,668,416
16 6^ 3 216
17 6^ 10 60,466,176
18 6^ 15 470,184,984,576
19 6^ 21 21,936,950,640,377,856
20 6^ 26 170,581,728,179,578,208,256
21 6^ 3 216
22 6^ 22 131,621,703,842,267,136
 
Found: 10000000 in 15889 strings. Time used 8.114 secs
Real time: 15.373 s
 
User time: 14.953 s
0 6^ 9 10,077,696
Sys. time: 0.254 s
1 6^ 0 1
CPU share: 98.92 %</pre>
2 6^ 3 216
3 6^ 2 36
4 6^ 6 46,656
5 6^ 6 46,656
6 6^ 1 6
7 6^ 5 7,776
8 6^ 12 2,176,782,336
9 6^ 4 1,296
10 6^ 9 10,077,696
11 6^ 16 2,821,109,907,456
12 6^ 4 1,296
13 6^ 13 13,060,694,016
14 6^ 28 6,140,942,214,464,815,497,216
15 6^ 18 101,559,956,668,416
16 6^ 3 216
17 6^ 10 60,466,176
18 6^ 15 470,184,984,576
19 6^ 21 21,936,950,640,377,856
20 6^ 26 170,581,728,179,578,208,256
21 6^ 3 216
22 6^ 22 131,621,703,842,267,136
 
Real time: 8.383 s User time: 8.133 s Sys. time: 0.185 s CPU share: 99.23 %
</pre>
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">use strict;
use warnings;
use List::Util 'first';
Line 1,155 ⟶ 1,214:
my $e = first { 6**$_ =~ /$n/ } 0..1000;
printf "%7d: 6^%-3s %s\n", $n, $e, comma 6**$e;
}</langsyntaxhighlight>
{{out}}
<pre> 0: 6^9 10,077,696
Line 1,185 ⟶ 1,244:
(Related recent task: [[Show_the_(decimal)_value_of_a_number_of_1s_appended_with_a_3,_then_squared#Phix]])
 
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">constant</span> <span style="color: #000000;">lim</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">22</span> <span style="color: #000080;font-style:italic;">-- (tested to 10,000,000)</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">(),</span> <span style="color: #000000;">t1</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">t0</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span>
Line 1,231 ⟶ 1,290:
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #7060A8;">papply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</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;">"%2d %29s = 6^%d\n"</span><span style="color: #0000FF;">},</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">columnize</span><span style="color: #0000FF;">({</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">lim</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">),</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">pwr</span><span style="color: #0000FF;">}),</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)})</span>
<!--</langsyntaxhighlight>-->
 
{{out}}
Line 1,261 ⟶ 1,320:
 
=={{header|Python}}==
<langsyntaxhighlight lang="python">def smallest_six(n):
p = 1
while str(n) not in str(p): p *= 6
Line 1,267 ⟶ 1,326:
for n in range(22):
print("{:2}: {}".format(n, smallest_six(n)))</langsyntaxhighlight>
{{out}}
<pre> 0: 10077696
Line 1,291 ⟶ 1,350:
20: 170581728179578208256
21: 216</pre>
 
=={{header|Quackery}}==
 
<syntaxhighlight lang="Quackery"> [ 0 swap
[ dip 1+
10 /
dup 0 = until ]
drop ] is digits ( n --> n )
 
[ 10 over digits
** temp put
false unrot
[ over temp share mod
over = iff
[ rot not unrot ]
done
dip [ 10 / ]
over 0 = until ]
2drop
temp release ] is contains ( n n --> b )
 
[ -1 swap
[ dip 1+
over 6 swap **
over contains
until ]
drop ] is smallest ( n --> n )
 
22 times
[ i^ 10 < if sp
i^ echo
say " --> "
6 i^ smallest **
echo cr ]
cr
say "The smallest power of 6 whose decimal expansion contains 31415926 is 6^"
31415926 smallest echo say "." cr</syntaxhighlight>
 
{{out}}
 
<pre> 0 --> 10077696
1 --> 1
2 --> 216
3 --> 36
4 --> 46656
5 --> 46656
6 --> 6
7 --> 7776
8 --> 2176782336
9 --> 1296
10 --> 10077696
11 --> 2821109907456
12 --> 1296
13 --> 13060694016
14 --> 6140942214464815497216
15 --> 101559956668416
16 --> 216
17 --> 60466176
18 --> 470184984576
19 --> 21936950640377856
20 --> 170581728179578208256
21 --> 216
 
The smallest power of 6 whose decimal expansion contains 31415926 is 6^4261.</pre>
 
=={{header|Raku}}==
 
<syntaxhighlight lang="raku" perl6line>use Lingua::EN::Numbers;
 
my @po6 = ^Inf .map: *.exp: 6;
Line 1,301 ⟶ 1,424:
sprintf "%3d: 6%-4s %s", $n, .&super, comma @po6[$_]
given @po6.first: *.contains($n), :k
};</langsyntaxhighlight>
{{out}}
<pre> 0: 6⁹ 10,077,696
Line 1,328 ⟶ 1,451:
 
=={{header|REXX}}==
<langsyntaxhighlight lang="rexx">/*REXX pgm finds the smallest (decimal) power of 6 which contains N, where N < 22. */
numeric digits 100 /*ensure enough decimal digs for 6**N */
parse arg hi . /*obtain optional argument from the CL.*/
Line 1,349 ⟶ 1,472:
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 input:}}
<pre>
Line 1,380 ⟶ 1,503:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
 
Line 1,403 ⟶ 1,526:
 
see "done..." + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,433 ⟶ 1,556:
</pre>
 
=={{header|RPL}}==
1980s RPL can only handle 64-bit unsigned integers, which means a multi-precision multiplication is here required.
{{works with|Halcyon Calc|4.2.7}}
{| class="wikitable"
! RPL code
! Comment
|-
|
≪ 1000000000 → x n p
≪ { } # 0d
x SIZE 1 '''FOR''' j
x j GET n * +
DUP p / SWAP OVER p * - ROT + SWAP
-1 '''STEP'''
'''IF''' DUP # 0d ≠ '''THEN''' SWAP + '''ELSE''' DROP '''END'''
≫ ≫ '<span style="color:blue">MMULT</span>' STO
≪ "" SWAP
1 OVER SIZE '''FOR''' d
DUP d GET →STR 3 OVER SIZE 1 - SUB
'''IF''' d 1 ≠ '''THEN'''
'''WHILE''' DUP SIZE 9 < REPEAT "0" SWAP +
'''END END'''
ROT SWAP + SWAP
'''NEXT''' DROP
≫ '<span style="color:blue">M→STR</span>' STO
≪
{ # 1d } SWAP
WHILE DUP REPEAT
SWAP 6 <span style="color:blue">MMULT</span> SWAP 1 - END
DROP <span style="color:blue">M→STR</span>
≫ '<span style="color:blue">POW6</span>' STO
≪ DEC { }
0 21 '''FOR''' n
n →STR -1
DO 1 + DUP '''POW6'''
'''UNTIL''' 3 PICK POS '''END'''
<span style="color:blue">POW6</span> ROT SWAP + SWAP DROP
NEXT
≫ '<span style="color:blue">TASK</span>' STO
|
<span style="color:blue">MMULT</span> ''( { #multi #precision } n -- { #multi #precision } )''
initialize stack with empty result number and carry
loop from the lowest digit block
multiply block by n, add carry
prepare carry for next block
if carry ≠ 0 then add it as a new block
<span style="color:blue">M→STR</span> ''( { #multi #precision } -- "integer" )''
for each digit block
turn it into string, remove both ends
if not the highest block
fill with "0"
add to previous blocks' string
<span style="color:blue">POW6</span> ''( n -- { #multi #precision } )''
{ #1d } is 1 in multi-precision
multiply n times
by 6
make it a string
Forces decimal mode for integer display
for n < 22
turn n into string, initialize counter
get 6^n
until "n" in "6^n"
remake n a string and add it to result list
|}
{{out}}
<pre>
1: { "10077696" "1" "216" "36" "46656" "46656" "6" "7776" "2176782336" "1296" "10077696" "2821109907456" "1296" "13060694016" "6140942214464815497216" "101559956668416" "216" "60466176" "470184984576" "21936950640377856" "170581728179578208256" "216" }
</pre>
====2000s RPL version====
Big integers are native in this version.
{{works with|HP|49}}
≪ { }
0 21 '''FOR''' n
0
'''WHILE''' 6 OVER ^ →STR n →STR POS NOT
'''REPEAT''' 1 + '''END'''
"'6^" SWAP + STR→ +
'''NEXT'''
≫ '<span style="color:blue">TASK</span>' STO
 
{{out}}
<pre>
1: { 6^9 6^0 6^3 6^2 6^6 6^6 6^1 6^5 6^12 6^4 6^9 6^16 6^4 6^13 6^28 6^18 6^3 6^10 6^15 6^21 6^26 6^3 }
</pre>
 
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">def smallest_6(n)
i = 1
c = 0
s = n.to_s
until i.to_s.match?(s)
c += 1
i *= 6
end
[n, c, i]
end
 
(0..21).each{|n| puts "%3d**%-3d: %d" % smallest_6(n) }
</syntaxhighlight>
{{out}}
<pre> 0**9 : 10077696
1**0 : 1
2**3 : 216
3**2 : 36
4**6 : 46656
5**6 : 46656
6**1 : 6
7**5 : 7776
8**12 : 2176782336
9**4 : 1296
10**9 : 10077696
11**16 : 2821109907456
12**4 : 1296
13**13 : 13060694016
14**28 : 6140942214464815497216
15**18 : 101559956668416
16**3 : 216
17**10 : 60466176
18**15 : 470184984576
19**21 : 21936950640377856
20**26 : 170581728179578208256
21**3 : 216
</pre>
=={{header|Wren}}==
{{libheader|Wren-big}}
{{libheader|Wren-fmt}}
<langsyntaxhighlight ecmascriptlang="wren">import "./big" for BigInt
import "./fmt" for Fmt
 
System.print(" n smallest power of 6 which contains n")
Line 1,451 ⟶ 1,711:
i = i + 1
}
}</langsyntaxhighlight>
 
{{out}}
Line 1,479 ⟶ 1,739:
21 6^3 = 216
</pre>
 
=={{header|Yabasic}}==
{{trans|Python}}
<syntaxhighlight lang="yabasic">// Rosetta Code problem: http://rosettacode.org/wiki/Smallest_power_of_6_whose_decimal_expansion_contains_n
// by Galileo, 05/2022
 
sub smallest_six(n)
local p, n$
n$ = str$(n)
p = 1
while not instr(str$(p, "%1.f"), n$) p = p * 6 : wend
return p
end sub
for n = 0 to 21 : print n, ": ", str$(smallest_six(n), "%1.f") : next</syntaxhighlight>
{{out}}
<pre>0: 10077696
1: 1
2: 216
3: 36
4: 46656
5: 46656
6: 6
7: 7776
8: 2176782336
9: 1296
10: 10077696
11: 2821109907456
12: 1296
13: 13060694016
14: 6140942214464815497216
15: 101559956668416
16: 216
17: 60466176
18: 470184984576
19: 21936950640377856
20: 170581728179578208256
21: 216
---Program done, press RETURN---</pre>
PureFox
9,476

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/311223...354740"