乘法持久性

将一个数字中的所有数字相乘
重复直到您剩下一位数

正如Numberphile解释的那样：

例

277777788888899→2x7x7x7x7x7x7x8x8x8x8x8x8x9x9 = 4996238671872
4996238671872→4x9x9x6x2x3x8x6x7x1x8x7x2 = 438939648
438939648→4x3x8x9x3x9x6x4x8 = 4478976
4478976→4x4x7x8x9x7x6 = 338688
338688→3x3x8x6x8x8 = 27648
27648→2x7x6x4x8 = 2688
2688→2x6x8x8 = 768
768→7x6x8 = 336
336→3x3x6 = 54
54→5x4 = 20
20→2x0 = 0

顺便说一下，这是当前记录：最小的数字和最大的步数。

高尔夫球

该程序以任何整数作为输入，然后从输入本身开始输出每个步骤的结果，直到我们碰到一位数字为止。对于277777788888899，输出应为

277777788888899
4996238671872
438939648
4478976
338688
27648
2688
768
336
54
20
0

（计算步数留给用户练习）。

果冻，4字节

DP$Ƭ

在线尝试！

说明

D    | convert to decimal digits
 P   | take the product
  $  | previous two links as a monad
   Ƭ | loop until no change, collecting all intermediate results

作为奖励，这是一个TIO，它将在给定的数字范围内查找步数最大的数字。即使在TIO上也可以很好地扩展。

— 尼克·肯尼迪
source

15

TI-BASIC（TI-84），30 32 31字节

-1个字节感谢@SolomonUcko！

While Ans>9:Disp Ans:prod(int(10fPart(Ans10^(seq(-X-1,X,0,log(Ans:End:Ans

输入为Ans。
输出显示为质询请求。Ans打印最后一步需要尾随。

我承认，我自己并没有想到这个公式，而是在这里找到并修改了它以更好地应对挑战。

编辑： 重新阅读挑战后，我意识到，如果乘积是一位数字，则程序必须终止。因此，要为此添加2个字节。

例：

说明：

While Ans>9               ;loop until the product is one digit
Disp Ans                  ;display the current product
prod(                     ;get the product of...
 int(                     ; the integer part of...
  10fPart(                ; ten times the fractional part of...
  Ans                     ; each element in the following list times the
                          ;  current product
  10^(                    ; multiplied by the list generated by using each
                          ;  element of the following list as an exponent
                          ;  for 10^n
   seq(-X-1),X,0,log(Ans  ; generate a list of exponents from -1 to -L where
                          ;  L = the length of the current product
End
Ans                       ;leave the final product in "Ans" and implicitly
                          ; print it

视觉模型：
Ans从开始125673。
该模型仅涵盖了将数字相乘的逻辑。其他所有内容都更容易理解。

seq(-X-1,X,0,log(Ans  =>  seq(-X-1,X,0,5.0992
   {-1 -2 -3 -4 -5 -6}
10^(...
   {.1 .01 .001 1E-4 1E-5 1E-6}
Ans...
   {12567.3 1256.73 125.673 12.5673 1.25673 .125673}
fPart(...
   {.3 .73 .673 .5673 .25673 .125673}
10...
   {3 7.3 6.73 5.673 2.5673 1.25673}
int(...
   {3 7 6 5 2 1}
   (the digits of the number, reversed)
prod(...
   1260
   (process is repeated again)

seq(-X-1,X,0,log(Ans  =>  seq(-X-1,X,0,3.1004
   {-1 -2 -3 -4}
10^(...
   {.1 .01 .001 1E-4}
Ans...
   {126 12.6 1.26 .126}
fPart(...
   {0 .6 .26 .126}
10...
   {0 6 2.6 1.26}
int(...
   {0 6 2 1}
prod(...
   0
   (product is less than 10.  loop ends)

笔记：

TI-BASIC是一种标记化语言。字符数不不等于字节数。

10^(是这个一字节的令牌。

由于TI计算器的小数精度限制，该程序将无法提供长度大于14位整数的正确乘积序列。

— 头
source

您可以通过移到10^(外部seq(并省略右括号来节省字节吗？

— 所罗门·乌科

是的，我相信！

— 陶

11

K（ngn / k），9个字节

{*/.'$x}\

在线尝试！

{ }\ 继续在花括号中应用该功能，直到序列收敛

$x 将参数格式化为字符串（字符列表）

.'分别评估（k的其他方言需要冒号.:'）

*/ 乘以，即乘积

— ngn
source

8

dzaima / APL，14 11字节

∪{×/⍎¨⍕⍵}⍡≡

在线尝试！

— 宰马
source

8

R，59个字节

n=scan();while(print(n)>9)n=prod(n%/%10^(nchar(n):1-1)%%10)

在线尝试！

由于print invisibly返回其输入，因此我们可以print(n)在while循环内部使用以模拟do-while循环。这是受到我在R.打高尔夫球的秘诀之一启发的。

标头有助于防止大量数字以科学计数法打印。

— 朱塞佩
source

8

05AB1E，7 4 字节

Δ=SP

在线尝试或验证所有测试用例。

说明：

Δ     # Loop until the number no longer changes:
 =    #  Print the number with trailing newline (without popping the number itself)
      #  (which will be the implicit input in the first iteration)
  SP  #  Convert the number to a list of digits, and calculate its product

— 凯文·克鲁伊森
source

7

Wolfram语言（Mathematica），47个字节

Most@FixedPointList[Times@@IntegerDigits@#&,#]&

在线尝试！

— J42161217
source

7

Wolfram语言（Mathematica），45字节

#//.x_/;x>9:>Times@@IntegerDigits@x&&Print@x&

在线尝试！

— J42161217
source

42个字节（如果您不介意使用）Echo。

— 罗马

7

Perl 6、23个字节

{$_,{[*] .comb}…10>*}

在线尝试！

— 肮脏的
source

7

Python 2中， 46 43个字节

-3感谢xnor（链接比较）

def f(n):print n;n>9>f(eval('*'.join(`n`)))

在线尝试！

— 乔纳森·艾伦
source

您可以>代替and。

— xnor

@xnor谢谢，很容易忘记，它将起作用。

— 乔纳森·艾伦

5

PowerShell，54个字节

for($a=$args;$a-gt9){$a;$a=("$a"|% t*y)-join"*"|iex}$a

在线尝试！

迭代方法，该方法首先写入输入参数，然后将其转换为字符串并将其通过管道传递到字符数组。该数组由一个星号连接，并作为带有invoke Expression别名的命令执行。由于这会将起始编号写为大于0的最后一个编号（在给定的测试方案中为20），因此我$a在输出的末尾添加了一个final 。

— 格拉西耶
source

5

C＃（Visual C＃交互式编译器），79 74 68字节

void f(int a){Print(a);if(a>9)f((a+"").Aggregate(1,(j,k)=>k%48*j));}

由于方法声明有多长时间，我尝试避免使用C＃进行递归，但是在这种情况下，与循环相比，它可以节省时间。

在线尝试！

— 无知的体现
source

5

PHP，63字节

<?=$n=$argn;while($n>9)echo"
",$n=array_product(str_split($n));

迭代版本，使用的php -nF输入进行调用STDIN。

在线尝试！

PHP，72 71个字节

function h($n){echo"$n
",($n=array_product(str_split($n)))>9?h($n):$n;}

在线尝试！

递归版本，作为函数。

输入：277777788888899

277777788888899
4996238671872
438939648
4478976
338688
27648
2688
768
336
54
20
0

输入：23

23
6

— 640KB
source

5

Python 2中，61 62 59个字节

def f(n):print n;n>9and f(reduce(int.__mul__,map(int,`n`)))

在线尝试！

_{-3个字节，感谢Jonathan Allan}

— 场
source

对于在最后一次迭代中不以0结尾的输入不起作用，例如23

— 无知的体现

int.__mul__比三个字节少lambda a,b:a*b

— 乔纳森·艾伦

@JonathanAllan谢谢！我知道一定有那样的东西

— TFeld

更改f(reduce(int.__mul__,map(int,`n`)))为f(eval('*'.join(`n`)))保存13个字节。

— mypetlion

@mypetlion ...我已经在另一篇文章中做了。

— 乔纳森·艾伦

5

perl 5（`-n` `-M5.01`），32 30 25字节

say$_=eval;s/\B/*/g&&redo

25字节

30字节

32字节

— 纳韦尔·福耶勒（Nahuel Fouilleul）
source

您应该提到这会使用-lpF//

— Grimmy

1

@Grimy我可以在不使用-lpF//，更新的情况下节省2个字节

— Nahuel Fouilleul

5

数学高尔夫，9个10字节

h(ôo▒ε*h(→

在线尝试！

现在，它可以正确处理单个数字的输入。不完美，但至少是正确的。

说明

h(            check length of input number and decrease by 1
  ö       →   while true with pop using the next 6 operators
   p          print with newline
    ▒         split to list of chars/digits
     ε*       reduce list by multiplication
       h(     length of TOS without popping, subtracted by 1 (exits when len(TOS) == 1)

— 马克斯
source

一位数字输入的输出应为该数字的一个副本-注释中已阐明

— dzaima

@dzaima我将研究它，并在解决问题时更新答案

— maxb

5

朱0.7，36个 33字节

f(n)=n>9?[n;f(prod(digits(n)))]:n

在线尝试！

感谢H.PWiz -3个字节。

— 基里尔
source

您可以使用[n;f(prod(digits(n)))]

— H.PWiz

4

JavaScript（ES6），45个字节

返回整数数组。

f=n=>[n,...n>9?f(eval([...n+''].join`*`)):[]]

在线尝试！

— Arnauld
source

4

PowerShell，51字节

filter f{$_
if($_-gt9){("$_"|% t*y)-join'*'|iex|f}}

在线尝试！

— 疯狂的
source

4

APL（NARS），19个字符，38个字节

{⍵≤9:⍵⋄∇×/⍎¨⍕⍵⊣⎕←⍵}

测试：

   f←{⍵≤9:⍵⋄∇×/⍎¨⍕⍵⊣⎕←⍵}
   f 23     
23
6
   f 27648     
27648
2688
768
336
54
20
0

— 罗斯鲁普
source

4

Haskell，45个字节

f n=n:[x|n>9,x<-f$product$read.pure<$>show n]

在线尝试！

— 妮米
source

4

J，16字节

([:*/,.&.":)^:a:

在线尝试！

— 加伦·伊万诺夫（Galen Ivanov）
source

4

红宝石，38 35 34字节

f=->n{p(n)>9&&f[eval n.digits*?*]}

在线尝试！

G B保存了1个字节。

— 基里尔
source

4

杰普特 `-R`，9个字节

效率极低-甚至不要尝试运行第一个测试用例！

_ì ×}hN â

试试吧

_ì ×}hN â     :Implicit input of integer U
      N       :Starting with the array of inputs (i.e., [U])
     h        :Do the following U times, pushing the result to N each time
_             :Take the last element in N and pass it through the following function
 ì            :  Convert to digit array
   ×          :  Reduce by multiplication
    }         :End function
        â     :Deduplicate N
              :Implicitly join with newlines and output

— 毛茸茸
source

3

Brachylog，7个字节

ẉ?Ḋ|ẹ×↰

在线尝试！

说明

ẉ          Write the input followed by a linebreak
 ?Ḋ        If the input is a single digit, then it's over
   |       Otherwise
    ẹ      Split the input into a list of digits
     ×     Multiply them together
      ↰    Recursive call with the result of the multiplication as input

— 致命
source

我自己尝试了一下。忘了the。其余的我也一样。

— 克罗佩卜

3

JavaScript（Babel节点），46字节

f=a=>a>9?[a,...f(eval([...a+''].join`*`))]:[a]

在线尝试！

JavaScript（Babel节点），44字节

如果输入可以作为字符串

f=a=>a>9?[a,...f(''+eval([...a].join`*`))]:a

在线尝试！

— 路易斯·费利佩·德·耶稣·穆诺兹
source

@Arnauld是的，我刚刚编辑并添加了错误的代码。我仍在寻找仅使用字符串而不是数组的东西

— Luis felipe De jesus Munoz

3

PowerShell，64 59字节

for($a="$args";9-lt$a){$a;$a="$(($a|% t*y)-join'*'|iex)"}$a

在线尝试！

迭代方法。接受输入并将其存储到中$a，然后进入for循环，只要的长度$a为2或更大（即，大于9）。内的循环中，我们输出$a，然后通过将它重新计算它toCharArra y，join连同荷兰国际集团它*，然后iex（短为Invoke-Expression和类似eval）。一旦脱离循环，我们只剩下一位数字可打印，因此我们将$a再次在管道上。

-5个字节，感谢KGlasier。

— AdmBorkBork
source

您可以使用比较9-lt$a而不是$a.length-1节省5个字节。而且，如果您始终不使用字符串，则可以切下一个不错的块。如果需要，请查看我的powershell尝试！

— KGlasier

3

木炭，13字节

θＷ⊖Ｌθ«≔ＩΠθθ⸿θ

在线尝试！链接是详细版本的代码。说明：

θ

第一次打印输入。

Ｗ⊖Ｌθ«

输入的长度不为1时重复上述步骤。

≔ＩΠθθ

将输入替换为其数字产品并转换为字符串。

⸿θ

在新行上打印输入。

— 尼尔
source

3

视网膜，24字节

.+~(\`

.
$&$*
^
.+¶$$.(

在线尝试！说明：

.+~(\`

在每个循环开始时，将当前值打印在自己的行上，直到它停止更改并且不要两次打印未更改的值。在每个循环结束时评估当前值。

.
$&$*

*在每个数字后添加一个。

^
.+¶$$.(

完成将输入转换为计算结果为数字产品的表达式。

仅作记录，Retina可以在一行（25个字节）中执行此操作：

.+"¶"<~[".+¶$.("|'*]'*L`.

— 尼尔
source

3

C（gcc），58个字节

f(n,t){for(;n=printf("%d\n",t=n)>2;)for(;n*=t%10,t/=10;);}

在线尝试！

迭代方法原来要短1个字节。

f(n,t){
    for(;n=printf("%d\n",t=n)   //print and update current number
            >2;)                //until only one digit is printed
        for(;n*=t%10,t/=10;);   //n*= product of digits of t (step)
}

C（gcc），61 59字节（递归）

f(n){printf("%d\n",n)>2&&f(p(n));}p(n){n=n?n%10*p(n/10):1;}

在线尝试！

~~对于打印和步骤，递归似乎都比迭代要短。~~

— Attinat
source

乘法持久性

乘法持久性

例

高尔夫球

更多例子

果冻，4字节

说明

TI-BASIC（TI-84），30 32 31字节

K（ngn / k），9个字节

dzaima / APL，14 11字节

R，59个字节

05AB1E，7 4 字节

Wolfram语言（Mathematica），47个字节

Wolfram语言（Mathematica），45字节

Perl 6、23个字节

Python 2中， 46 43个字节

PowerShell，54个字节

C＃（Visual C＃交互式编译器），79 74 68字节

PHP，63字节

PHP，72 71个字节

Python 2中，61 62 59个字节

perl 5（-n -M5.01），32 30 25字节

数学高尔夫，9个10字节

说明

朱0.7，36个 33字节

JavaScript（ES6），45个字节

PowerShell，51字节

APL（NARS），19个字符，38个字节

Haskell，45个字节

J，16字节

红宝石，38 35 34字节

杰普特 -R，9个字节

Brachylog，7个字节

说明

JavaScript（Babel节点），46字节

JavaScript（Babel节点），44字节

PowerShell，64 59字节

木炭，13字节

视网膜，24字节

C（gcc），58个字节

C（gcc），61 59字节（递归）

perl 5（`-n` `-M5.01`），32 30 25字节

杰普特 `-R`，9个字节