도전

잘 알려진 숫자 순서로 n'번째 요소 또는 첫 번째 요소' 를 출력하는 함수 / 프로그램을 작성하십시오 n.

         1, 2, 4, 8, 16 ...

아, 잠깐만 요. 처음 몇 개의 숫자를 잊었습니다.

1, 1, 1, 1, 2, 4, 8, 16 ...

도대체, 나는 좋은 측정을 위해 몇 가지를 더 추가 할 것입니다 :

1, 1, 1, 1, 2, 4, 8, 16, 33, 69, 146, 312, 673, 1463, 3202, 7050, 15605, 34705 ...

숫자는 (0 인덱스) 공식으로 주어진 일반화 된 카탈로니아 어 숫자입니다.

어디에

이다 OEIS A004149 .

시퀀스를 0 또는 1 인덱스로 만들 것인지 선택할 수 있습니다. 시퀀스는 물론 동일해야하므로 수식이 하나 인 경우 수식을 다시 작성해야합니다.

파이썬 , 51 바이트

f=lambda n,k=2:n<3or k<n and f(k)*f(n-k-2)+f(n,k+1)

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

수식을 약간 단순화합니다.

펄 6 , 44 바이트

{1,1,1,1,{sum @_[2..*]Z*@_[@_-4...0,0]}...*}

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

게으른 무한 값 시퀀스를 반환하는 익명 코드 블록입니다. 이것은 설명 된대로 시퀀스를 거의 구현하며, zip 바로 가기는 두 번째 요소 이후까지 모든 요소에 네 번째 요소부터 시작하여 목록의 반대 부분을 추가 1하고 끝에 추가 요소를 추가합니다 .

설명:

{                                          }  # Anonymous code block
                                       ...*   # Create an infinite sequence
 1,1,1,1,                                     # Starting with four 1s
         {                            }       # Where each new element is:
          sum                                   # The sum of
              @_[2..*]                          # The second element onwards
                      Z*                        # Zip multiplied with
                        @_[@_-4...0  ]          # The fourth last element backwards
                                   ,0           # And 1

05AB1E , 14 13 11 바이트

$ƒˆ¯Âø¨¨¨PO

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

n 번째 요소 (0 인덱스)를 출력합니다.

$                # push 1 and the input
 ƒ               # repeat (input+1) times
  ˆ              #  add the top of the stack (initially 1) to the global array
   ¯             #  push the global array
    Â            #  and a reversed copy of it
     ø           #  zip the two together, giving a list of pairs
      ¨¨¨        #  drop the last 3 pairs
         P       #  take the product of each pair (or 1 if the list is empty)
          O      #  take the sum of those products
                 #  after the last iteration, this is implicitly output;
                 #  otherwise, it's added to the global array by the next iteration

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

xnor의 솔루션 포트 .

인덱스가 0입니다.

f=(n,k=2)=>n<3||k<n&&f(k)*f(n+~++k)+f(n,k)

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

자바 스크립트 (ES6),  83  75 바이트

더 빠르고 덜 재귀하지만 훨씬 더 긴 솔루션입니다.

인덱스가 0입니다.

f=(n,i,a=[p=1])=>a[n]||f(n,-~i,[...a,p+=(h=k=>k<i&&a[k]*a[i-++k]+h(k))(2)])

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

하스켈, 49 43 39 바이트

a n=max(sum[a k*a(n-2-k)|k<-[2..n-1]])1              

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

들어 n<3(가) sum0, 그래서 max ... 1그것을가 발생합니다 1.

편집 : @Jo King 덕분에 -6 바이트.

Wolfram Language (Mathematica) , 36 바이트

Sum[#0@i#0[#-i-1],{i,3,#-1}]/. 0->1&

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

1- 색인.

2- 인덱싱 된 시퀀스는 4 바이트 더 짧습니다 Sum[#0@i#0[#-i],{i,#-4}]/. 0->1&. 온라인으로 사용해보십시오!

05AB1E , 17 13 바이트

4Å1λ£₁λ¨Â¦¦s¦¦*O+

기존 05AB1E 답변 보다 짧지는 않지만 새로운 05AB1E 버전의 재귀 기능을 직접 연습 해보고 싶었습니다. 아마도 몇 바이트 정도 골프를 쳤을 것입니다. 편집 : 그리고 그것은 사실의 재귀 버전을 볼 수 있습니다 @Grimy 입니다 아래의 05AB1E 응답, 13 바이트를 .

$n$

$n$£è
£

설명:

$a(n)= a(n-1) + \sum_{k=2}^{n-1}(a(k)\cdot a(n-1-k))$

$a(0)=a(1)=a(2)=a(3)=1$

   λ               # Create a recursive environment,
    £              # to output the first (implicit) input amount of results after we're done
4Å1                # Start this recursive list with [1,1,1,1], thus a(0)=a(1)=a(2)=a(3)=1
                   # Within the recursive environment, do the following:
      λ            #  Push the list of values in the range [a(0),a(n)]
       ¨           #  Remove the last one to make the range [a(0),a(n-1)]
        Â          #  Bifurcate this list (short for Duplicate & Reverse copy)
         ¦¦        #  Remove the first two items of the reversed list,
                   #  so we'll have a list with the values in the range [a(n-3),a(0)]
           s       #  Swap to get the [a(0),a(n-1)] list again
            ¦¦     #  Remove the first two items of this list as well,
                   #  so we'll have a list with the values in the range [a(2),a(n-1)]
              *    #  Multiply the values at the same indices in both lists,
                   #  so we'll have a list with the values [a(n-3)*a(2),...,a(0)*a(n-1)]
               O   #  Take the sum of this list
     ₁          +  #  And add it to the a(n-1)'th value
                   # (afterwards the resulting list is output implicitly)

@Grimy의 13 바이트 버전 ( 아직 대답 하지 않았다면 답 을 올리십시오 !) :

1λ£λ1šÂ¨¨¨øPO

$n$

1λèλ1šÂ¨¨¨øPO
λλ1šÂ¨¨¨øPO$a(0)=1$

설명:

$a(n) = \sum_{k=2}^{n-1}(a(k)\cdot a(n-2-k))$

$a(-1) = a(0) = a(1) = a(2) = 1$

 λ             # Create a recursive environment,
  £            # to output the first (implicit) input amount of results after we're done
1              # Start this recursive list with 1, thus a(0)=1
               # Within the recursive environment, do the following:
   λ           #  Push the list of values in the range [a(0),a(n)]
    1š         #  Prepend 1 in front of this list
      Â        #  Bifurcate the list (short for Duplicate & Reverse copy)
       ¨¨¨     #  Remove (up to) the last three value in this reversed list
          ø    #  Create pairs with the list we bifurcated earlier
               #  (which will automatically remove any trailing items of the longer list)
           P   #  Get the product of each pair (which will result in 1 for an empty list)
            O  #  And sum the entire list
               # (afterwards the resulting list is output implicitly)

파이썬 3 , 59 바이트

정말 비효율적이며 a(13)TIO에서 끝나지 않습니다.

a=lambda n,k=2:n<4or(n-k<2)*a(n-1)or a(k)*a(n-k-2)+a(n,k+1)

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

젤리 , 17 바이트

1WṪ;+¥×Uṫ3SƲ;@Ʋ⁸¡

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

$n$$0$$n$

하스켈 , 76 바이트

1:1:1:f[1,1,1]
f(x:z)|y<-x+sum(zipWith(*)(init$init z)$reverse z)=y:f(y:x:z)

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

APL (Dyalog Extended) , 34 바이트 ^SBCS

Dzaima 덕분에 -2.

익명 접두사 람다.

{⍵≤3:1⋄+/(∇⍵-1),⍵(-×⍥∇¯2+⊢)¨4…⍵}

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

Japt , 19 17 16 바이트

n1 차 색인 된 용어를 출력합니다 .

@Zí*Zz2)Ťx}g4Æ1

시도 해봐

@Zí*Zz2)Ťx}g4Æ1     :Implicit input of integer U
@                    :Function taking an array as an argument via parameter Z
 Zí                  :  Interleave Z with
    Zz2              :  Z rotated clockwise by 180 degrees (simply reversing would be a bye shorter but would modify the original array)
   *                 :  Reduce each pair by multiplcation
       )             :  End interleave
        Å            :  Slice off the first element
         ¤           :  Slice off the first 2 elements
          x          :  Reduce by addition
           }         :End function
            g        :Pass the following as Z, push the result back to it and repeat until it has length U
             4Æ1     :Map the range [0,4) to 1s
                     :Implicit output of the last element

하스켈 , 65 바이트

f a|a<4=1|z<-g[2..a]=sum$zipWith(*)z$reverse(1:g[0..a-4])
g=map f

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

당신도 사용할 수있는 f일련의 단일 요소를 얻기 위해, 또는에 값 목록을 전달 g하고 해당 목록에 대한 모든 인덱스를 얻을.

넷째 (gforth) , 99 81 바이트

: f recursive dup 4 > if 0 over 3 do over 1- i - f i f * + loop else 1 then nip ;

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

출력은 n 번째 항이고 입력은 1- 인덱싱 됨

편집 : xnor의 수식으로 전환하여 17 바이트를 절약했습니다. 1 인덱싱을 사용하여 다른 1 바이트를 저장했습니다.

코드 설명

: f                     \ start a new word definition
  recursive             \ mark that this word will be recursive
  dup 4 >               \ duplicate the input and check if it is greater than 4
  if                    \ if it is:
    0 over              \ create an accumulator and copy n to top of stack
    3 do                \ start counted loop from 3 to n-1
      over 1- i - f     \ recursively calculate f(n-1-i)
      i f               \ recursively calculate f(i)
      * +               \ multiply results and add to accumulator
    loop                \ end the counted loop        
  else                  \ otherwise, if n < 5
    1                   \ put 1 on the stack
  then                  \ end the if block
  nip                   \ drop n from the stack
;                       \ end the word definition

숯 , 26 바이트

Ｆ⁵⊞υ¹ＦＮ⊞υΣ✂Ｅ⮌υ×κ§υλ³→Ｉ§υ±⁴

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 내부적으로 1 인덱싱을 사용하여 계산하지만 0 인덱싱 된 n 번째 숫자를 인쇄합니다. 설명:

Ｆ⁵⊞υ¹

로 시작하십시오 a[0] = a[1] = a[2] = a[3] = a[4] = 1. 예, 이것은 1- 인덱싱되지만 추가 0 값입니다. 그것은 당신을위한 코드 골프입니다.

ＦＮ

추가 n항을 계산하십시오 . 이것은 과도하지만, 때 원하는 용어를 쉽게 찾을 수 n<5있습니다.

⊞υΣ✂Ｅ⮌υ×κ§υλ³

각 항에 대해 다음 항을 지금까지 사용한 항의 합계와 세 항을 제외한 항의 역수를 곱한 값으로 계산합니다.

→

이것은 Charcoal이 2 인수 형식의 구문 분석을 속이는 데 사용되지 Slice않는 방법 입니다 . 그렇지 않으면 3 개의 용어를 제거하는 덜 골프적인 방법을 사용해야합니다.

Ｉ§υ±⁴

마지막 네 번째 항을 출력합니다.

Pyth , 30 바이트

J*4]1VQ=+J+eJsPP*M.t,PJ_PJ0;<J

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

$n$

J*4]1VQ=+J+eJsPP*M.t,PJ_PJ0;<JQ # Full program, last Q = input (implicitly added)
J*4]1                  # J = 4 * [1] (=[1,1,1,1])
VQ                     # for N in range(Q):
  =+J                  #  J +=
     +eJ               #   J[-1] + 
        s              #    sum(                           )
           *M          #     map(__operator_mul,          )
             .t      0 #      transpose(          , pad=0)
               ,       #       [       ,         ]
                PJ     #         J[:-1] 
                  _PJ  #                 J[1::-1]
<JQ                    # J[::Q]

<@$n$

루비 , 42 41 바이트

f=->n{n<4?1:(4..n).sum{|i|f[i-1]*f[n-i]}}

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

1- 인덱스 (1 바이트 저장)

옥타브 , 73 바이트

g=(1:4).^0;for(i=3:(n=input('')))g(i+2)=g(4:i+1)*g(i-(2:i-1))';end;g(end)

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

Stewie Griffin 덕분에 -2 바이트 다시 한 번 명령형 접근 방식이 기능 재귀 적 접근 방식보다 우선합니다. 그 중 하나가 아래에 나와 있습니다.

옥타브 , 75 바이트

f(f=@(a)@(n){@()sum(arrayfun(@(k)a(a)(k)*a(a)(n-2-k),2:n-1)),1}{2-(n>3)}())

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

Captcha는 이것을 게시 할 때 내가 사람인지 확인하고 싶었습니다. 솔직히 말해서, 나는 확실하지 않다 .

펄 5 -MList::Util=sum , 61 바이트

sub a{my$b=-2+pop;$b<2||sum a($b+1),map{a($_)*a($b-$_)}2..$b}

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

C / C ++ , 70 69 67 바이트

Jonathan 덕분에 -1 바이트.

int a(int n){int k=2,s=0;while(++k<n)s+=a(k)*a(n+~k);return s?s:1;}

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