음수가 아닌 정수 의 계승 을 찾는 가장 짧은 프로그램이나 함수를 만듭니다 .

계승 !은 다음과 같이 정의됩니다.

일반 영어에서 0의 계승은 1이고 n의 계승입니다. 여기서 n이 0보다 크면 n은 1보다 작은 계승의 n 배입니다.

코드는 표준 방법을 사용하여 입력 및 출력을 수행해야합니다.

요구 사항 :

• 계승을 계산할 수있는 내장 라이브러리를 사용하지 않습니다 (이 형식은 모두 포함 eval).
• 최대 125까지의 계승을 계산할 수 있습니다
• 숫자 0의 계승을 계산할 수 있습니다 (1과 같음)
• 최대 125 분의 1 분 안에 완료

동점 일 경우 가장 짧은 제출이 이기고 그 당시 가장 많은 표를 얻은 답이 이깁니다.

골프 스크립트-12 자

{,1\{)*}/}:f

Golfscript 시작하기-단계별 계승

골프 스크립트를 배우려는 사람들을위한 것입니다. 전제 조건은 골프 스크립트에 대한 기본 지식과 골프 스크립트 문서를 읽는 기능입니다.

그래서 우리는 새로운 도구 golfscript 를 시도하고 싶습니다 . 항상 간단한 것으로 시작하는 것이 좋으므로 계승으로 시작합니다. 간단한 명령형 의사 코드를 기반으로 한 초기 시도는 다음과 같습니다.

# pseudocode: f(n){c=1;while(n>1){c*=n;n--};return c}
{:n;1:c;{n 1>}{n c*:c;n 1-:n;}while c}:f

공백은 골프 스크립트에서 거의 사용되지 않습니다. 공백을 제거하는 가장 쉬운 방법은 다른 변수 이름을 사용하는 것입니다. 모든 토큰을 변수로 사용할 수 있습니다 ( 구문 페이지 참조). 변수로 사용하기에 유용한 토큰은 |, 와 같은 특수 문자 &이며 ?일반적으로 코드의 다른 곳에서는 사용되지 않습니다. 이들은 항상 단일 문자 토큰으로 구문 분석됩니다. 반대로, 같은 변수 n는 스택에 숫자를 넣을 공간이 필요합니다. 숫자는 본질적으로 사전 초기화 된 변수입니다.

항상 그렇듯이, 최종 결과에 영향을 미치지 않으면 서 우리가 바꿀 수있는 진술이있을 것입니다. golfscript에서 모든 제외 true로 평가 0, [], "",과 {}(참조 이 ). 여기서 루프 종료 조건을 간단히 변경할 수 있습니다 {n}(추가 시간을 반복하고 n = 0 일 때 종료).

다른 언어로 골프를 타는 것과 마찬가지로 사용 가능한 기능을 아는 데 도움이됩니다. 운 좋게도 목록은 golfscript에 대해 매우 짧습니다. 다른 캐릭터를 구하기 1-위해 (로 변경할 수 있습니다 . 현재 코드는 다음과 같습니다. ( 원하는 경우 여기 1대신 사용할 수 있으므로 |초기화가 중단됩니다.)

{:n;1:|;{n}{n|*:|;n(:n;}while|}:f

가장 짧은 솔루션을 얻으려면 스택을 잘 사용하는 것이 중요합니다 (연습 실습). 일반적으로 값이 작은 코드 세그먼트에만 사용되는 경우 변수에 값을 저장하지 않아도됩니다. 실행중인 제품 변수를 제거하고 단순히 스택을 사용함으로써 많은 문자를 절약 할 수 있습니다.

{:n;1{n}{n*n(:n;}while}:f

여기에 다른 생각이 있습니다. n루프 바디 끝의 스택에서 변수 를 제거하고 바로 다음에 밀어 넣습니다. 실제로 루프가 시작되기 전에 스택에서 루프를 제거합니다. 대신 스택에 그대로 두어야하며 루프 조건을 비워 둘 수 있습니다.

{1\:n{}{n*n(:n}while}:f

변수를 완전히 제거 할 수도 있습니다. 이렇게하려면 항상 변수를 스택에 유지해야합니다. 이는 상태 확인이 끝날 때 스택에 변수의 사본 두 개가 필요하므로 확인 후에도 손실되지 않습니다. 즉 0, 루프가 끝난 후 스택에 중복 이 생기지 만 쉽게 해결할 수 있습니다.

이것은 우리를 최적의 while루프 솔루션으로 안내합니다!

{1\{.}{.@*\(}while;}:f

이제 우리는 여전히 이것을 더 짧게 만들고 싶습니다. 명백한 목표는 단어 여야합니다 while. 문서를 살펴보면 전개 와 수행 이라는 두 가지 대안 이 있습니다. 다른 노선을 선택할 수있는 경우 두 가지 혜택을 모두 시도해보십시오. 펼치기는 '거의 while 루프'이므로 5 문자 while를 4로 줄 /입니다. 에 관해서는 3자를 do삭감 while하고 두 블록을 합치면 다른 문자를 저장할 수 있습니다.

실제로 do루프 를 사용하면 큰 단점이 있습니다. 본문이 한 번 실행 된 후 조건 확인이 수행되므로 값 0이 잘못되므로 if 문이 필요할 수 있습니다. 펼치기가 더 짧다는 것을 알려 드리겠습니다 (일부 솔루션 do은 마지막에 제공됨). 우리가 이미 가지고있는 코드는 최소한의 변경이 필요합니다.

{1\{}{.@*\(}/;}:f

큰! 우리의 솔루션은 이제 매우 짧으며 여기서 끝났습니다. 아니. 이것은 17 자이며 J는 12 자입니다. 패배를 인정하지 마십시오!

지금 당신은 생각하고 있습니다 ... 재귀

재귀를 사용한다는 것은 분기 구조를 사용해야 한다는 것을 의미 합니다 . 불행히도, 간결하게 재귀 적으로 계승을 표현할 수 있기 때문에 반복에 대한 대안으로 보일 수 있습니다.

# pseudocode: f(n){return n==0?n*f(n-1):1}
{:n{n.(f*}1if}:f # taking advantage of the tokeniser

재귀를 일찍 시도했다면 while루프 를 사용하지 않았을 수도 있습니다 ! 여전히 우리는 16 자에 불과합니다.

배열

배열은 일반적으로 [and ]문자를 사용하거나 ,함수를 사용하여 두 가지 방식으로 생성됩니다 . 스택 맨 위에서 정수로 실행하면 ,arr [i] = i를 가진 해당 길이의 배열을 반환합니다.

배열을 반복하기 위해 다음 세 가지 옵션이 있습니다.

1. {block}/: 밀기, 막기, 밀기, 막기 ...
2. {block}%: [push, block, push, block, ...] (이것은 약간의 뉘앙스가 있습니다. 예를 들어 각 푸시 전에 스택에서 중간 값이 제거됩니다)
3. {block}*: 밀기, 밀기, 막기, 밀기, 막기 ...

골프 스크립트 문서에는 {+}*배열의 내용을 합하는 데 사용하는 예제가 있습니다. 이것은 {*}*배열의 곱을 얻는 데 사용할 수 있음 을 나타냅니다.

{,{*}*}:f

불행히도, 그렇게 간단하지 않습니다. 모든 요소가 1 개씩 꺼져 있습니다 ( [0 1 2]대신 [1 2 3]). {)}%이 문제를 해결 하는 데 사용할 수 있습니다 .

{,{)}%{*}*}:f

글쎄요 이것은 0을 올바르게 처리하지 않습니다. 비용이 너무 많이 들지만 (n + 1)! / (n + 1)을 계산하여이를 수정할 수 있습니다.

{).,{)}%{*}*\/}:f

n = 1과 동일한 버킷에서 n = 0을 처리 할 수도 있습니다. 이 작업은 실제로 수행 할 수있는 시간이 매우 짧습니다.

7 자에서 정렬하는 것이 좋지 않습니다 : [1\]$1=. 이 분류 기술은 숫자에 경계를 두는 것과 같은 유용한 목적을 가지고
있습니다.

같은 블록에서 증분과 곱셈을하려면 배열의 모든 요소를 ​​반복해야합니다. 우리는 배열을 만들지 않기 때문에,를 사용해야한다는 것을 의미합니다 {)*}/. 이것은 factorial의 가장 짧은 golfscript 구현을 가능하게합니다! 12 자 길이로 J와 연결됩니다!

{,1\{)*}/}:f

보너스 솔루션

루프에 if대한 간단한 솔루션으로 시작 do:

{.{1\{.@*\(.}do;}{)}if}:f

이 중 몇 가지를 더 짜낼 수 있습니다. 조금 복잡하기 때문에 이러한 것들이 작동하도록 설득해야합니다. 이 모든 것을 이해했는지 확인하십시오.

{1\.!!{{.@*\(.}do}*+}:f
{.!{1\{.@*\(.}do}or+}:f
{.{1\{.@*\(.}do}1if+}:f

더 좋은 대안은 (n + 1)! / (n + 1)을 계산하는 것이므로 if구조 가 필요하지 않습니다 .

{).1\{.@*\(.}do;\/}:f

그러나 do여기서 가장 짧은 솔루션은 0에서 1까지의 모든 문자와 그 자체로 모든 문자를 매핑하는 데 몇 문자가 필요하므로 분기가 필요하지 않습니다. 이런 종류의 최적화는 놓치기 매우 쉽습니다.

{.!+1\{.@*\(.}do;}:f

관심있는 사람은 위와 동일한 길이의 대체 재귀 솔루션을 몇 가지 제공합니다.

{.!{.)f*0}or+}:f
{.{.)f*0}1if+}:f
{.{.(f*}{)}if}:f

* 참고 :이 게시물에서 실제로 많은 코드 조각을 테스트하지 않았으므로 오류가 있는지 알려주십시오.

하스켈, 17

f n=product[1..n]

파이썬-27

간단히 :

f=lambda x:0**x or x*f(x-1)

APL (4)

×/∘⍳

익명의 기능으로 작동합니다 :

    ×/∘⍳ 5
120

이름을 지정하려면 6 자 :

f←×/∘⍳

J (12)

J의 표준 정의 :

f=:*/@:>:@i.

125 초 동안 1 초 미만!

예 :

 f 0
 1
 f 5
 120
  f 125x
 1882677176888926099743767702491600857595403
 6487149242588759823150835315633161359886688
 2932889495923133646405445930057740630161919
 3413805978188834575585470555243263755650071
 31770880000000000000000000000000000000

골프 스크립트-13 자 (SYM)

기능을 정의 !

{),()\{*}/}:!             # happy robot version \{*}/ 

대체 13 자 버전

{),()+{*}*}:! 

전체 프로그램 버전은 10 자입니다.

~),()+{*}*

테스트 케이스는 1/10 초 미만입니다.

입력:

0!

산출

1

입력

125!

산출

188267717688892609974376770249160085759540364871492425887598231508353156331613598866882932889495923133646405445930057740630161919341380597818883457558547055524326375565007131770880000000000000000000000000000000

펄 6 : 13 자

$f={[*]1..$_}

[*]Haskell product과 같으며 1..$_1에서 $_까지의 인수입니다.

MATLAB, 15

f=@(x)prod(1:x)

테스트 사례

>> f(0)
ans =
     1
>> f(4)
ans =
    24
>> tic,f(125),toc
ans =
  1.8827e+209
Elapsed time is 0.000380 seconds.

파이썬, 28 바이트

f=lambda x:x/~x+1or x*f(x-1)

(Alexandru의 솔루션을 기반으로 함)

MATL , 2 바이트

:p

설명 :

:    % generate list 1,2,3,...,i, where i is an implicit input
p    % calculate the product of of all the list entries (works on an empty list too)

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

루비-21 자

f=->n{n>1?n*f[n-1]:1}

테스트

irb(main):009:0> f=->n{n>1?n*f[n-1]:1}
=> #<Proc:0x25a6d48@(irb):9 (lambda)>
irb(main):010:0> f[125]
=> 18826771768889260997437677024916008575954036487149242588759823150835315633161
35988668829328894959231336464054459300577406301619193413805978188834575585470555
24326375565007131770880000000000000000000000000000000

자바, 85 자

BigInteger f(int n){return n<2?BigInteger.ONE:new BigInteger(""+n).multiply(f(n-1));}

포스트 스크립트, 26 자

/f{1 exch -1 1{mul}for}def

예:

GS> 0 f =
1
GS> 1 f =
1
GS> 8 f =
40320

함수 자체는 21 자만 사용합니다. 나머지는 변수에 바인딩하는 것입니다. 바이트를 저장하기 위해 다음과 같이 숫자에 바인드 할 수도 있습니다.

GS> 0{1 exch -1 1{mul}for}def
GS> 8 0 load exec =
40320

자바 스크립트, 25

function f(n)!n||n*f(n-1)

CoffeeScript, 19

f=(n)->!n||n*f(n-1)

truen = 0 인 경우 반환 하지만 JavaScript는 어쨌든 1을 입력으로 강제합니다.

루비 -30 29 자

def f(n)(1..n).inject 1,:*end

테스트

f(0) -> 1
f(5) -> 120

F # : 26 자

F #에는 제품 기능이 내장되어 있지 않지만 접을 수있는 제품 기능을 만들 수 있습니다

let f n=Seq.fold(*)1{1..n}

사용자의 관점에 따라 C #, 20 또는 39 자

전통적인 인스턴스 방법으로 (39 자; 여기서 테스트 ) :

double f(int x){return 2>x?1:x*f(x-1);}

람다 식 (20 자이지만 고지 사항 참조; 여기서 테스트 됨 ) :

f=x=>2>x?1:x*f(x-1);

우리는 125double 때문에 사용해야합니다 ! == 1.88 * 10 ²⁰⁹ 보다 큽니다 ulong.MaxValue.

람다 버전의 문자 수에 대한 면책 ​​조항 :

C # 람다에서 재귀를 수행하는 경우 람다를 명명 된 변수에 저장해야 자체 호출 할 수 있습니다. 그러나 (예를 들어) JavaScript와는 달리 자기 참조 람다는 이전 행에서 선언 되고 초기화 되어야합니다 . 변수를 선언 및 / 또는 초기화하는 동일한 명령문에서 함수를 호출 할 수 없습니다.

즉, 이것은 작동하지 않습니다 :

Func<int,double> f=x=>2>x?1:x*f(x-1); //Error: Use of unassigned local variable 'f'

그러나 이것은 :

Func<int,double> f=null;            
f=x=>2>x?1:x*f(x-1);  

f실행시 할당을 해제 할 수 없으므로이 제한에 대한 정당한 이유 가 없습니다. Func<int,double> f=null;라인 의 필요성은 C #의 기발한 것입니다. 그것이 문자 수에서 그것을 무시하는 것이 공정한지 여부는 독자에게 달려 있습니다.

CoffeeScript, 실제 21 자 19 자

f=(x)->+!x||x*f x-1

여기에서 테스트되었습니다 : http://jsfiddle.net/0xjdm971/

Brachylog , 7 6 바이트

범위를 만들고 곱하면

max () 함수를 사용하는 아이디어가있는 ov에 1 바이트 탱크

;1⌉⟦₁×

설명

;1          --  If n<1, use n=1 instead (zero case)
  ⟦₁        --      Construct the range [1,n]
    ×       --      return the product of said range

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

Brachylog , 10 9 바이트

재귀

≤1|-₁↰;?×

설명

            --f(n):
≤1          --  if n ≤ 1: return 1
|           --  else:
 -₁↰        --      f(n-1)
    ;?×     --            *n

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

C (39 자)

double f(int n){return n<2?1:n*f(n-1);}

D : 45 자

T f(T)(T n){return n < 2 ? 1 : n * f(n - 1);}

더 읽기 :

T f(T)(T n)
{
    return n < 2 ? 1 : n * f(n - 1);
}

더 차가운 (더 긴 버전이지만) 컴파일 타임 ( 64 자 ) 에서 모두 수행하는 템플릿입니다 .

template F(int n){static if(n<2)enum F=1;else enum F=n*F!(n-1);}

더 읽기 :

template F(int n)
{
    static if(n < 2)
        enum F = 1;
    else
        enum F = n * F!(n - 1);
}

시조 템플릿은 매우 장황하므로 코드 골프에서 실제로 사용할 수는 없습니다. D는 코드 골프에 비해 문자 수 측면에서 이미 충분히 장황합니다 (실제로 큰 프로그램의 경우 전체 프로그램 크기를 줄이는 데 실제로 효과적 이지만 ). 그것은 내가 가장 좋아하는 언어이므로 GolfScript와 같은 것들이 크림을 적용하더라도 코드 골프에서 얼마나 잘 할 수 있는지 시도하고 볼 수 있다고 생각합니다.

PowerShell – 36

소박한:

filter f{if($_){$_*(--$_|f}else{1}}

테스트:

> 0,5,125|f
1
120
1,88267717688893E+209

스칼라, 39 자

def f(x:BigInt)=(BigInt(1)to x).product

대부분의 문자는 BigInts가 사용되도록 보장 하므로 최대 125까지의 값 요구 사항이 충족됩니다.

자바 스크립트, ES6 17

f=n=>n?n*f(n-1):1

ES6 :

• 화살표 기능

PowerShell, 42 바이트

( 함수 대신 필터 를 사용하여 2 문자 저장 )

filter f($x){if(!$x){1}else{$x*(f($x-1))}}

산출:

PS C:\> f 0
1
PS C:\> f 5
120
PS C:\> f 1
1
PS C:\> f 125
1.88267717688893E+209

라켓 (구성표) 40 35 29 바이트

0을 계산합니다! 1이되고 125를 계산합니다! 타이머에 따라 0 초 안에. 정기적 인 재귀 적 접근

(define(f n)(if(= n 0)1(* n(f(- n 1)))))

일반적인 리스프를 이길 수있는 새로운 버전 : 목록의 모든 요소를 ​​곱합니다 (하스켈 솔루션과 동일)

(λ(n)(apply *(build-list n add1)))

다른 체계 솔루션을 이기고 적용 대신 foldl을 사용하고 buildlist 대신 range를 사용하여 다른 라켓 솔루션을 계산하는 최신 버전

(λ(n)(foldl * n(range 1 n)))

모닝 턴 초승달 , 1827 1698 자

나는 오늘 새로운 언어를 배우고 싶다고 느꼈고, 이것이 내가 착륙 한 것입니다 ... (왜 나 자신에게 이것을합니까?)이 출품작은 상을받지는 않지만 지금까지 0 점의 다른 답을 능가합니다. 같은 언어!

Take Northern Line to Bank
Take Central Line to Holborn
Take Piccadilly Line to Heathrow Terminals 1, 2, 3
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Parsons Green
Take District Line to Bank
Take District Line to Parsons Green
Take District Line to Acton Town
Take District Line to Hammersmith
Take Circle Line to Aldgate
Take Circle Line to Aldgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Aldgate
Take Circle Line to Hammersmith
Take District Line to Acton Town
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Acton Town
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Parsons Green
Take District Line to Notting Hill Gate
Take Circle Line to Notting Hill Gate
Take Circle Line to Bank
Take Circle Line to Temple
Take Circle Line to Aldgate
Take Circle Line to Aldgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Aldgate
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Bank
Take District Line to Upney
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Upney
Take District Line to Bank
Take Circle Line to Embankment
Take Circle Line to Embankment
Take Northern Line to Angel
Take Northern Line to Moorgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Mornington Crescent

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

런던을 여행하는 사람이라면 누구나 즉시 그 사실을 이해할 것이므로 자세한 설명을 할 필요가 없습니다.

시작시 대부분의 작업은 0 건을 처리하는 것입니다. 1에서 제품을 초기화 한 후 0을 사용하여 max (input, 1)를 계산하여 새 입력을 얻을 수 있습니다. = 1! 그러면 메인 루프가 시작될 수 있습니다.

(편집 : 7 (자매)을 자체로 나눠서 생성하는 대신 "Heathrow Terminals 1, 2, 3"에서 1을 제거하여 전체 여행 횟수를 절약했습니다. 또한 저렴한 방법을 사용하여 -1을 생성합니다. 다음 단계.)

모닝 턴 초승달에서는 감소하는 것이 비쌉니다 (튜브 자체보다 저렴하지만). 일을보다 효율적으로 만들기 위해 파싱 된 0의 NOT을 가져 와서 -1을 생성하고 많은 루프를 위해 Hammersmith에 저장합니다.

Befunge-2x20 = 40 자

0\:#v_# 1#<\$v *\<
    >:1-:#^_$>\:#^_$

랩 어라운드를 사용하지 않는 독립형 코드 블록이라는 기능입니다. 스택의 맨 위에 인수를 놓은 다음 왼쪽 상단 오른쪽에서 입력하면 함수가 오른쪽 맨 아래에서 종료되고 결과는 스택 맨 위에 표시됩니다.

예 : 125의 계승 계산

555**   0\:#v_# 1#<\$v *\<
            >:1-:#^_$>\:#^_$    .@

테스트 0

0   0\:#v_# 1#<\$v *\<
        >:1-:#^_$>\:#^_$    .@

J-6 자

*/>:i.

이것이 중요합니까? 나는 그것이 이전 J 예제와 매우 유사하다는 것을 알고 있지만 조금 더 짧습니다 :)

저는 J의 초보자이지만 지금까지는 많은 재미가 있습니다!

C에서 (23 자)

이것은 반환이 지정되지 않은 경우 마지막 할당을 반환으로 계산하는 GCC "기능"을 남용합니다.

f(a){a=a>0?f(a-1)*a:1;}

적절한 C에서 28 자

f(a){return a>0?f(a-1)*a:1;}

코나 ( 11 6)

*/1.+!

K는 오른쪽에서 왼쪽으로 (대부분의 경우), 그래서 우리는 열거 작동 x(에서 번호 목록 / 배열 할 0로를 x-1) 추가 1(목록의 범위 그것에 0에 x), 다음 모두 함께 숫자를 곱합니다. 계산이 필요하지 않은 125!경우을 .옆으로 제거하여 1 바이트를 더 절약 할 수 1있습니다. 어쨌든 125! 단 밀리 초 단위로 계산됩니다.

  */1.+!125.
1.882677e+209