Kiên trì nhân

1. Nhân tất cả các chữ số trong một số
2. Lặp lại cho đến khi bạn còn lại một chữ số

Theo giải thích của Numberphile :

• Numberphile "Có gì đặc biệt về 277777788888899?"
• Numberphile "Sự kiên trì nhân rộng (cảnh quay thêm)"

Thí dụ

1. 277777788888899 → 2x7x7x7x7x7x7x8x8x8x8x8x8x9x9 = 4996238671872
2. 4996238671872 → 4x9x9x6x2x3x8x6x7x1x8x7x2 = 438939448
3. 438939448 → 4x3x8x9x3x9x6x4x8 = 4478976
4. 4478976 → 4x4x7x8x9x7x6 = 338688
5. 338688 → 3x3x8x6x8x8 = 27648
6. 27648 → 2x7x6x4x8 = 2688
7. 2688 → 2x6x8x8 = 768
8. 768 → 7x6x8 = 336
9. 336 → 3x3x6 = 54
10. 54 → 5x4 = 20
11. 20 → 2x0 = 0

Đây là bản ghi hiện tại, bằng cách này: số nhỏ nhất với số bước lớn nhất.

Golf

Một chương trình lấy bất kỳ số nguyên nào làm đầu vào và sau đó xuất kết quả của từng bước, bắt đầu với chính đầu vào, cho đến khi chúng ta đạt được một chữ số. Đối với 277777788888899, đầu ra phải là

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

(Đếm số bước được để lại dưới dạng bài tập cho người dùng).

Thêm ví dụ

Từ A003001 :

25
10
0

Từ A003001 cũng vậy:

68889
27648
2688
768
336
54
20
0

Từ video Numberphile :

327
42
8

Vì vậy, đã có một câu hỏi về sự kiên trì phụ gia , nhưng đây là sự kiên trì nhân rộng. Ngoài ra, câu hỏi đó yêu cầu số bước là đầu ra, trong khi tôi muốn xem kết quả trung gian.

Thạch , 4 byte

DP$Ƭ

Hãy thử trực tuyến!

Giải trình

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

Là một phần thưởng, đây là một TIO sẽ tìm các số có số bước lớn nhất cho một phạm vi số chữ số đã cho. Nó quy mô tốt ngay cả trên TIO.

TI-BASIC (TI-84), 30 32 31 byte

-1 byte nhờ @SolomonUcko!

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

Đầu vào là trong Ans.
Đầu ra được hiển thị như các yêu cầu thách thức. Các dấu Anslà cần thiết để in bước cuối cùng.

Tôi sẽ thừa nhận, bản thân tôi đã không nghĩ đến công thức này, thay vào đó tôi đã tìm thấy nó ở đây và sửa đổi nó để phù hợp hơn với thử thách.

EDIT: Khi đọc lại thử thách, tôi nhận ra rằng chương trình phải chấm dứt nếu sản phẩm là một chữ số. Do đó, 2 byte đã được thêm vào tài khoản này.

Thí dụ:

24456756
        24456756
prgmCDGF8
        24456756
          201600
               0
11112
           11112
prgmCDGF8
           11112
               2

Giải trình:

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

Mô hình trực quan:
Ans bắt đầu như 125673.
Mô hình này chỉ bao gồm logic đằng sau nhân các chữ số; mọi thứ khác dễ hiểu hơn.

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)

Ghi chú:

TI-BASIC là một ngôn ngữ được mã hóa. Số lượng ký tự không bằng số byte.

10^(là mã thông báo một byte này .

Chương trình này sẽ không cung cấp đúng chuỗi sản phẩm có số nguyên dài hơn 14 chữ số do giới hạn của độ chính xác thập phân trên máy tính TI.

K (ngn / k) , 9 byte

{*/.'$x}\

Hãy thử trực tuyến!

{ }\ tiếp tục áp dụng hàm trong các dấu ngoặc nhọn cho đến khi chuỗi hội tụ

$x định dạng đối số dưới dạng một chuỗi (danh sách các ký tự)

.'đánh giá từng (phương ngữ khác của k yêu cầu một dấu hai chấm, .:')

*/ lần hơn, tức là sản phẩm

dzaima / APL , 14 11 byte

∪{×/⍎¨⍕⍵}⍡≡

Hãy thử trực tuyến!

R , 59 byte

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

Hãy thử trực tuyến!

Vì print invisiblytrả về đầu vào của nó, chúng ta có thể sử dụng print(n)bên trong whilevòng lặp để mô phỏng một do-whilevòng lặp. Này được lấy cảm hứng từ một trong tôi lời khuyên cho việc chơi golf trong R .

Tiêu đề giúp ngăn chặn số lượng lớn được in trong ký hiệu khoa học.

05AB1E , 7 4 byte

Δ=SP

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

Δ     # 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

Ngôn ngữ Wolfram (Mathicala) , 47 byte

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

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 45 byte

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

Hãy thử trực tuyến!

Perl 6 , 23 byte

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

Hãy thử trực tuyến!

Python 2 ,  46  43 byte

-3 nhờ xnor (so sánh chuỗi)

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

Hãy thử trực tuyến!

PowerShell , 54 byte

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

Hãy thử trực tuyến!

Phương thức lặp đầu tiên viết đối số đầu vào, sau đó chuyển đổi nó thành một chuỗi và chuyển nó thành một mảng ký tự. Mảng này được nối bởi một dấu sao đơn và được thực thi như một lệnh với bí danh biểu thức gọi. Vì phần này ghi số Bắt đầu xuống số cuối lớn hơn 0, (20, trong kịch bản kiểm tra đã cho), tôi thêm một số cuối $avào cuối để xuất.

C # (Trình biên dịch tương tác Visual C #) , 79 74 68 byte

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

Tôi cố gắng tránh xa đệ quy trong C # do thời gian khai báo phương thức là bao lâu, nhưng trong trường hợp này nó sẽ tiết kiệm so với một vòng lặp.

Hãy thử trực tuyến!

PHP , 63 byte

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

Phiên bản lặp, gọi với php -nFđầu vào từ STDIN.

Hãy thử trực tuyến!

PHP ,72 71 byte

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

Hãy thử trực tuyến!

Phiên bản đệ quy, như chức năng.

Đầu vào: 277777788888899

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

Đầu vào: 23

23
6

Python 2 , 61 62 59 byte

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

Hãy thử trực tuyến!

_{-3 byte, nhờ Jonathan Allan}

perl 5 ( -n -M5.01), 32 30 25 byte

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

25 byte

30 byte

32 byte

MathGolf , 9 10 byte

h(ôo▒ε*h(→

Hãy thử trực tuyến!

Bây giờ nó xử lý chính xác các đầu vào là một chữ số. Không hoàn hảo, nhưng ít nhất nó là chính xác.

Giải trình

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)

Julia 0,7 , 36 33 byte

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

Hãy thử trực tuyến!

Cảm ơn H.PWiz cho -3 byte.

JavaScript (ES6), 45 byte

Trả về một mảng các số nguyên.

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

Hãy thử trực tuyến!

PowerShell , 51 byte

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

Hãy thử trực tuyến!

APL (NARS), 19 ký tự, 38 byte

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

kiểm tra:

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

Haskell, 45 byte

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

Hãy thử trực tuyến!

J , 16 byte

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

Hãy thử trực tuyến!

Ruby , 38 35 34 byte

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

Hãy thử trực tuyến!

1 byte được lưu bởi G B.

Japt -R , 9 byte

Không hiệu quả khủng khiếp - thậm chí không thử chạy trường hợp thử nghiệm đầu tiên!

_ì ×}hN â

Thử nó

_ì ×}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

Brachylog , 7 byte

ẉ?Ḋ|ẹ×↰

Hãy thử trực tuyến!

Giải trình

ẉ          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

JavaScript (Nút Babel) , 46 byte

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

Hãy thử trực tuyến!

JavaScript (Nút Babel) , 44 byte

Nếu đầu vào có thể được lấy là Chuỗi

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

Hãy thử trực tuyến!

PowerShell , 64 59 byte

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

Hãy thử trực tuyến!

Phương pháp lặp. Đưa đầu vào và lưu trữ vào $a, sau đó vào một forvòng lặp miễn là độ dài bằng $ahai hoặc nhiều hơn (nghĩa là nó lớn hơn 9). Trong vòng lặp, chúng ta xuất ra $avà sau đó tính toán lại bằng cách chuyển đổi nó toCharArra y, kết joinhợp nó với *, và sau đó iex(viết tắt Invoke-Expressionvà tương tự như eval). Khi chúng tôi ra khỏi vòng lặp, chúng tôi chỉ còn một chữ số để in, vì vậy chúng tôi lại đặt $alên đường ống.

-5 byte nhờ KGlasier.

Than , 13 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

θ

In đầu vào lần đầu tiên.

Ｗ⊖Ｌθ«

Lặp lại trong khi độ dài của đầu vào không phải là 1.

≔ＩΠθθ

Thay thế đầu vào bằng sản phẩm kỹ thuật số của nó thành chuỗi.

⸿θ

In đầu vào trên một dòng mới.

Võng mạc , 24 byte

.+~(\`

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

Hãy thử trực tuyến! Giải trình:

.+~(\`

In giá trị hiện tại trên dòng riêng của nó ở đầu mỗi vòng lặp cho đến khi nó dừng thay đổi và không in giá trị không thay đổi hai lần. Đánh giá giá trị hiện tại ở cuối mỗi vòng lặp.

.
$&$*

Thêm một *sau mỗi chữ số.

^
.+¶$$.(

Kết thúc biến đầu vào thành một biểu thức đánh giá cho sản phẩm kỹ thuật số.

Chỉ cần cho bản ghi, Retina có thể làm điều này trong một dòng (25 byte):

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

C (gcc) , 58 byte

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

Hãy thử trực tuyến!

Cách tiếp cận lặp lại hóa ra ngắn hơn 1 byte.

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 byte (đệ quy)

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

Hãy thử trực tuyến!

Đệ quy dường như ngắn hơn lặp lại cho cả in và bước ...