수학에서 음수가 아닌 정수 n 의 계승으로 단축 된 "사실"은 n 으로 표시됩니다 ! , n 보다 작거나 같은 모든 양의 정수의 곱입니다 . 예를 들어 5! 이고 1 * 2 * 3 * 5 * 4 = 120

빈 제품에 대한 규칙에 따라 계승 0 은 1 입니다.

이것들은 우리가 익숙한 일반적인 사실입니다. 대안을 추가합시다 :

1. 계승 (위에 정의)
2. 이중 계승 : n !! = 1 + 2 + ... + n
3. 삼중 계승 : n !!! = 1-(2-(3-(...-n))) ...)
4. 4 배 계승 : n !!!! = 1 / (2 / (3 ... / n))) ...) . 참고 : 이것은 정수 나누기가 아닌 부동 소수점 나누기입니다.

도전

음이 아닌 정수 입력 받아 N 직접 사이이어서 1 및 4 느낌표한다. 입력은 다음과 같이 (정확하게) 보일 것입니다 : 0! , 5 !! , 132 !!! 또는 4 !!!! . 이 과제에서는 유연한 입력 형식을 가정하지 않아도됩니다. 죄송합니다.

산출

출력은 편리한 형식으로 결과가되어야합니다. 4 중 계승의 결과는 소수점을 제외한 2 자리 이상이어야합니다 ( 0 제외). !!! = 0 입니다.

테스트 사례 :

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

각 언어에서 가장 짧은 솔루션이 이깁니다.

자바 스크립트 (ES6), 88 바이트

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

테스트 사례

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));
  }
}

형식화 및 의견

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()

껍질 , 15 바이트

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

온라인으로 사용해보십시오!

설명

기능 목록으로 인덱싱 : 기능적 언어를 사용하는 기쁨.

§!ëΠΣ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

나는 이후, 내림차순 범위와 왼쪽 주름을 사용 -하고 /껍질의 역순으로 자신의 인수를.

C # (. NET 코어) , 134130128 바이트

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;}

온라인으로 사용해보십시오!

코드 골프의 가장 중요한 부분은 도전 과제를 해결하는 동안 배우는 것입니다. 이 중 C #에서는 문자열의 공백 외에도 다른 문자를자를 수 있다는 것을 배웠습니다.

• LiefdeWen 덕분에 4 바이트가 절약되었습니다!
• 내가하는 일을 빼줄 필요가 없기 때문에 2 바이트 저장 s.Split('!').Length, 그냥 한계를 해결 e>4?i/r:e>3?i-r:e>2?i+r:i*r하고 n<1&e<3?1:r.

펄 5 , 62 바이트

61 바이트 코드 + 1 -p.

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

내 부분을 놓친 점 을 지적한 @GB 에게 감사합니다 !

온라인으로 사용해보십시오! (이것은 -l가독성을 위해 사용 합니다)

R , 113111 바이트

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

몇 가지 테스트 사례를 시도하십시오!

언 골프 :

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 바이트

이 시점에서 나는 재귀가 바이트 절약을위한 열쇠라고 생각합니다.

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))

온라인 에서 사용해보십시오!

@ Mr.Xcoder 덕분에 -9 바이트 !

@Felipe Nardi Batista 덕분에 -2 바이트 !

Pyth , 34 30 바이트

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

온라인으로 사용해보십시오!

설명

+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 바이트

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

온라인으로 사용해보십시오!

루비 , 83 80 79 바이트

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

온라인으로 사용해보십시오!

설명:

->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)
}

자바 (8) 141 136 134 바이트

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;}

@CarlosAlejo 의 C # 답변 덕분에 -5 바이트 (141 → 136) .

설명:

여기에서 시도하십시오.

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

젤리 ,  24 23 26  25 바이트

+  3  2 바이트의 잘못된 해석 후 수정 패치

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

전체 프로그램 (프로그램 위치에서 참조되는 헬퍼 링크가있는 모나드 링크)

온라인으로 사용해보십시오! 또는 테스트 스위트를 참조하십시오.

어떻게?

× - 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)

자체 수정 x86_64 머신 코드, 123 바이트

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

해석 된 언어가 화려한 코드를 동적으로 실행할 수있는 이유 eval 일반 머신 코드가 아닌 입니까?

그것을 사용해보십시오 :

#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]));
    }
}

어셈블리:

_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

나중에 설명이 추가됩니다. 기본적인 아이디어는 수정하는 것입니다 divss xmm0, xmm1에서 지시를 0x100000db0하고로 교체 mulss,addss , subss또는divss 제공된 피연산자에 따라. 입력 문자열을 구문 분석하는 데 작은 트릭도 사용됩니다.

다음으로 생성 된 어셈블리 :

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;
}

하스켈 105 102 98 96 바이트

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)

Zgarb와 nimi 덕분에 9 바이트가 절약되었습니다.

온라인으로 사용해보십시오.

가이아 , 26 25 바이트

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

온라인으로 사용해보십시오!

설명

ẋ                          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.

젤리 , 28 바이트

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

온라인으로 사용해보십시오!

-2 바이트에 대한 Jonathan Allan의 답변 에서 링크를 줄로 분리하는 아이디어를 얻었습니다 .

APL (Dyalog) , 30 바이트

lstefano의 솔루션에서 영감을 얻었습니다 .

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

온라인으로 사용해보십시오!

{… } 인수가 나타내는 익명 함수⍵ :

 0:: 오류가 발생하면 :

  0 제로를 돌려 주다

 ⋄ 이제 시도하십시오 :

  ⍵∩⎕D 인수의 교회법 및 집합 D의 igits (제거합니다 포인트를 느낌표)

  ⍎ 그것을 실행하십시오 (숫자로 바꿉니다)

  ⍳ ndi의 ndices

  (… )/ 용어 사이에 다음 기능을 삽입합니다 (필요에 따라 APL이 적합합니다).

   ⍵~⎕D 없이 인수 D의 igits (잎 느낌표)

  ≢ 그 집계 (즉, 얼마나 많은 느낌표)

  '×+-⌹'⊃⍨ 이것을 사용하여 기호 목록에서 선택하십시오 *

  ⍎ 실행 (기호를 함수로 변환)

⌹÷빈 목록에 오류를 발생시키기 위해 (정규 나누기) 대신 (행렬 나누기)를 사용 합니다.

펄 5 , 96 바이트

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

온라인으로 사용해보십시오!

Dyalog APL, 최소 29 자

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

식이 가장 정확합니다. 그것은 모든 테스트 케이스를 제외하고 전달 0!!!!하는 것이주는 1대신 요구의 0APL의 빈 벡터의 감소가 감소하는 데 사용되는 함수에 대한 중립적 인 요소를 반환하도록되어 있기 때문에 그의. 몫은 1입니다. 현재 나는 그것을 고칠 시간이 없지만 비오는 날 여기에 남겨 둘 것입니다.

05AB1E , 25 24 바이트

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

온라인으로 사용해보십시오!

Mathematica, 152 바이트

(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]])&

자바 스크립트, 111 163 바이트

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)))

읽을 수있는 버전

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)))