피보나치 오리알


36

정의

F(n)양의 정수에서 피보나치 수열 은 다음과 같이 정의됩니다.

1. F(1) = 1
2. F(2) = 1
3. F(n) = F(n-1) + F(n-2), where n is an integer and n > 2

양의 정수의 피보나치 오리알은의 곱입니다 [F(1), F(2), ..., F(n)].

태스크

양의 정수가 주어지면 n의 Fibonacci-orial을 찾으십시오 n.

명세서

피보나치 오리온은 100합리적인 컴퓨터에서 5 초 이내에 계산해야합니다.

테스트 케이스

n   Fibonacci-orial of n
1   1
2   1
3   2
4   6
5   30
6   240
7   3120
8   65520
9   2227680
10  122522400
11  10904493600
12  1570247078400
13  365867569267200
14  137932073613734400
15  84138564904377984000
16  83044763560621070208000
17  132622487406311849122176000
18  342696507457909818131702784000
19  1432814097681520949608649339904000
20  9692987370815489224102512784450560000
100 3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000

참고 문헌



1
@LuisMendo 피보나치의 합은 ... 피보나치라고 생각합니다. 음, 빼기
Leaky Nun

2
@LeakyNun 현재 JavaScript 답변은 최대 15 개까지만 테스트 사례를 완료합니다. JavaScript는 2 ^ 53-1 이후의 숫자를 올바르게 비교 (또는 조작) 할 수 없기 때문에 대부분의 언어는 그렇지 않으므로 대부분의 제출물과 유사합니다. 큰 지원 번호
MayorMonty

1
"합리적인 컴퓨터"란 무엇을 의미합니까?
Outgolfer Erik

2
-1 이것은 특히 흥미로운 지름길이없는 여러 가지 도전 과제 (범위, 피보나치, 계승)처럼 보이기 때문입니다.
Esolanging 과일

답변:


63

Mathematica, 10 바이트

Fibonorial

또 다른 Mathematica 내장 기능은 내장 언어없이 골프 언어로 소리를냅니다.


49
난 .. 무슨 .. 왜, Mathematica ?!
Lynn

3
그 기능도 존재하지 않았다!
LegionMammal978

3
@Lynn 규칙 35 : 존재하는 경우, 그것의 매스 매 티카 기능이있다)
베타 붕괴

9
@BetaDecay 규칙 110 이라는 것을 알았습니다 .
마틴 엔더

1
아니요, 규칙 110 은 매우 다릅니다. Mathematica도 내장되어 있다고 확신합니다.
AdmBorkBork

27

젤리 , 6 바이트

+С1ḊP

입력 100은 로컬에서 500ms 내에 완료됩니다. 온라인으로 사용해보십시오!

작동 원리

+С1ḊP  Niladic link. No input.
        Since the link doesn't start with a nilad, the argument 0 is used.

   1    Yield 1.
+       Add the left and right argument.
 С     Read a number n from STDIN.
        Repeatedly call the dyadic link +, updating the right argument with
        the value of the left one, and the left one with the return value.
        Collect all values of the left argument into an array.
    Ḋ   Dequeue; discard the first Fibonacci number (0).
     P  Product; multiply the remaining ones.

그래서되는 +¡1n 번째 피보나치의 비 내장 +С1처음 n 피보나치 숫자인가?
caird coinheringaahing

@cairdcoinheringaahing 거의.
Dennis

내장 피보나치 기능이 있다고 생각 했습니까?
MilkyWay90


16

브레인 퍽, 1,198 1,067 817 770 741 657 611 603

,[>++++++[-<-------->]<<[->++++++++++<]>>,]>+>+>>+>+<<<<<<[->>>[[-]
<[->+<]>>[-<+<+>>]<[->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<[->
[-]>>>>>>+>+<<<<<<<<[->+<]]]]]]]]]]]+>>>>>>>>]<<<<<<<<[->[-<+<<+>>>
]<[->+<]>>>[<<<<<[->>>>>>>>+<<<<<<<<]>>>>>>>>>>>>>]<<<<<<<<[->>>[-<
<<<<<<<+>>>>[->+>>+<<<]>[-<+>]>>>]<<[->>>>>>>+>+<<<<<<<<]<+<<<<<<<<
]>>>[-]>>>>>[[-]>[->+<]>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<
+>[->>>>>>+>+<<<<<<<<[-]]]]]]]]]]>]<<[<]+>>>>>>>>]<<<<<<<<[<<<<<<<<
]>>>>>[>>>>>>>>]+<<<<<<<<]>>>>>>>>>>>[<[-]>>[-<<+>>]>>>>>>>]<<<<<<<
<[<<<<<<<<]>>]>>>>>>[>>>>>>>>]<<<<<<<<[+++++[-<++++++++>]<.<<<<<<<]

주석이 포함 된 비 압축

# parse input (max 255)
,[>++++++[-<-------->]<<[->++++++++++<]>>,]
>+>+>>+>+<<<<<<
[->>>
  # compute next fibonacci number
  [[-]<
    [->+<]>>
    [-<+<+>>]<
    # perform carries
    [->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<
      [->[-]>>>>>>+>+<<<<<<<<[->+<]]
    ]]]]]]]]]+>>>>>>>>
  ]<<<<<<<<
  # multiplication
  [->
    # extract next digit of F_n (most significant first)
    [-<+<<+>>>]<
    [->+<]>>>
    # move back to the end
    [<<<<<
      [->>>>>>>>+<<<<<<<<]>>>>>>>>>>>>>
    ]<<<<<<<<
    # digit wise multiplication (shifting current digit)
    [->>>
      [-<<<<<<<<+>>>>
        [->+>>+<<<]>
        [-<+>]>>>
      ]<<
      # shift previous total over one gap (in effect multiplying by 10)
      [->>>>>>>+>+<<<<<<<<]<+<<<<<<<<
    ]>>>[-]>>>>>
    # add product to total
    [[-]>
      [->+<]>
      # perform carries
      [-<+>
        [-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>
          [->>>>>>+>+<<<<<<<<[-]]
        ]]]]]]]]>
      ]<<[<]+>>>>>>>>
    ]<<<<<<<<
    [<<<<<<<<]>>>>>
    [>>>>>>>>]+<<<<<<<<
  ]>>>>>>>>>>>
  # overwrite previous product
  [<[-]>>
    [-<<+>>]>>>>>>>
  ]<<<<<<<<
  [<<<<<<<<]>>
]>>>>>>
# output product
[>>>>>>>>]<<<<<<<<
[+++++
  [-<++++++++>]<.<<<<<<<
]

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

온라인 통역사 에서 n = 100의 런타임 이 1 초 미만입니다 (내 자신의 통역사를 사용하여 로컬로 약 0.2 초). 최대 입력은 255이지만 인터프리터가 ~ 54000 셀을 지원해야합니다 (온라인 인터프리터는 64k로 줄 바꿈 된 것 같습니다).


변경 로그

곱하기 위해 현재 숫자를 더 잘 추출하고 추가 및 단일 패스로 병합하여 약 130 바이트를 절약했습니다. 또한 조금 더 빠른 것 같습니다.

250 바이트를 더 절약했습니다. 곱셈 스크래치 패드를 두 개의 셀로 줄였습니다.이 숫자 사이에서 지금까지 이동할 필요가 없으므로 거의 모든 곳에서 바이트가 절약됩니다. 또한 숫자를 곱한 후 캐리를 삭제하고 대신 누적 합계에 추가하면서 전체 캐리를 수행합니다.

첫 번째 반복을 앞으로 이동하지 않고 현재 위치에서 작업함으로써 단순히 현재 숫자를 더 잘 추출하여 다시 50을 자릅니다. 약간의 미세 최적화는 약 10 바이트를 차지합니다.

30 명이 더 갔다. 1이 아닌 0으로 이미 찍힌 숫자를 표시하면 쉽게 찾을 수 있습니다. 또한 곱셈 루프가 다소 단순하게 완료되었는지 확인합니다.

스크래치 패드를 다른 셀로 80 바이트 더 줄였습니다. 이전 제품의 마커와 현재 누적 합계를 병합하여 간격 사이의 이동을 줄이고 부기를 좀 더 쉽게 만들었습니다.

또 다른 셀을 제거하여 피보나치 숫자의 마커를 재사용하여 마지막으로 찍은 숫자도 표시함으로써 다른 50 개를 저장했습니다. 또한 루프를 병합하여 이전 총계를 숫자 단위 곱셈 루프로 이동시킬 수있었습니다.

입력 구문 분석시 8 바이트를 절약했습니다. 죄송합니다.


14

파이썬, 45 바이트

a=b=o=1
exec"o*=a;a,b=b,a+b;"*input()
print o

입력은 stdin에서 가져옵니다. n = 100에 대한 출력 이 너무 빨리 완료되어 정확하게 시간을 정합니다. n = 1000 은 약 1 초가 걸립니다.

샘플 사용법

$ echo 10 | python fib-orial.py
122522400

$ echo 100 | python fib-orial.py
3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000

13

하스켈 41 29 바이트

@Laikoni의 발언으로 1 + 11 바이트가 절약되었습니다.

f=1:scanl(+)1f
(scanl(*)1f!!)

1, f그리고 !!별도의 토큰입니다. 첫 번째 줄은 피보나치 시퀀스를 정의하고, 두 번째 줄은 피보나치 오리알의 시퀀스를 계산하고 주어진 n에 대해 n 번째를 반환하는 함수입니다. n = 1000 일지라도 거의 즉시 숫자 인쇄를 시작합니다.


1
당신은 공간을 제거 할 수 있습니다 (scanl(*)1f!!).
Laikoni

2
피보나치 발생기가 더 짧 습니다 .f=1:scanl(+)1f
Laikoni

@ Laikoni 정말 놀랍습니다!
Christian Sievers

2
@WillNess 나는뿐만 아니라 의해 난 단지 다른 사용자가하는 일에 의해 정당화되지라고 생각 meta.codegolf.stackexchange.com/questions/2419/...meta.codegolf.stackexchange.com/questions/9031/... (하지만이 더 많이 그리고 나는 전부 읽지 않았습니다)
Christian Sievers

1
@flawr 42+42를 추가하는 함수로 사용할 수 있습니까? 완성되지 않은 표현 일뿐입니다. 그러나 Haskell 에서는 괄호를 추가 (42+)하고 함수를 작성하는 방법 인 섹션을 얻을 수 있습니다 \n->42+n. 여기서는 더 복잡한 첫 번째 피연산자 !!대신 (인덱싱을위한 이진 삽입 연산자) 만 사용 +합니다.
Christian Sievers

11

파이썬 2, 39 바이트

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

Ideone에서 테스트하십시오 .


True경우에 따라 반환되도록 지정할 수도 있습니다 .
Leaky Nun

5
True입력 0 만 반환 하지만 양수는 아닙니다.
Dennis

6

J, 17 16 바이트

1 바이트는 훨씬 더 나은 솔루션으로 골프를칩니다.

[:*/+/@(!|.)\@i.

아이디어는 원본과 동일하지만 작은 대각선에서 작동하도록 행렬을 형성하는 대신 대각선을 즉시 형성합니다.


기발한

첫 번째 n 피보 노말 을 얻으려면 :

*/\(#{.+//.)!/~i.

오른쪽에서 왼쪽으로 읽는 중 ...
연속 된 정수 배열 ( i.)을 지정된 숫자까지 배열을 만듭니다. 해당 배열에서 배열의 모든 쌍에서 계산 된 /~이항 계수 ( !) 테이블 ( )을 만듭니다. 이 테이블은 파스칼의 삼각형 상단에 위치합니다 첫 번째 행의 끝과 기본 대각선 아래의 모든 요소는 0으로 구현되었습니다 !. +/모든 사소한 대각선 ( /.) 을 합산 ( ) 하면 피보나치 수를 얻지 만 {.결과 배열에서 첫 번째 요소를 #테이블 자체 의 길이 ( ) 만큼 가져와야합니다 ( ). 이어서, 어레이의 */연속 접두사 ( \)에 적용된 생성물 ( ) 은 원하는 순서의 피보 노리 알을 초래한다.당신은 당신이 2 바이트 이상을 사용하는 마지막 하나를 수행 할 수하고자하는 경우 ( {:)하지만 난 그들 모두를 표시하는 것은 죄가 아니라고 생각했다 :).
NB. the previous code block is not a J function.

   {:*/\(#{.+//.)!/~i. 10
122522400

J의 큰 숫자의 x경우 마지막에 사용 합니다.

   {:*/\(#{.+//.)!/~i. 100x
3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225...

이 프로그램은 평균 0.11s에서 실행됩니다 .

   100 timex '{:*/\(#{.+//.)!/~i.100x'
0.112124

1
함수 인 대안은 [:*/+/@(!|.)\@i.16 바이트를 사용 하는 것입니다 . !/~접두사를 사용하여 생성하는 것을 제외하고 는 사용하는 테이블을 따라 동일한 이항 계수를 형성합니다 i..
마일

4

Pyth, 13 바이트

u*Gs=[sZhZ)Q1

데모

이것은 영리하고 형식이 안전하지 않은 트릭을 사용합니다. 문자 ( u*G ... Q1) 중 5 개는 출력이 많은 수의 입력 결과라고 말합니다. 나머지 코드는 숫자를 생성합니다.

=[sZhZ)변수 Z를 목록으로 업데이트합니다 [s(Z), h(Z)]. 그런 다음 s해당 목록을 합산하여 곱합니다.

Z처음에는 0입니다 s,의 int에, 신원 기능입니다. h+ 1기능입니다. 따라서 첫 번째 반복에서 Z가됩니다 [0, 1].s위에서 언급 한 것처럼리스트에 합계 기능이 있습니다. h헤드 기능입니다. 따라서 두 번째 반복은 [1, 0]입니다.

목록은 다음과 같습니다.

Iter  Z          Sum
0     0          Not used
1     [0, 1]     1
2     [1, 0]     1
3     [1, 1]     2
4     [2, 1]     3
5     [3, 2]     5

이 합계를 곱하여 결과를 얻습니다.


4

매스 매 티카 25 24 바이트

마틴 엔더 덕분입니다.

1##&@@Fibonacci@Range@#&

1##&@@Fibonacci@Range@#&@100

타이밍 : 63 마이크로 초

{0.000063, 
3371601853146468125386964065447576689828006172937411310662486977801540
6711385898686165008341900290675836651822917015531720110825745874313823
1009903039430687777564739516714333248356092511296002464445971530050748
1235056111434293619038347456390454209587101225261757371666449068625033
9995735521655245297254676280601708866020010771376138030271586483293355
0772869860576999281875676563330531852996518618404399969665040724619325
7877568825245646129366994079739720698147440310773871269639752334356493
6789134243905645353892122400388956268116279491329780860702550826683922
9003714114129148483959669418215206272639036409444764264391237153249138
8089634845995941928089653751672688740718152064107169357399466473375804
9722605947689699525073466941890502338235963164675705844341280523988912
2373033501909297493561702963891935828612435071136036127915741683742890
4150054292406756317837582840596331363581207781793070936765786629772999
8328572573496960944166162599743042087569978353607028409125185326833249
36435856348020736000000000000000000000000}

또는 동일한 바이트 수로 :1##&@@Fibonacci~Array~#&
Greg Martin

4

젤리, 8 바이트

RḶUc$S€P

젤리에서의 첫 제출. @Dennis ' answer 만큼 짧지는 않지만 다른 방법으로 2 바이트 만 길어집니다.

로컬에서는 n = 100의 @Dennis 버전으로 380ms에 비해 약 400ms가 필요합니다 .

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

설명

RḶUc$S€P  Input: n
R         Generate the range [1, 2, ..., n]
          For each value x in that range
 Ḷ          Create another range [0, 1, ..., x-1]
  U         Reverse that list
   c        Compute the binomial coefficients between each pair of values
    $       Bind the last two links (Uc) as a monad
     S€   Sum each list of binomial coefficients
          This will give the first n Fibonacci numbers
       P  Take the product of those to compute the nth Fibonacci-orial

3

PARI / GP, 29 바이트

f=n->prod(i=1,n,fibonacci(i))

또는 대안으로 :

f=n->prod(i=a=!b=0,n,b=a+a=b)

3

R, 99 96 78 76 66 바이트

이 답변은 Binet의 Formula 뿐만 아니라 prod(x)함수를 사용합니다. 이후 R은 빌드에없는 Phi값을, 내가 직접 정의 :

p=(1+sqrt(5))/2;x=1;for(n in 1:scan())x=x*(p^n-(-1/p)^n)/sqrt(5);x

그것은 5 초 이내에 작동하지만 RInf그 큰 숫자에 대한 대답으로 경향이 있습니다 ...

언 골프 :

r=sqrt(5)
p=(1+r)/2 
x=1
for(n in 1:scan())        
    x=x*(p^n-(-1/p)^n)/r    
x

@Cyoce 덕분에 -2 바이트!
오, 나는이 사이트를 좋아합니까! @ user5957401 덕분에 -10 바이트


sqrt(5)변수 에 저장 하여 비트를 절약 할 수 있음
Cyoce

N한 번만 사용하기 때문에 1:N비트 내부에서 스캔을 호출 할 수 있습니다 . 즉 for(n in 1:scan()). for 루프 *prod()함수 대신 사용하여 몇 개의 문자를 저장할 수도 있습니다 . for 루프는 한 줄이므로 중괄호도 필요하지 않습니다.
user5957401

Binet의 공식을 사용하는 것이 좋습니다. 당신의 정신으로는 53 바이트 만function(n,N=1:n,p=5^.5)prod(((1+p)^N-(1-p)^N)/2^N/p)
Michael M

3

R, 82 , 53 , 49 바이트 (48 바이트, 다른 입력 스타일)

b=d=1;a=0;for(i in 1:scan()){d=d*b;b=a+b;a=b-a};d

코드 앞에 입력 번호를 붙이면 48 바이트가됩니다

->n;b=d=1;a=0;for(i in 1:n){d=d*b;b=a+b;a=b-a};d

편집 : 새로운 코드. 원본은 다음과 같습니다.

a=function(n)ifelse(n<3,1,{v=c(1,1,3:n);for(i in 3:n)v[i]=v[i-1]+v[i-2];prod(v)})

Inf 이외의 다른 것은 반환하지 않습니다 a(100). 그리고 음이 아닌 정수 외에는 작동하지 않습니다.

언 골프 드 :

a=function(n){
   if(n<3) return(1)
   v=c(1,1,3:n)
   for(i in 3:n)
       v[i]=v[i-1]+v[i-2]
   prod(v)
}

3

자바, 165 바이트

골프 :

BigInteger f(int n){BigInteger[]a={BigInteger.ZERO,BigInteger.ONE,BigInteger.ONE};for(int i=0;i<n;){a[++i%2]=a[0].add(a[1]);a[2]=a[2].multiply(a[i%2]);}return a[2];}

이것은 BigInteger많은 수로 인해 필요한 또 다른 경우 입니다. 그러나 텍스트 BigInteger를 최소로 유지하면서 크기를 줄였습니다. 또한 정적 가져 오기와 비교하여 총 길이가 길어졌습니다.

이 프로그램은 배열에서 3 개의 숫자를 추적하여 작동합니다. 처음 두 개는 이전 두 피보나치 수입니다. 세 번째는 누적 된 값입니다. 루프는 다음 값을 계산하고이를 (0, 1, 0, 1, ...) 배열 인덱스로 저장하여 시작합니다. 따라서 값 비싼 (소스 크기 측면에서) 할당 작업으로 값을 전환 할 필요가 없습니다. 그런 다음 그 새로운 가치를 포착하고 그것을 누산기에 곱하십시오.

임시 객체를 피하고 루프를 두 개의 할당 연산자로 제한함으로써 꽤 많은 바이트를 짜낼 수있었습니다.

언 골프 드 :

import java.math.BigInteger;

public class Fibonacci_orial {

  public static void main(String[] args) {
    // @formatter:off
    String[][] testData = new String[][] {
      { "1", "1" },
      { "2", "1" },
      { "3", "2" },
      { "4", "6" },
      { "5", "30" },
      { "6", "240" },
      { "7", "3120" },
      { "8", "65520" },
      { "9", "2227680" },
      { "10", "122522400" },
      { "11", "10904493600" },
      { "12", "1570247078400" },
      { "13", "365867569267200" },
      { "14", "137932073613734400" },
      { "15", "84138564904377984000" },
      { "16", "83044763560621070208000" },
      { "17", "132622487406311849122176000" },
      { "18", "342696507457909818131702784000" },
      { "19", "1432814097681520949608649339904000" },
      { "20", "9692987370815489224102512784450560000" },
      { "100", "3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000" }
    };
    // @formatter:on

    for (String[] data : testData) {
      System.out.println("Input: " + data[0]);
      System.out.println("Expected: " + data[1]);
      System.out.print("Actual:   ");
      System.out.println(new Fibonacci_orial().f(Integer.parseInt(data[0])));
      System.out.println();
    }
  }

  // Begin golf
  BigInteger f(int n) {
    BigInteger[] a = { BigInteger.ZERO, BigInteger.ONE, BigInteger.ONE };
    for (int i = 0; i < n;) {
      a[++i % 2] = a[0].add(a[1]);
      a[2] = a[2].multiply(a[i % 2]);
    }
    return a[2];
  }
  // End golf

}

프로그램 출력 :

Input: 1
Expected: 1
Actual:   1

Input: 2
Expected: 1
Actual:   1

Input: 3
Expected: 2
Actual:   2

Input: 4
Expected: 6
Actual:   6

Input: 5
Expected: 30
Actual:   30

Input: 6
Expected: 240
Actual:   240

Input: 7
Expected: 3120
Actual:   3120

Input: 8
Expected: 65520
Actual:   65520

Input: 9
Expected: 2227680
Actual:   2227680

Input: 10
Expected: 122522400
Actual:   122522400

Input: 11
Expected: 10904493600
Actual:   10904493600

Input: 12
Expected: 1570247078400
Actual:   1570247078400

Input: 13
Expected: 365867569267200
Actual:   365867569267200

Input: 14
Expected: 137932073613734400
Actual:   137932073613734400

Input: 15
Expected: 84138564904377984000
Actual:   84138564904377984000

Input: 16
Expected: 83044763560621070208000
Actual:   83044763560621070208000

Input: 17
Expected: 132622487406311849122176000
Actual:   132622487406311849122176000

Input: 18
Expected: 342696507457909818131702784000
Actual:   342696507457909818131702784000

Input: 19
Expected: 1432814097681520949608649339904000
Actual:   1432814097681520949608649339904000

Input: 20
Expected: 9692987370815489224102512784450560000
Actual:   9692987370815489224102512784450560000

Input: 100
Expected: 3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000
Actual:   3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000


2

루비, 39 바이트

->n{f=i=b=1;n.times{f,i,b=i,f+i,b*f};b}

36 :-> n {f = i = b = 1; n. 시간 {b * = f; i = f + f = i}; b}
GB

2

자바 스크립트 (ES6), 51 39 바이트

재귀 구현 (39 바이트)

f=(n,a=p=i=b=1)=>++i<n?f(n,b,p*=b+=a):p

원래 구현 (51 바이트)

n=>{for(i=a=b=p=1;++i<n;){c=a;a=b;p*=b+=c}return p}

참고 : 피보나치 오리온 16의 반올림 오류를 시작합니다. 100은 무한대이며 1 초 미만으로 표시됩니다.


나는 당신이 2 바이트를 절약 할 필요가없는 n=>[...Array(n)].reduce(p=>(c=a,a=b,p*=b+=c),a=1,b=0)것을 세는 것을 발견하기 위해 대체 53 바이트 버전을 만들었습니다 f=.
Neil

페어 포인트. 저의 이론적 근거는 단지 호출 할 수있는 것이 아니라 호출 할 수 있고 재사용 할 수있었습니다 .
Pandacoder

물론, 누군가 재사용하고 싶다면 여전히 이름을 지정할 수 있습니다.
Neil

@Neil 이제는 가서 다시 구현했으며 이제 f =가 필수이거나 실제로 실행할 수 없습니다. : D
Pandacoder

적어도 원래 구현의 바이트 수를 수정했습니다.
Neil

2

DC (GNU 또는 OpenBSD 풍미) , 36 바이트

파일 A003266-v2.dc:

0sA1sB1?[1-d0<LrlBdlA+sBdsA*r]dsLxrp

(후행 줄 바꿈 없음)

... 이제 결과는 명명 된 레지스터를 사용하는 대신 스택에 유지됩니다 ( Y버전 1에 있음). 이 r명령은 원본에서 사용할 수 없습니다 dc( RosettaCode의 Dc 페이지 참조 ).

운영:

$ time dc -f A003266-v2.dc <<< 100
337160185314646812538696406544757668982800617293741131066248697780154\
067113858986861650083419002906758366518229170155317201108257458743138\
231009903039430687777564739516714333248356092511296002464445971530050\
748123505611143429361903834745639045420958710122526175737166644906862\
503399957355216552452972546762806017088660200107713761380302715864832\
933550772869860576999281875676563330531852996518618404399969665040724\
619325787756882524564612936699407973972069814744031077387126963975233\
435649367891342439056453538921224003889562681162794913297808607025508\
266839229003714114129148483959669418215206272639036409444764264391237\
153249138808963484599594192808965375167268874071815206410716935739946\
647337580497226059476896995250734669418905023382359631646757058443412\
805239889122373033501909297493561702963891935828612435071136036127915\
741683742890415005429240675631783758284059633136358120778179307093676\
578662977299983285725734969609441661625997430420875699783536070284091\
2518532683324936435856348020736000000000000000000000000

real    0m0.005s
user    0m0.004s
sys     0m0.000s

설명하려고 :

tos스택을 제거하지 않고 스택 상단의 내용입니다.
nos아래 요소입니다 tos.

0 sA # push(0) ; A=pop()
1 sB # push(1) ; B=pop()
1    # push(1)
     # this stack position will incrementally hold the product
?    # push( get user input and evaluate it )
[    # start string
 1-  # push(pop()-1)
 d   # push(tos)
 0   # push(0)
 <L  # if pop() < pop() then evaluate contents of register L
 r   # exchange tos and nos
     # now nos is the loop counter
     # and tos is the bucket for the product of the fibonacci numbers
 lB  # push(B)
 d   # push(tos)
 lA  # push(A)
 +   # push(pop()+pop())
     # now tos is A+B, nos still is B 
 sB  # B=pop()
     # completes B=A+B
 d   # push(tos)
 sA  # A=pop()
     # completes B=A
     # tos (duplicated new A from above) is the next fibonacci number
 *   # push(nos*tos)
     # tos now is the product of all fibonacci numbers calculated so far
 r   # exchange tos and nos
     # now tos is the loop counter, nos is the product bucket
]    # end string and push it
d    # push(tos)
sL   # L=pop()
x    # evaluate(pop())
r    # exchange tos and nos
     # nos now is the former loop counter
     # tos now is the complete product. \o/
p    # print(tos)
     # this does not pop() but who cares? :-P

DC , 41 바이트

... 곧은 속임수 :

파일 A003266-v1.dc:

0sA1sB1sY?[1-d0<LlBdlA+sBdsAlY*sY]dsLxlYp

(후행 줄 바꿈 없음)

운영:

$ for i in $(seq 4) ; do dc -f A003266-v1.dc <<< $i ; done
1
1
2
6
$ time dc -f A003266-v1.dc <<< 100
337160185314646812538696406544757668982800617293741131066248697780154\
067113858986861650083419002906758366518229170155317201108257458743138\
231009903039430687777564739516714333248356092511296002464445971530050\
748123505611143429361903834745639045420958710122526175737166644906862\
503399957355216552452972546762806017088660200107713761380302715864832\
933550772869860576999281875676563330531852996518618404399969665040724\
619325787756882524564612936699407973972069814744031077387126963975233\
435649367891342439056453538921224003889562681162794913297808607025508\
266839229003714114129148483959669418215206272639036409444764264391237\
153249138808963484599594192808965375167268874071815206410716935739946\
647337580497226059476896995250734669418905023382359631646757058443412\
805239889122373033501909297493561702963891935828612435071136036127915\
741683742890415005429240675631783758284059633136358120778179307093676\
578662977299983285725734969609441661625997430420875699783536070284091\
2518532683324936435856348020736000000000000000000000000

real    0m0.006s
user    0m0.004s
sys     0m0.004s

1
* 한숨! * ... dc코드를 작성하는 것이 설명하는 것보다 훨씬 쉽습니다 ...
yeti

1
예, 우리는 미친 종류의 다중 스택 시각화 가제트가있는 IDE가 정말로 필요합니다 ...
Joe

1
새 명령으로 무엇을 추가해야하는지 몇 가지 아이디어가 있지만 가장 큰 영향을주는 아이디어는 다음과 같습니다. "기본 스택 변경"명령 추가. ;-)
yeti

2
... 또는 명명 된 레지스터로 기본 스택을 교체하십시오. 그것은 사용자의 두뇌에 더 많은 매듭을 만들지 만 이름을 갖기 위해 기본 스택이 필요하지 않습니다 ...] :-)
yeti

1
예, 확실히 편리합니다! 또한 단일 항목을 지우고 스택 맨 위에 있지 않은 항목을 회전하고 맨 위 n항목을 한 번에 다른 스택으로 옮길 수도 있습니다. 그러나 지금 dc은 소스 에서 컴파일하는 방법을 아직 모릅니다 . : /
Joe

2

C 번호 110 109 107 103 101 94 바이트

using i=System.Numerics.BigInteger;i f(i n){i a=0,b=1,x=1;for(;n-->0;)x*=a=(b+=a)-a;return x;}

설명

//Aliasing BigInteger saves a few bytes
using i=System.Numerics.BigInteger;

//Since BigInteger has an implicit from int we can also change the input
//and save two more bytes.
i f(i n)
{
    //using an alternative iterative algorithm (link to source below) to cut out the temp variable
    //b is next iteration, a is current iteration, and x is the running product
    i a = 0, b = 1, x = 1; 

    //post decrement n down to zero instead of creating a loop variable
    for (; n-- > 0;)

        //The bracket portion sets the next iteration             
        //get the current iteration and update our running product
        x *= a = (b += a) - a;

    return x;
}

반복 Fib 알고리즘


이것이 5 초 미만으로 돌아 오는 최대 N을 찾고 싶었던 것보다 훨씬 더 잘 수행되면 1540이 나오고 247441 자릿수의 숫자를 얻습니다.
JustinM-복원 모니카

감동적인. 호기심으로 1541을 계산하는 데 얼마나 걸립니까?
Pandacoder

@Pandacoder 최근 알고리즘 변경으로 인해 훨씬 ​​빨라졌습니다. 755ms에서 1541이므로 이제 새로운 하위 5 최대 값을 찾을 것입니다.
JustinM-복원 모니카

@ 판다 코더 (Pandacoder) 런타임 시간이 100 ~ 100ms 정도 차이가 나지만 2565는 평균 5 초 정도 인 것 같습니다
JustinM-Reinstate Monica

그 숫자는 얼마나됩니까?
Pandacoder

2

dc, 38 40 30 28 바이트

?si1d[sadlarla+zli>b]sbzli>b[*z1<*]ds*xf

si1d[sadlarla+zli>b*]sbzli>b

넓히는:

si     # Take input from top of stack and store it in register `i'
1d     # Push 1 on stack and duplicate
[      # Open macro definition
 sa    #  Store most recent term of Fibonacci sequence in register `a'
 d     #  Duplicate second most recent term
 la    #  Push most recent term onto stack
 r     #  Rotate top two items on stack
 la    #  Push most recent term onto stack (again)
       #  At this point, we've essentially duplicated the top two terms of the stack
       #    without altering the order of the terms
 +     #  Add top two terms of stack (generate next Fibonacci number)
 zli>b #  Take stack depth and load input (target number of terms); if we don't have
       #  enough terms yet, execute `b'
 *     #  Once we've generated all the terms (factors, really), we'll multiply
       #    them, one * for every time we iterated to generate a term
]sb    # Store macro in register `b'
zli>b  # Look familiar? This way, we change the "do-while" (`dsbx') to just "while"
       # Leave result on top of stack

z암시 적 루프 카운터 zli!=가 멋지다 !!! 그리고 스택의 모든 요소를 ​​수집하고 루프에 곱하는 것이 좋습니다 ... ;-) ...하지만 여기에 입력 1과 2에 매달립니다 GNU dc... :-(
yeti

@yeti Thanks : D 그리고 버그를 지적 해 주셔서 감사합니다; 나는 눈치 채지 못했다.
Joe

2

Brain-Flak , 54 바이트

([{}]<(())>){(({})()<{({}()<([({})]({}{}))>)}{}{}>)}{}

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

Brain-Flak의 곱셈은 큰 입력에 오랜 시간이 걸립니다. F 100 과 F 99 를 일반 곱셈 알고리즘으로 곱하면 수십억 년이 걸릴 것입니다.

다행히도 더 빠른 방법이 있습니다. 로 시작하는 일반화 된 피보나치 수열은 일반 수열과 (k, 0)동일한 항에을 곱한 항을 생성합니다 k. 이 관찰을 사용하여 Brain-Flak은 피보나치 수를 쉽게 생성 할 수있는 것처럼 피보나치 수를 곱할 수 있습니다.

스택 -n이 두 개의 숫자 로 구성 되면 일반화 된 피보나치 시퀀스의 반복을 {({}()<([({})]({}{}))>)}{}{}계산 n하고 마지막으로 모두 버립니다. 나머지 프로그램은 초기 1을 설정하고 범위 내 모든 숫자에 대해 이것을 반복합니다 n...1.

이 인터프리터가 제공하는 다른 언어의 동일한 알고리즘이 있습니다.

Brain-Flak Classic, 52 바이트

({}<(())>){(({})[]<{({}[]<(({}<>)<>{}<>)>)}{}{}>)}{}

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

브레인 플루, 58 바이트

<>(<(())>)<>{(({}<>)<{({}({}))({}[()])}{}>[()]<>)}<>({}){}

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

미니-플락, 62 바이트

([{}()](())){(({})()({({}()([({})]({}{}))[({})])}{}{})[{}])}{}

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


1

수학 -32 26 바이트

Fibonacci@i~Product~{i,#}&

@MartinEnder는 6 바이트를 잘랐습니다!


1

28 바이트

오늘 전에 GAP에 Fibonacci내장 기능 이 있다는 것을 몰랐습니다 .

n->Product([1..n],Fibonacci)

GAP에 연결할 수 있습니까? 그것이 무엇인지 전혀 모른다.
Leaky Nun

오 물론입니다 (그러나 여기에서 처음으로 사용하는 사람은 아닙니다 ...)
Christian Sievers

1

루비, 85 바이트

g =->x{(1..x).to_a.collect{|y|(0..y).inject([1,0]){|(a,b),_|[b, a+b]}[0]}.inject(:*)}

괜찮 았지만 아마도 더 짧은 해결책이있을 것입니다.

여기에서 가져온 빠른 피보나치 계산 : 링크

여기에서 테스트


1

줄리아, 36 바이트

!x=[([1 1;1 0]^n)[2]for n=1:x]|>prod

1

뇌 플랙 , 110 (104) 100 바이트

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

({}<((())<>)>){({}[()]<<>(({})<>({}<>)<>)>)}<>{}([[]]()){({}()<({}<>)<>({<({}[()])><>({})<>}{})>)}{}

설명

먼저 Green Eggs와 Iron Man 박사 의 피보나치 시퀀스 생성기 curtesy의 개선 된 버전을 실행합니다.

({}<((())<>)>){({}[()]<<>(({})<>({}<>)<>)>)}<>{}

그런 다음 스택에 둘 이상의 항목이있는 동안

([[]]()){({}()<...>)}

상위 두 항목을 곱하십시오

({}<>)<>({<({}[()])><>({})<>}{})

여분의 제로 팝

{}

1
불행히도, 25의 입력에 10 초가 걸리기 때문에 이것이 유효하지 않다고 생각합니다. 알고리즘은 매우 비효율적이므로 (언어와 마찬가지로) 100으로 계산하는 데 몇 시간이 걸릴 수 있습니다.
DJMcMayhem

1

클로저, 70 바이트

Clojure는 실제로 코드 골프에 적합한 언어는 아닙니다. 오 잘

http://tryclj.com 에서 사용해보십시오 .

(last(nth(iterate(fn[[a b r]][b(+ a b)(* r(+ a b))])[0N 1 1])(dec n)))


1

스위프트, 68 바이트

func f(n:Int,_ a:Int=1,_ b:Int=1)->Int{return n<1 ?1:a*f(n-1,b,a+b)}
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.