Trong toán học, giai thừa, rút ​​ngắn "thực tế" của một số nguyên n không âm , ký hiệu là n! , là tích của tất cả các số nguyên dương nhỏ hơn hoặc bằng n . Ví dụ: 5! là 1 * 2 * 3 * 4 * 5 = 120

Giai thừa của 0 là 1 , theo quy ước cho một sản phẩm trống.

Đây là những sự thật thường xuyên chúng ta đã quen. Hãy thêm một số lựa chọn thay thế:

1. Giai thừa (xác định ở trên)
2. Nhân tử kép: n !! = 1 + 2 + ... + n
3. Nhân tố ba: n !!! = 1 - (2 - (3 - (... - n))) ...)
4. Nhân tố tăng gấp bốn lần: n !!!! = 1 / (2 / (3 ... / n))) ...) . Lưu ý: Đây là phép chia điểm trôi nổi, không phải phép chia số nguyên.

Thử thách

Lấy một đầu vào số nguyên không âm n , theo sau trực tiếp từ 1 đến 4 dấu chấm than. Đầu vào sẽ trông (chính xác) như thế này: 0! , 5 !! , 132 !!! hoặc 4 !!!! . Trong thử thách này, bạn không thể giả sử một định dạng đầu vào linh hoạt, xin lỗi.

Đầu ra

Đầu ra phải là kết quả, trên bất kỳ định dạng thuận tiện. Kết quả của giai thừa bốn nhân phải có ít nhất 2 chữ số sau dấu thập phân, ngoại trừ 0 !!!! = 0 .

Các trường hợp thử nghiệm:

0! = 1
1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
6! = 720
7! = 5040
8! = 40320
9! = 362880
10! = 3628800
---
0!! = 0
1!! = 1
2!! = 3
3!! = 6
4!! = 10
5!! = 15
6!! = 21
7!! = 28
8!! = 36
9!! = 45
10!! = 55
---
0!!! = 0
1!!! = 1
2!!! = -1
3!!! = 2
4!!! = -2
5!!! = 3
6!!! = -3
7!!! = 4
8!!! = -4
9!!! = 5
10!!! = -5
---
0!!!! = 0
1!!!! = 1
2!!!! = 0.5
3!!!! = 1.5
4!!!! = 0.375
5!!!! = 1.875
6!!!! = 0.3125
7!!!! = 2.1875
8!!!! = 0.27344
9!!!! = 2.4609
10!!!! = 0.24609

Giải pháp ngắn nhất trong mỗi ngôn ngữ chiến thắng.

JavaScript (ES6), 88 byte

s=>eval(([a,b]=s.split(/\b/),g=k=>+a?k-a?k+'_*+-/'[b.length]+`(${g(k+1)})`:k:+!b[1])(1))

Các trường hợp thử nghiệm

let f =

s=>eval(([a,b]=s.split(/\b/),g=k=>+a?k-a?k+'_*+-/'[b.length]+`(${g(k+1)})`:k:+!b[1])(1))

for(o = '!'; o <= '!!!!'; o += '!') {
  for(n = 0; n <= 10; n++) {
    console.log(n + o + ' = ' + f(n + o));
  }
}

Định dạng và nhận xét

s =>                                // given the input string s,
  eval(                             // evaluate as JS code:
    ( [a, b] = s.split(/\b/),       //   a = integer (as string) / b = '!' string
      g = k =>                      //   g = recursive function taking k as input
        +a ?                        //     if a is not zero:
          k - a ?                   //       if k is not equal to a:
            k + '_*+-/'[b.length] + //         append k and the operation symbol
            `(${g(k + 1)})`         //         append the result of a recursive call
          :                         //       else:
            k                       //         just append k and stop recursion
        :                           //     else:
          +!b[1]                    //       return 1 for multiplication / 0 otherwise
    )(1)                            //   initial call to g() with k = 1
  )                                 // end of eval()

Husk , 15 byte

§!ëΠΣF-F/#'!oṫi

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

Giải trình

Lập chỉ mục vào một danh sách các chức năng: niềm vui của việc sử dụng ngôn ngữ chức năng.

§!ëΠΣF-F/#'!oṫi  Implicit input, say x = "6!!!"
              i  Convert to integer (parses the leading sequence of digits): 6
            oṫ   Descending range to 1: y = [6,5,4,3,2,1]
  ë              Four-element list containing the functions
   Π             product,
    Σ            sum,
     F-          left fold with subtraction (gives 0 for empty list), and
       F/        left fold with division (gives 0 for empty list).
 !               1-based index into this list with
         #'!     count of !-characters in input: gives F-
§                Apply to y and print implicitly: -3

Tôi sử dụng một phạm vi giảm dần và các nếp gấp bên trái, kể từ đó -và /đưa các đối số của chúng theo thứ tự ngược lại trong Husk.

C # (.NET Core) , 134 130 128 byte

s=>{double e=s.Split('!').Length,n=int.Parse(s.Trim('!')),i=n,r=n;for(;--i>0;)r=e>4?i/r:e>3?i-r:e>2?i+r:i*r;return n<1&e<3?1:r;}

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

Phần tốt nhất của việc chơi golf mã là những điều bạn học được khi cố gắng giải quyết các thử thách. Trong phần này tôi đã học được rằng trong C #, bạn có thể cắt các ký tự khác ngoài các khoảng trắng từ các chuỗi.

• 4 byte được lưu nhờ LiefdeWen!
• Đã lưu 2 byte vì tôi không cần phải trừ 1 s.Split('!').Length, chỉ cần sửa các giới hạn trong e>4?i/r:e>3?i-r:e>2?i+r:i*rvà n<1&e<3?1:r.

Perl 5 , 62 byte

Mã 61 byte + 1 cho -p.

$_=/^0!$/+eval join(qw{| *( +( -( /(}[s/!//g],1..$_).")"x--$_

Cảm ơn @GB đã chỉ ra một sự bỏ lỡ từ phía tôi!

Hãy thử trực tuyến! (cái này dùng -lđể dễ đọc)

R , 113 111 byte

function(s){z=strtoi((n=strsplit(s,'!')[[1]])[1])
n=length(n)
`if`(z,Reduce(c('*','+','-','/')[n],1:z,,T),n<2)}

Hãy thử một số trường hợp thử nghiệm!

vô dụng:

function(s){
  n <- strsplit(s,"!")[[1]]          # split on "!"
  z <- strtoi(n[1])                  # turn to integer
  n <- length(n)                     # count number of "!"
  FUN <- c(`*`,`+`,`-`,`/`)[[n]]     # select a function
  right <- TRUE                      # Reduce (fold) from the right
  if( z > 0)                         # if z > 0
    Reduce(FUN, 1:z,,right)          # return the value
  else    
    (n < 2)                          # 1 if n = 1, 0 if n > 1
}

Python3, 124 130 121 119 byte

Tại thời điểm này, tôi tin rằng đệ quy là chìa khóa để tiết kiệm byte hơn nữa.

s=input()
l=s.count('!')
v=int(s[:-l])+1
print(eval((" *+-/"[l]+"(").join(map(str,range(1,v)))+")"*(v-2)or"0")+(l<2>v))

Hãy thử các thử nghiệm trên Dùng thử trực tuyến!

-9 byte nhờ @ Mr.Xcoder !

-2 byte nhờ @Felipe Nardi Batista !

Bình thường , 34 30 byte

+uv++H@"/*+-"/Q\!G_tUK.vQKq"0!

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

Giải trình

+uv++H@"/*+-"/Q\!G_tUK.vQKq"0!"Q    Implicit: append "Q
                                    Implicit: read input to Q
                      .vQ           Evaluate Q as Pyth code. This evaluates the integer,
                                    any !'s are parsed as unary NOT for the next expression
                                    and discarded.
                     K              Save the result to K.
                    U               Get a list [0, 1, ..., K-1].
                   t                Drop the first item to get [1, 2, ..., K-1].
                  _                 Reverse to get [K-1, K-2, ..., 1].
 u                       K          Starting from G = K, for H in [K-1, K-2, ..., 1] do:
             /Q\!                     Count the !'s in Q.
      @"/*+-"                         Get the correct operator.
    +H                                Prepend the current H.
   +             G                    Append the previous value G.
  v                                   Evaluate as Python code.
                          q"0!"Q    See if Q == "0!".
+                                   If so, add 1.

05AB1E , 27 byte

þL"/*+-"¹'!¢©è".»"ì.VD_нi®Θ

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

Ruby , 83 80 79 byte

->s{z=s.count ?!;s<?1?1+1<=>z:eval([*1..w=s.to_i]*(".0"+"_*+-/"[z]+?()+?)*~-w)}

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

Giải trình:

->s{
    # Get number of !
    z=s.count ?!

    # Special case: if the number is 0, then output 0 or 1 depending on z
    s<?1?1+1<=>z:

    # Otherwise build the full expression as a string and then evaluate it
    eval([*1..w=s.to_i]*(".0"+"_*+-/"[z]+?()+?)*~-w)
}

Java 8, 141 136 134 byte

s->{float q=s.split("!",-1).length,n=new Float(s.split("!")[0]),i=n,r=n;for(;--i>0;r=q<3?i*r:q<4?i+r:q<5?i-r:i/r);return n<1&q<3?1:r;}

-5 byte (141 → 136) nhờ câu trả lời C # của @CarlosAlejo .

Giải trình:

Hãy thử nó ở đây.

s->{                                // Method with String parameter and float return-type
  float q=s.split("!",-1).length,   //  Amount of exclamation marks + 1
        n=new Float(s.split("!")[0]),
                                    //  The number before the exclamation marks
        i=n,                        //  Index (starting at `n`)
        r=n;                        //  Return sum (starting at `n`)
  for(;--i>0;                       //  Loop from `i-1` down to 1
    r=                              //   Change the result (`r`) to:
      q<3?                          //    If `q` is 2:
       i*r                          //     Multiply
      :q<4?                         //    Else if `q` is 3:
       i+r                          //     Addition
      :q<5?                         //    Else if `q` is 4:
       i-r                          //     Subtraction
      :                             //    Else (if `q` is 5):
       i/r                          //     Division
  );                                //  End of loop
  return n<1&q<3?                   //  Edge case if the input is `0!`:
          1                         //   Then return 1
         :                          //  Else:
          r;                        //   Return the result
}                                   // End of method

Thạch ,  24 23 26  25 byte

+  3  2 byte vá để sửa sau khi giải thích sai :(

×
+
_
÷
ṣ”!µḢVRṚȯL©Ị$®ŀ@/

Một chương trình đầy đủ (một liên kết đơn âm với các liên kết trợ giúp được tham chiếu theo vị trí chương trình)

Hãy thử trực tuyến! hoặc xem một bộ thử nghiệm .

Làm sao?

× - Link 1, multiply: number, number

+ - Link 2, add: number, number

_ - Link 1, subtract: number, number

÷ - Link 1, divide: number, number

ṣ”!µḢVRṚȯL©Ị$®ŀ@/ - Main link: list of characters, a
ṣ”!               - split s at '!' characters
   µ              - monadic separation, call that b
    Ḣ             - head - pop and yield the digit list from b, modifying b
     V            - evaluate as Jelly code (get the number, say N)
      R           - range = [1,2,3,...,N]
       Ṛ          - reverse = [N,...,3,2,1]
            $     - last two links as a monad:
         L        -   length of modified b (number of '!' characters)
          ©       -   (copy to register)
           Ị      -   insignificant? (1 when just one '!', 0 when two or more)
        ȯ         - logical or (1 for "0!", 0 for "0!!...", the reversed-range otherwise)
                / - cumulative reduce by:
               @  -  with swapped arguments:
              ŀ   -    dyadic call of link at index:
             ®    -      recall value from register (number of '!' characters)

Mã máy x86_64 tự sửa đổi, 123 byte

0f b6 0f 31 c0 eb 11 0f be c9 8d 04 80 8d 44 41 d0 0f b6 4f 01 48 ff c7 83 f9 21 75 ea b9 21 21 21 a1 33 0f 0f bc c9 81 c1 ff 07 00 00 c1 e9 03 0f b6 c9 89 ca 09 c2 74 35 55 48 89 e5 c7 45 fc 59 58 5c 5e 8a 4c 0d fc 88 0d 15 00 00 00 f3 0f 2a c8 83 f8 02 5d 7c 1f ff c8 0f 57 c0 f3 0f 2a c0 f3 0f 5e c1 83 f8 01 0f 28 c8 7f eb c3 f3 0f 10 05 03 01 00 00 c3 0f 28 c1 c3

Tại sao các ngôn ngữ được giải thích có thể tự động chạy mã với các evals ưa thích , nhưng không phải là mã máy đơn giản?

Hãy thử với:

#include <stdio.h>
#include <sys/mman.h>
#include <errno.h>

char ff[] = "\x0f\xb6\x0f\x31\xc0\xeb\x11\x0f\xbe\xc9\x8d\x04\x80\x8d\x44\x41\xd0\x0f\xb6\x4f\x01\x48\xff\xc7\x83\xf9\x21\x75\xea\xb9\x21\x21\x21\xa1\x33\x0f\x0f\xbc\xc9\x81\xc1\xff\x07\x00\x00\xc1\xe9\x03\x0f\xb6\xc9\x89\xca\x09\xc2\x74\x35\x55\x48\x89\xe5\xc7\x45\xfc\x59\x58\x5c\x5e\x8a\x4c\x0d\xfc\x88\x0d\x15\x00\x00\x00\xf3\x0f\x2a\xc8\x83\xf8\x02\x5d\x7c\x1f\xff\xc8\x0f\x57\xc0\xf3\x0f\x2a\xc0\xf3\x0f\x5e\xc1\x83\xf8\x01\x0f\x28\xc8\x7f\xeb\xc3\xf3\x0f\x10\x05\x03\x01\x00\x00\xc3\x0f\x28\xc1\xc3";
int main()
{
    char* page = (char*)((unsigned long)((char*)ff) & (~0xfffLL));
    if (mprotect(page, 0x1000, PROT_READ | PROT_WRITE | PROT_EXEC) < 0) {
        perror("mprotect");
        return -1;
    }
    float (*f)(char*) = (float (*)(char*))ff;
    char* testcases[] = { "0!","1!","2!","3!","4!","5!","6!","7!","8!","9!","10!",
                          "0!!","1!!","2!!","3!!","4!!","5!!","6!!","7!!","8!!","9!!","10!!",
                          "0!!!","1!!!","2!!!","3!!!","4!!!","5!!!","6!!!","7!!!","8!!!","9!!!","10!!!",
                          "0!!!!","1!!!!","2!!!!","3!!!!","4!!!!","5!!!!","6!!!!","7!!!!","8!!!!","9!!!!","10!!!!",
                        };
    for (int i = 0; i < 44; i++) {
        printf("%s -> %f\n", testcases[i], f(testcases[i]));
    }
}

Hội,, tổ hợp:

_f:
100000d4f:  0f b6 0f    movzx   ecx, byte ptr [rdi]
100000d52:  31 c0   xor eax, eax
100000d54:  eb 11   jmp 17 <_f+18>
100000d56:  0f be c9    movsx   ecx, cl
100000d59:  8d 04 80    lea eax, [rax + 4*rax]
100000d5c:  8d 44 41 d0     lea eax, [rcx + 2*rax - 48]
100000d60:  0f b6 4f 01     movzx   ecx, byte ptr [rdi + 1]
100000d64:  48 ff c7    inc rdi
100000d67:  83 f9 21    cmp ecx, 33
100000d6a:  75 ea   jne -22 <_f+7>
100000d6c:  b9 21 21 21 a1  mov ecx, 2703302945
100000d71:  33 0f   xor ecx, dword ptr [rdi]
100000d73:  0f bc c9    bsf ecx, ecx
100000d76:  81 c1 ff 07 00 00   add ecx, 2047
100000d7c:  c1 e9 03    shr ecx, 3
100000d7f:  0f b6 c9    movzx   ecx, cl
100000d82:  89 ca   mov edx, ecx
100000d84:  09 c2   or  edx, eax
100000d86:  74 35   je  53 <_f+6E>
100000d88:  55  push    rbp
100000d89:  48 89 e5    mov rbp, rsp
100000d8c:  c7 45 fc 59 58 5c 5e    mov dword ptr [rbp - 4], 1583110233
100000d93:  8a 4c 0d fc     mov cl, byte ptr [rbp + rcx - 4]
100000d97:  88 0d 15 00 00 00   mov byte ptr [rip + 21], cl
100000d9d:  f3 0f 2a c8     cvtsi2ss    xmm1, eax
100000da1:  83 f8 02    cmp eax, 2
100000da4:  5d  pop rbp
100000da5:  7c 1f   jl  31 <_f+77>
100000da7:  ff c8   dec eax
100000da9:  0f 57 c0    xorps   xmm0, xmm0
100000dac:  f3 0f 2a c0     cvtsi2ss    xmm0, eax
100000db0:  f3 0f 5e c1     divss   xmm0, xmm1
100000db4:  83 f8 01    cmp eax, 1
100000db7:  0f 28 c8    movaps  xmm1, xmm0
100000dba:  7f eb   jg  -21 <_f+58>
100000dbc:  c3  ret
100000dbd:  f3 0f 10 05 03 01 00 00     movss   xmm0, dword ptr [rip + 259]
100000dc5:  c3  ret
100000dc6:  0f 28 c1    movaps  xmm0, xmm1
100000dc9:  c3  ret

Giải thích sẽ được bổ sung sau. Ý tưởng cơ bản là để thay đổi divss xmm0, xmm1hướng dẫn tại 0x100000db0và thay thế bằng một mulss, addss, subsshoặc divsstheo toán hạng đã cung cấp. Một mẹo nhỏ cũng được sử dụng để phân tích chuỗi đầu vào.

Hội được tạo với:

float f (char* s)
{
    int x;
    for (x=0; *s != '!'; s++) {
        x=10*x + (*s-'0');
    }
    unsigned char op = (__builtin_ctz(*(unsigned int *)s ^ 0xa1212121)-1) >> 3;
    if (x == 0 && op == 0) {
        return 1;
    }
    unsigned int lookup = 0x5e5c5859;
    unsigned char new_code = ((unsigned char*)&lookup)[op];
    asm("movb %0, 0x15(%%rip)" : : "r" (new_code));
    float sum;
    for (sum = x--; x>0; x--) {
        sum = x / sum;
    }
    return sum;
}

Haskell, 105 102 98 96 byte

0!3=0
x!y=foldr([(*),(+),(-),(/)]!!y)([1,0,0,1]!!y)[1..x]
f s|[(n,b)]<-lex s=read n!(length b-1)

Đã lưu 9 byte nhờ Zgarb và nimi.

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

Gaia , 26 25 byte

ẋ)@d┅v;l“×+⁻÷”=“ₔ⊢”+e¤ḥ!∨

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

Giải trình

ẋ                          Split the input into runs of the same character.
 )                         Get the last one (the !'s).
  @                        Push an input (since there's none left, use the last one).
   d                       Parse as number (ignores the !'s).
    ┅v                     Get the reverse range: [n .. 1]
      ;                    Copy the ! string
       l“×+⁻÷”=            Get its length and index into this string of operators.
               “ₔ⊢”+       Append 'ₔ⊢' to the operator.
                    e      Eval the resulting string, which is "reduce by <operator> with
                            swapped arguments." Reducing an empty list gives 0.
                     ¤     Bring the !'s back to the top.
                      ḥ!   Remove the first character and check if it's empty.
                        ∨  Logical OR; turns 0 from 0! to 1, doesn't change anything else.

Thạch , 28 byte

×
+
_
÷
³ċ”!
ḟ”!VRṚ¢ŀ@/¢Ị¤¹?

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

Có ý tưởng tách các liên kết thành các dòng từ câu trả lời của Jonathan Allan cho -2 byte.

APL (Dyalog) , 30 byte

Lấy cảm hứng từ giải pháp của lstefano .

{0::0⋄(⍎'×+-⌹'⊃⍨≢⍵~⎕D)/⍳⍎⍵∩⎕D}

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

{... } chức năng ẩn danh mà lập luận được đại diện bởi ⍵:

 0:: nếu có lỗi xảy ra:

  0 trả về số không

 ⋄ bây giờ cố gắng:

  ⍵∩⎕D giao điểm của đối số và tập hợp D igits (loại bỏ các dấu chấm than)

  ⍎ thực hiện điều đó (biến nó thành một số)

  ⍳ ɩ thông tin về điều đó

  (... )/ chèn (APL là kết hợp đúng, nếu cần) các chức năng sau đây giữa các điều khoản:

   ⍵~⎕D đối số không có D igits (để lại dấu chấm than)

  ≢ kiểm đếm điều đó (tức là có bao nhiêu dấu chấm than)

  '×+-⌹'⊃⍨ sử dụng để chọn từ danh sách các ký hiệu *

  ⍎ thực hiện (biến biểu tượng thành một hàm)

⌹(phân chia ma trận) được sử dụng thay vì ÷(phân chia bình thường) để gây ra lỗi trong danh sách trống

Perl 5 , 96 byte

s/(\d+)//;@a=1..$1;$"=qw|* + -( /(|[$l=-1+length];$_=$1?"@a".($l>1?')'x($1-1):''):$l?0:1;$_=eval

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

APL Dyalog, ít nhất 29 ký tự

{(⍎i⊃'×+-÷')/⍳⍎⍵↓⍨-i←+/'!'=⍵}

Biểu thức là đúng. Nó vượt qua tất cả các trường hợp kiểm tra NGOẠI TRỪ 0!!!!mà nó đưa ra 1thay vì yêu cầu 0và đó là vì trong APL, việc giảm một vectơ trống được cho là trả về phần tử trung tính cho hàm được sử dụng để giảm. Đối với thương số đó là 1. Hiện tại tôi không có thời gian để thử và sửa nó nhưng tôi sẽ để nó ở đây cho một ngày mưa.

05AB1E , 25 24 byte

þDLðýs¹'!¢<"*+-/"ès<×J.V

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

Toán học, 152 byte

(T=ToExpression;If[#=="0!!!!",0,s=T@StringCount[#,"!"];t=T@StringDrop[#,-s];{#!,i~Sum~{i,#},Sum[-i(-1)^i,{i,#}],N@Product[1/i^(-1)^i,{i,#}]}[[s]]&[t]])&

Javascript, 111 163 byte

s=>([a,b]=s.split(/\b/),c=b.length,a==0&c==1||eval((p=[...Array(+a+1).keys()].slice(1).join(c-1?c-2?c-3?'/(':'-(':'+':'*'))+')'.repeat((p.match(/\(/g)||[]).length)))

Phiên bản dễ đọc

s=>([a,b]=s.split(/\b/),c=b.length,a==0&c==1||eval((p=
[...Array(+a+1).keys()].slice(1).join(c-1?c-2?c-3?'/(':'-
(':'+':'*'))+')'.repeat((p.match(/\(/g)||[]).length)))