Đừng nhầm lẫn với Tìm giai thừa!

Giới thiệu

Giai thừa của một số nguyên ncó thể được tính bằng

Điều này là tương đối dễ dàng và không có gì mới. Tuy nhiên, giai thừa có thể được mở rộng thành nhân tử kép , sao cho cho các số chẵn và cho các số lẻ. Nhưng chúng tôi không giới hạn ở hai giai thừa. Ví dụ: hoặc hoặc n !!! = n \ lần (n-3) \ lần (n-6) \ lần (...) \ lần4 \ lần1 tùy thuộc vào giá trị khởi đầu.

Tóm lại: trong đó Hoặc, bằng tiếng Anh đơn giản: Trừ số đếm giai thừa từ số cơ sở nhiều lần và nhân tất cả các số nguyên dương.

Các thách thức

Viết hàm sẽ tính bất kỳ loại nhân tử lặp lại cho bất kỳ số nguyên không âm nào.

Đầu vào

Hoặc

• Một chuỗi chứa một số nguyên mười cơ sở không âm, theo sau là 1 hoặc nhiều dấu chấm than. Ví dụ "6!"hay "9!!"hay "40!!!!!!!!!!!!!!!!!!!!".

hoặc là

• Các giá trị giống nhau được biểu thị bằng hai số nguyên: một giá trị cơ bản không âm và một giá trị dương biểu thị số giai thừa. Điều này có thể được thực hiện theo bất kỳ định dạng nào từ các quy tắc I / O mặc định.

Đầu ra

Kết quả tính toán nói trên.

Nhận xét thách thức

• 0!bằng 1định nghĩa. Mã của bạn phải chiếm tài khoản này.
• Số lượng giai thừa được giới hạn bởi ngoài phạm vi này, bạn có thể tự do xuất bất cứ thứ gì. Ngoài ra , đó là ngoại lệ duy nhất cho quy tắc này. $$0 < factorial~count \leq base~value$$ 0!

Ví dụ

Input                              Output

3!!!                               3
0!                                 1
6!                                 720
9!!                                945
10!!!!!!!!                         20
40!!!!!!!!!!!!!!!!!!!!             800
420!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!  41697106428257280000000000000000

Hãy thử nó với một triển khai Python chưa được chỉnh sửa: Hãy thử trực tuyến!

Nhận xét chung

• Đây là môn đánh gôn , vì vậy câu trả lời sử dụng ít byte nhất trong mỗi ngôn ngữ sẽ thắng.
• Quy tắc chuẩn , quy tắc I / O và quy tắc kẽ hở được áp dụng.
• Vui lòng bao gồm một liên kết Dùng thử trực tuyến để chứng minh mã của bạn hoạt động.
• Hãy thúc đẩy câu trả lời của bạn với một lời giải thích về mã của bạn.

R , 33 byte

function(n,k)prod(seq(n+!n,1,-k))

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

Xử lý $n=0$ bằng cách thêm phủ định logic của $n$ .

ArnoldC , 702 698 634 byte

LISTEN TO ME VERY CAREFULLY f
I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE n
I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE p
GIVE THESE PEOPLE AIR
HEY CHRISTMAS TREE r
YOU SET US UP 1
HEY CHRISTMAS TREE c
YOU SET US UP 0
STICK AROUND n
GET TO THE CHOPPER r
HERE IS MY INVITATION r
YOU'RE FIRED n
ENOUGH TALK
GET TO THE CHOPPER n
HERE IS MY INVITATION n
GET DOWN p
ENOUGH TALK
GET TO THE CHOPPER c
HERE IS MY INVITATION 0
LET OFF SOME STEAM BENNET n
ENOUGH TALK
BECAUSE I'M GOING TO SAY PLEASE c
GET TO THE CHOPPER n
HERE IS MY INVITATION 0
ENOUGH TALK
YOU HAVE NO RESPECT FOR LOGIC
CHILL
I'LL BE BACK r
HASTA LA VISTA, BABY

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

Được dịch sang mã giả:

f(n,p) {
  r=1;
  c=0;
  while (n) {
    r=r*n;
    n=n-p;
    c=n<0;
    if (c) n=0;
  }
  return r;
}

Lưu ý: ArnoldC chỉ có một loại dữ liệu: số nguyên có chữ ký 16 bit. Do đó tôi không thể kiểm tra 420!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!trường hợp.

Thạch , 4 byte

RṚmP

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

Làm sao? Với $n$ và $k$ , đầu tiên nó tạo ra phạm vi $n,\cdots, 1$ (với RṚ), sau đó với mnó giữ mỗi $k^{\text{th}}$ yếu tố của phạm vi này (do đó $n, n-k, n-2k,\cdots,n-\lfloor n/k\rfloor k$ ), và cuối cùng nhân chúng bằng cách sử dụng P.

APL (Dyalog Extended) , 7 byte ^SBCS

Chức năng tiền tố ẩn danh. Đưa ra [n,b]như là đối số.

×/-\…1¨

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

1¨ một cho mỗi yếu tố của đối số; [1,1]

-\ chênh lệch tích lũy; [n,n-b]

… phạm vi sử dụng phần tử thứ hai của đối số bên trái làm chỉ báo của bước, ví dụ: [9,7]tiếp tục với5

×/ sản phẩm

Haskell , 21 byte

n%a=product[n,n-a..1]

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

Kết hợp chức năng sản phẩm tích hợp với phép liệt kê phạm vi bước sẽ đánh bại đệ quy (thậm chí với flawr tiết kiệm một byte).

22 byte

n%a|n<1=1|m<-n-a=n*m%a

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

Đây là một giải pháp lấy đầu vào ở định dạng chuỗi như thế 9!!, mà tôi nghĩ là thú vị hơn.

42 byte

(\[(n,a)]->product[n,n-length a..1]).reads

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

Bình thường , 6 byte

Đây là tất cả 6-byters tương đương:

*F:Q1E
*F:E1Q
*F%E_S

Hãy thử trực tuyến! ( *F:Q1E)

Hoặc, 11 byte , lấy đầu vào là một chuỗi:

*F:.vQ1/Q\!

Bộ thử nghiệm.

JavaScript (ES6), 21 byte

Đưa đầu vào là (k)(n).

k=>g=n=>n<1||n*g(n-k)

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

Hoặc 24 byte để hỗ trợ BigInts.

JavaScript (ES6), 55 byte

Lấy đầu vào dưới dạng một chuỗi, sử dụng định dạng được mô tả trong thử thách.

s=>(a=s.split`!`,k=a.length-1,g=n=>n<1||n*g(n-k))(a[0])

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

Khoảng trắng , 91 byte

[S S S T    N
Push_1][S N
S _Duplicate_1][S N
S _Duplicate_1][T   N
T   T   _Read_STDIN_as_integer_(base)][T    T   T   _Retrieve_base][S S S N
_Push_0][T  N
T   T   _Read_STDIN_as_integer_(factorial)][N
S S N
_Create_Label_LOOP][S N
S _Duplicate_base][S S S T  N
_Push_1][T  S S T   _Subtract][N
T   T   S N
_If_negative_jump_to_Label_PRINT_RESULT][S N
S _Duplicate_base][S T  S S T   S N
_Copy_0-based_2nd_(result)][T   S S N
_Multiply][S N
T   _Swap_top_two][S S S N
_Push_0][T  T   T   _Retrieve_factorial][T  S S T   _Subtract][N
S N
N
_Jump_to_Label_LOOP][N
S S S N
_Create_Label_PRINT_RESULT][S N
N
_Discard_top][T N
S T _Print_result_as_integer]

Chữ cái S(dấu cách), T(tab) và N(dòng mới) được thêm vào dưới dạng chỉ tô sáng.
[..._some_action]chỉ thêm vào giải thích.

Hãy thử trực tuyến (chỉ với không gian thô, tab và dòng mới).

Giải thích bằng mã giả:

Integer result = 1
Integer base = STDIN as integer
Integer factorial = STDIN as integer
Start LOOP:
  If(base <= 0):
    Call function PRINT_RESULT
  result = result * base
  base = base - factorial
  Go to next iteration of LOOP

function PRINT_RESULT:
  Print result as integer to STDOUT

Python 2 , 29 byte

f=lambda n,b:n<1or n*f(n-b,b)

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

Perl 6 , 22 byte

{[*] $^a,*-$^b...^1>*}

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

Codeblock ẩn danh trả về sản phẩm của phạm vi bắt đầu từ đầu vào đầu tiên, giảm lần thứ hai cho đến khi nó ở dưới 1, không bao gồm số cuối cùng. Điều này hoạt động 0, vì trường hợp cơ bản của sản phẩm giảm là 1, vì vậy đầu ra là 1.

05AB1E , 10 8 7 byte

ݦRIιнP

Đầu vào là hai đầu vào riêng biệt: đầu vào đầu tiên base; đầu vào thứ hai factorial.

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

-2 byte nhờ @ Mr.Xcoder .
-1 byte nhờ @Jonathan ALLan .

Giải trình:

Ý        # Create a list in the range [0, (implicit) base-input]
 ¦       # And remove the first item to make it the range [1, base]
         # (NOTE: this is for the edge case 0. For the other test cases simply `L` instead
         #  of `ݦ` is enough.)
  R      # Reverse this list so the range is [base, 1]
   Iι    # Uninterleave with the second input as step-size
         #  i.e. base=3, factorial=7: [[3],[2],[1],[],[],[],[]]
         #  i.e. base=10, factorial=8: [[10,2],[9,1],[8],[7],[6],[5],[4],[3]]
         #  i.e. base=420, factorial=30: [[420,390,360,...,90,60,30],[419,389,359,...],...]
     н   # Only leave the first inner list
      P  # And take the product of its values
         # (which is output implicitly as result)

Câu trả lời gốc 10 byte :

L0KD¤-IÖÏP

Đầu vào là hai đầu vào riêng biệt: đầu vào đầu tiên base; đầu vào thứ hai factorial.

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:

L           # Create a list in the range [1, (implicit) base-input]
 0K         # Remove all 0s (edge case for input 0, which will become the list [1,0])
   D        # Duplicate this list
    ¤       # Get the last value (without popping)
            # (could also be `Z` or `¹` for max_without_popping / first input respectively)
     -      # Subtract it from each item in the list
      IÖ    # Check for each if they're divisible by the second factorial-input
        Ï   # In the list we copied, only leave the values at the truthy indices
         P  # And take the product of those
            # (which is output implicitly as result)

mã máy x86-64, 12 byte

Cùng một mã máy thực hiện điều tương tự ở chế độ 32 bit và đối với số nguyên 16 bit ở chế độ 16 bit.

Đây là một chức năng, có thể được gọi với args n=RCX, k=ESI. Giá trị trả về 32 bit trong EAX.

Có thể gọi từ C với quy ước gọi System V x86-64 với các đối số giả để đưa các đối số thực vào các thanh ghi bên phải. uint32_t factk(int, uint32_t k, int, uint64_t n); Tôi không thể chỉ sử dụng Windows x64 vì 1 toán tử mulchặn RDX và chúng tôi không muốn tiền tố REX truy cập R8 / R9. nkhông được có bất kỳ rác nào trong 32 bit cao để JRCXZ hoạt động, nhưng ngoài ra đó là tất cả 32 bit.

Danh sách NASM (địa chỉ tương đối, mã máy, nguồn)

 1                         factk:
 2 00000000 6A01             push 1
 3 00000002 58               pop rax             ; retval = 1
 4 00000003 E306             jrcxz  .n_zero      ; if (n==0) return
 5                         .loop:                ; do {
 6 00000005 F7E1              mul   ecx            ; retval *= n  (clobbering RDX)
 7 00000007 29F1              sub   ecx, esi       ; n -= k
 8 00000009 77FA              ja   .loop         ; }while(sub didn't wrap or give zero)
 9                         .n_zero:
10 0000000B C3               ret

0xc = 12 byte

Hoặc 10 byte nếu chúng ta không cần xử lý n=0trường hợp đặc biệt, bỏ qua jrcxz.

Đối với giai thừa tiêu chuẩn, bạn sử dụng loopthay vì phụ / ja để lưu 2 byte, nhưng nếu không thì cùng một mã.

Kiểm tra người gọi mà đi argcnhư k, với nmã hóa cứng.

align 16
global _start
_start:
  mov  esi, [rsp]
;main:
  mov  ecx, 9
  call factk

  mov  esi, eax
  mov  edx, eax
  lea  rdi, [rel print_format]
  xor  eax, eax
extern printf
  call printf
extern exit
  call exit

section .rodata
print_format: db `%#x\t%u\n`

```

APL (Dyalog Unicode) , 11 byte ^SBCS

Chức năng ẩn danh ẩn danh. Đưa ra nnhư là đối số phải và bnhư là đối số trái.

×/1⌈⊢,⊢-×∘⍳

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

×∘⍳ nhân bbởi ɩ ntegers từ 1 đếnn

⊢- trừ đi từ n

⊢, trả trước n

1⌈ tối đa của một và mỗi người

×/ sản phẩm

Ruby , 25 byte

f=->s,r{s<1?1:s*f[s-r,r]}

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

Ngôn ngữ Wolfram (Mathicala) , 22 21 byte

1##&@@Range[#,1,-#2]&

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

-1 nhờ attinat: Times --> 1##&

Giải thích: sử dụng Rangeđể lập danh sách các giá trị {n, n-k, n-2k, n-3k, ...}, dừng trước khi xuống dưới 1 (nghĩa là dừng vừa phải). Sau đó nhân tất cả các số trong danh sách này với Times(hoặc 1##&).

Java 10, 44 byte

f->b->{int r=1;for(;b>0;b-=f)r*=b;return r;}

Lấy giai thừa làm đầu vào đầu tiên, cơ sở là thứ hai.

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

Điều này ở trên không hoạt động cho trường hợp thử nghiệm lớn nhất do phạm vi số nguyên giới hạn (32 bit). Để khắc phục điều này, chúng ta có thể sử dụng BigIntegers, điều trùng hợp là gấp đôi chính xác kích thước - 88 79 byte :

f->b->{var r=f.ONE;for(;b.signum()>0;b=b.subtract(f))r=r.multiply(b);return r;}

-9 byte nhờ @ OlivierGrégoire .

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

Giải trình:

f->b->{       // Method with two integer parameters and integer return-type
  int r=1;    //  Result-integer, starting at 1
  for(;b>0;   //  Loop as long as the base is still larger than 0
      b-=f)   //    After every iteration: decrease the base by the factorial
    r*=b;     //   Multiply the result by the base
  return r;}  //  Return the result

Japt , 8 byte

TõUV f ×

Thử nó

-1 nhờ EoI chỉ ra Shaggy không bị câm có thể như thế nào!

C (gcc) , 41 byte

r;f(n,k){for(r=1;n>0;n-=k)r*=n;return r;}

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

MathGolf , 7 6 byte

╙╒x%ε*

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

Tìm thấy một cách thông minh để xử lý 0! mà không thay đổi các trường hợp thử nghiệm khác. Lấy đầu vào là k n(thứ tự ngược lại), giúp với popping ngầm.

Giải trình

╙        maximum of two elements (pops largest of k and n,
         which is n for every valid case except 0!, where 1 is pushed)
 ╒       range(1,n+1)
  x      reverse int/array/string
   %     slice every k:th element
    ε*   reduce list with multiplication

Tùy viên , 21 19 byte

${x<y∨x*$[x-y,y]}

Hãy thử trực tuyến! Thực hiện đệ quy khá trực tiếp. (Lưu ý: truevề cơ bản 1, vì nó có thể được sử dụng trong các phép toán số học 1.) Đây là một trong số ít các chương trình tôi đã viết cho trang web này, nơi sử dụng toán tử unicode tiết kiệm byte (chính xác là 1).

Lựa chọn thay thế

20 byte: ${x<y or x*$[x-y,y]}

21 byte: Prod@${{_%y=x%y}\1:x}

27 byte: ${x*[`1,$][x>y][x-y,y]∨1}

27 byte: ${If[x>y,x*$[x-y,y],_or 1]}

27 byte: ${x*[`1,$][x>y][x-y,y]or 1}

29 byte: ${If[x>y,x*$[x-y,y],_+not _]}

Rust , 92 73 61 byte

fn f(n:i128,k:i128)->i128{if n<=0{return 1}return n*f(n-k,k)}

Tôi mới bắt đầu học rỉ sét, vì vậy tôi chắc chắn điều này có thể ngắn hơn. Sẽ cập nhật khi tôi học. Giá trị trả về phải là i128để tính toán thử nghiệm cuối cùng.

Chỉnh sửa: Đệ quy ngắn hơn.

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

Bạn có thể thêm bài kiểm tra của riêng mình hoặc chỉnh sửa một trong những bài kiểm tra đã có.

q , 59 57 55 53 byte

{prd 2+(&)1_i=last i:("J"$x(&)not[n])#(!)sum n:"!"=x}

giải trình:

q)x:"12!!" / let our input be 12!!, assign to x
q)sum n:"!"=x / count "!"s
2i
q)(!)sum n:"!"=x / (!)m -> [0,m)
0 1
q)("J"$x(&)not[n]) / isolate the number in input
12
q)("J"$x(&)not[n])#(!)sum n:"!"=x / x#y means take x items from list y, if x>y, circle around
0 1 0 1 0 1 0 1 0 1 0 1
q)i:("J"$x(&)not[n])#(!)sum n:"!"=x / assign to i
q)i
0 1 0 1 0 1 0 1 0 1 0 1
q)(last i)=i:("J"$x(&)not[n])#(!)sum n:"!"=x / take last elem of i and see which are equal in i
010101010101b
q)1_(last i)=i:("J"$x(&)not[n])#(!)sum n:"!"=x / drop first elem
10101010101b
q)(&)1_(last i)=i:("J"$x(&)not[n])#(!)sum n:"!"=x / indices of 1b (boolean TRUE)
0 2 4 6 8 10
q)2+(&)1_(last i)=i:("J"$x(&)not[n])#(!)sum n:"!"=x / add 2 across array
2 4 6 8 10 12
q)prd 2+(&)1_(last i)=i:("J"$x(&)not[n])#(!)sum n:"!"=x / product across array
46080

đây cũng là một phiên bản trong k (cùng logic), 42 41 byte

{*/2+&1_i=last i:("J"$x@&~:n)#!+/n:"!"=x}

Physica , 22 byte

f=>n;k:n<1||n*f[n-k;k]

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

26 byte

Học lại cách sử dụng "ngôn ngữ" của riêng tôi \ o / ... Nếu tôi biết cách viết một trình phân tích cú pháp 2 năm trước, thì đây sẽ là 20 byte :(

->n;k:GenMul##[n…1]{%%k}

hoặc là

->n;k:GenMul##Range[n;1;k]

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

Võng mạc , 66 byte

^0
1
\d+
*!,
+`(!+)(!+),\1$
$1$2,$2,$1
!+$
1
+`(!+),(\d+)
$.($2*$1

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp kiểm tra nhanh hơn. Số mauls mà không có dấu chấm than. Giải trình:

^0
1

Sửa chữa lên 0!.

\d+
*!,

Chuyển đổi nsang unary và thêm một dấu phân cách.

+`(!+)(!+),\1$
$1$2,$2,$1

Liên tục trừ ktừ nkhi n>k, và thu thập kết quả.

!+$
1

Thay thế kbằng 1(ở dạng thập phân).

+`(!+),(\d+)
$.($2*$1

Nhân với từng giá trị trung gian lần lượt, chuyển đổi thành số thập phân.

Japt , 8 byte

1õUV f ×

Thử nó

JavaScript (Node.js) , 35 byte

(n,i,f=i)=>i-n<1?f:r(n,i-n,f*(i-n))

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

Forth (gforth) , 50 byte

: f 1 1 2over / 1+ 0 do 2over i * - 1 max * loop ;

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

Giải thích mã

: f                \ start a new word definition
  1 1              \ add placeholder and accumulator to stack
  2over / 1+       \ get the number of times to run the loop (num/factorial + 1)
  0 do             \ start loop from 0 to num/factorial
    2over          \ copy num and factorial to the top of the stack
    i * -          \ get the current number to multiply by (num - factorial * i)
    1 max          \ make sure it can't be 0 or negative [set to 1 if it is]
    *              \ multiply accumulator by result
  loop             \ end loop
;                  \ end the word definition           

Perl 5 -Mbigint -p , 45 byte

$b=s/!//g;$\=1*$_||1;$\*=$_ while($_-=$b)>0}{

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

Stax , 6 byte

å▐█ΩV∟

Chạy và gỡ lỗi nó

Nó nhận đầu vào trong mẫu {count} {base}.

Gaia , 6 byte

…)¦v%Π

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

Có đầu vào là n, kvì vậy đầu vào 3 4sẽ là 3!!!!.

…	 push [0...n-1], or [] if n == 0
 )¦	 increment each value (does nothing if [])
   v	 reverse list
    %	 take every k'th element
     Π	 product; product([]) = 1.