실베스터의 시퀀스 OEIS A000058 은 다음과 같이 정의 된 정수 시퀀스입니다.

각 멤버는 모든 이전 멤버의 곱에 1을 더한 것입니다. 시퀀스의 첫 번째 멤버는 2입니다.

태스크

n을 취하고 실베스터 시퀀스의 n 번째 항을 계산하는 가능한 가장 작은 프로그램을 만듭니다. 표준 입력, 출력 및 허점이 적용됩니다. 결과가 매우 빠르게 커지므로 선택한 언어로 인해 오버플로가 발생하는 용어를 사용하지 않아도됩니다.

테스트 사례

인덱스를 0 개 또는 1 개 사용할 수 있습니다. (여기서는 제로 인덱싱을 사용합니다)

>>0
2
>>1
3
>>2
7
>>3
43
>>4
1807

Brain-Flak , 76 68 58 52 46 바이트

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

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

이 관계를 대신 사용하십시오.

시퀀스에서 제공된 관계로부터 수정 된이 관계에서 파생됩니다.

a(n+1) = a(n) * (a(n) - 1) + 1.

설명

각 명령의 기능에 대한 설명서 는 GitHub 페이지 를 방문 하십시오 .

Brain-Flak에는 두 개의 스택이 있으며, 각각 Stack 1과 Stack 2로 이름을 지정합니다.

입력은 스택 1에 저장됩니다.

<>(()())<>             Store 2 in Stack 2.

{                      while(Stack_1 != 0){
  ({}[()])                 Stack_1 <- Stack_1 - 1;
  <>                       Switch stack.
  ({({}[()])({})}{}())     Generate the next number in Stack 2.
  <>                       Switch back to Stack 1.
}

<>                     Switch to Stack 2, implicitly print.

생성 알고리즘의 경우 :

({({}[()])({})}{}())      Top <- (Top + Top + (Top-1) + (Top-1) + ... + 0) + 1

(                  )      Push the sum of the numbers evaluated in the process:

 {            }               while(Top != 0){
  ({}[()])                        Pop Top, push Top-1    (added to sum)
          ({})                    Pop again, push again  (added to sum)
                              }

               {}             Top of stack is now zero, pop it.
                 ()           Evaluates to 1 (added to sum).

대체 46 바이트 버전

이것은 하나의 스택 만 사용합니다.

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

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

젤리 , 5 바이트

Ḷ߀P‘

이것은 0 기반 인덱싱과 챌린지 사양의 정의를 사용합니다.

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

Ḷ߀P‘  Main link. Argument: n

Ḷ      Unlength; yield [0, ..., n - 1].
 ߀    Recursively apply the main link to each integer in that range.
   P   Take the product. This yields 1 for an empty range.
    ‘  Increment.

헥사 고니 , 27 바이트

1{?)=}&~".>")!@(</=+={"/>}*

펼쳐진 :

    1 { ? )
   = } & ~ "
  . > " ) ! @
 ( < / = + = {
  " / > } * .
   . . . . .
    . . . .

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

설명

순서를 고려하고 b(a) = a(n) - 1약간의 정리를 해 봅시다 .

b(a) = a(n) - 1
     = a(n-1)*(a(n-1)-1) + 1 - 1
     = (b(n-1) + 1)*(b(n-1) + 1 - 1)
     = (b(n-1) + 1)*b(n-1)
     = b(n-1)^2 + b(n-1)

이 순서는 매우 비슷하지만,이 프로그램에서 바이트를 저장하기 위해 증분을 끝까지 연기 할 수 있습니다.

주석이 달린 소스 코드는 다음과 같습니다.

^{Timwi의 HexagonyColorer로 작성되었습니다 .}

다음은 메모리 다이어그램입니다 (빨간색 삼각형은 메모리 포인터의 초기 위치 및 방향을 나타냅니다).

^{Timwi의 EsotericIDE로 작성되었습니다 .}

코드는 왼쪽 모서리를 감싸는 회색 경로에서 시작하므로 초기 선형 비트는 다음과 같습니다.

1{?)(
1      Set edge b(1) to 1.
 {     Move MP to edge N.
  ?    Read input into edge N.
   )(  Increment, decrement (no-op).

그런 다음 코드 <는 분기 인 분기를 누르고 주 루프의 시작 (및 끝)을 나타냅니다. 만큼로서 N의 에지는 양의 값을 갖고, 녹색 경로가 실행된다. 이 경로는 그리드를 몇 번 감쌀 수 있지만 실제로는 완전히 선형입니다.

""~&}=.*}=+={....(

는 .실제 코드가 있으므로, 어떤 작전 없습니다 :

""~&}=*}=+={(
""             Move the MP to edge "copy".
  ~            Negate. This is to ensure that the value is negative so that &...
   &           ...copies the left-hand neighbour, i.e. b(i).
    }=         Move the MP to edge b(i)^2 and turn it around.
      *        Multiply the two copies of b(i) to compute b(i)^2.
       }=      Move the MP back to edge b(i) and turn it around.
         +     Add the values in edges "copy" and b(i)^2 to compute
               b(i) + b(i)^2 = b(i+1).
          ={   Turn the memory pointer around and move to edge N.
            (  Decrement.

이 감소하는이 감소하면 N에 0빨간색 경로가 실행됩니다 :

")!@
"     Move MP back to edge b(i) (which now holds b(N)).
 )    Increment to get a(N).
  !   Print as integer.
   @  Terminate the program.

J, 18 14 12 바이트

이 버전은 randomra 덕분입니다. 나중에 자세한 설명을 작성하려고합니다.

0&(]*:-<:)2:

J, 14 바이트

이 버전은 마일 덕분입니다. ^:아래와 같이 아젠다 대신 파워 부사 를 사용했습니다 . 앞으로 더 많은 설명.

2(]*:-<:)^:[~]

J, 18 바이트

2:`(1+*/@$:@i.)@.*

인덱스가 0입니다.

예

   e =: 2:`(1+*/@$:@i.)@.*
   e 1
3
   e 2
7
   e 3
43
   e 4
1807
   x: e i. 10
2 3 7 43 1807 3263443 10650056950807 113423713055421862298779648 12864938683278674737956996400574416174101565840293888 1655066473245199944217466828172807675196959605278049661438916426914992848    91480678309535880456026315554816
   |: ,: x: e i. 10
                                                                                                        2
                                                                                                        3
                                                                                                        7
                                                                                                       43
                                                                                                     1807
                                                                                                  3263443
                                                                                           10650056950807
                                                                              113423713055421862298779648
                                                    12864938683278674737956996400574416174101565840293888
165506647324519994421746682817280767519695960527804966143891642691499284891480678309535880456026315554816

설명

이것은 다음과 같은 의제입니다.

           ┌─ 2:
           │    ┌─ 1
       ┌───┤    ├─ +
       │   └────┤           ┌─ / ─── *
── @. ─┤        │     ┌─ @ ─┴─ $:
       │        └─ @ ─┴─ i.
       └─ *

( (9!:7)'┌┬┐├┼┤└┴┘│─'then을 사용하여 생성 5!:4<'e')

분해 :

       ┌─ ...
       │
── @. ─┤
       │
       └─ *

상단 분기를 gerund로 사용하고 G하단을 selector로 사용 F하면 다음과 같습니다.

e n     <=>     ((F n) { G) n

이 2:경우 0 = * n, 즉 부호가 0 일 때 (따라서 0 일 때) 상수 함수를 사용합니다 n. 그렇지 않으면이 포크를 사용합니다.

  ┌─ 1
  ├─ +
──┤           ┌─ / ─── *
  │     ┌─ @ ─┴─ $:
  └─ @ ─┴─ i.

다음 시리즈 중 하나에 다음을 더한 것입니다.

            ┌─ / ─── *
      ┌─ @ ─┴─ $:
── @ ─┴─ i.

더 나아가서, 이것은 범위 ( )에 */대한 자체 참조 ( $:)보다 곱 ( i.)입니다.

펄 6 , 24 바이트

{(2,{1+[*] @_}...*)[$_]}

{(2,{1+.²-$_}...*)[$_]}

설명

# bare block with implicit parameter ｢$_｣
{
  (
    # You can replace 2 with 1 here
    # so that it uses 1 based indexing
    # rather than 0 based
    2,

    # bare block with implicit parameter ｢@_｣
    {
      1 +

      # reduce the input of this inner block with ｢&infix:<*>｣
      # ( the input is all of them generated when using a slurpy @ var )
      [*] @_

      # that is the same as:
      # ｢@_.reduce: &infix:<*>｣
    }

    # keep calling that to generate more values until:
    ...

    # forever
    *

  # get the value as indexed by the input
  )[ $_ ]
}

용법:

my &code = {(2,{1+[*] @_}...*)[$_]}

say code 0; # 2
say code 1; # 3
say code 2; # 7
say code 3; # 43
say code 4; # 1807

# you can even give it a range
say code 4..7;
# (1807 3263443 10650056950807 113423713055421844361000443)

say code 8;
# 12864938683278671740537145998360961546653259485195807
say code 9;
# 165506647324519964198468195444439180017513152706377497841851388766535868639572406808911988131737645185443
say code 10;
# 27392450308603031423410234291674686281194364367580914627947367941608692026226993634332118404582438634929548737283992369758487974306317730580753883429460344956410077034761330476016739454649828385541500213920807

my $start = now;
# how many digits are there in the 20th value
say chars code 20;
# 213441

my $finish = now;
# how long did it take to generate the values up to 20
say $finish - $start, ' seconds';
# 49.7069076 seconds

하스켈, 26 바이트

f n|n<1=2|m<-f$n-1=1+m*m-m

사용 예 : f 4-> 1807.

자바 7, 46 42 바이트

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

일반적인 수식으로 0- 인덱싱을 사용합니다. Java에는 편리한 전력 연산자가 없기 때문에 통화가 오래 걸리기 때문에 교체 n*n-n했습니다 .n*(n-1)f()

하스켈, 25 바이트

(iterate(\m->m*m-m+1)2!!)

SILOS , 60 바이트

readIO 
p = 2
lblL
r = p
r + 1
p * r
i - 1
if i L
printInt r

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

내 대답의 포트는 C 입니다.

뇌 플랙 , 158 154 바이트

새는 수녀가 여기서 이겼어

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

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

설명

입력 a (0) 아래에 2를 넣으십시오.

({}<(()())>) 

입력이 0보다 큰 동안 입력에서 1을 빼고 ...

{
({}[()]

아무 말 않고...

<

곱셈을위한 촉매로 작용하기 위해 하나를 다른 스택에 놓는다 <> (()) <>

스택이 비어 있지 않은 동안

 ([])
 {
  {}

목록의 맨 위로 이동하여 복사

  <>({}<<>(({}<>))><>)

사본에 촉매를 곱하십시오

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

하나 추가

 <>({}())

시퀀스를 올바른 스택으로 다시 이동

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

맨 아래 항목을 제외한 모든 항목 제거

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

C, 32 바이트

f(n){return--n?f(n)*~-f(n)+1:2;}

1 기반 인덱싱을 사용합니다. Ideone에서 테스트하십시오 .

실제로 9 바이트

2@`rΣτu`n

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

이 관계를 대신 사용하십시오.

시퀀스에서 제공된 관계로부터 수정 된이 관계에서 파생됩니다.

a(n+1) = a(n) * (a(n) - 1) + 1.

R, 44 42 41 바이트

JDL 덕분에 2 바이트 절약

사용자 덕분에 1 바이트 절약

f=function(n)ifelse(n,(a=f(n-1))^2-a+1,2)

오아시스 , 4 바이트 (비경쟁)

아마 골프 가족의 나의 마지막 언어! 언어는 도전 과제를 게시하기 때문에 비경쟁.

암호:

²->2

Zwei의 대체 솔루션 :

<*>2

확장 버전 :

a(n) = ²->
a(0) = 2

설명:

²    # Stack is empty, so calculate a(n - 1) ** 2.
 -   # Subtract, arity 2, so use a(n - 1).
  >  # Increment by 1.

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

파이썬, 38 36 바이트

Dennis 덕분에 2 바이트.

f=lambda n:0**n*2or~-f(n-1)*f(n-1)+1

무시 했어!

대신 순서에서 제공된 관계를 수정하여이 관계를 사용하십시오.

a(n+1) = a(n) * (a(n) - 1) + 1

설명

0**n*2파이썬으로 정의되어 있기 때문에 2언제 n=0와 0달리 반환합니다 .0**01

체다 , 26 바이트

n g->n?g(n-=1)**2-g(n)+1:2

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

꽤 관용적입니다.

설명

n g ->    // Input n, g is this function
  n ?     // if n is > 1
    g(n-=1)**2-g(n)+1   // Do equation specified in OEIS
  : 2     // if n == 0 return 2

CJam, 10 바이트

2{_(*)}ri*

0 기반 인덱싱을 사용합니다. 온라인으로 사용해보십시오!

05AB1E , 7 바이트

2sFD<*>

설명

0부터 시작하는 인덱싱을 사용합니다.

2         # push 2 (initialization for n=0)
 sF       # input nr of times do
   D<*    # x(x-1)
      >   # add 1

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

프롤로그, 49 바이트

a(0,2).
a(N,R):-N>0,M is N-1,a(M,T),R is T*T-T+1.

SILOS 201 바이트

readIO 
def : lbl
set 128 2
set 129 3
j = i
if j z
print 2
GOTO e
:z
j - 1
if j Z
print 3
GOTO e
:Z
i - 1
:a
a = 127
b = 1
c = 1
:b
b * c
a + 1
c = get a
if c b
b + 1
set a b
i - 1
if i a
printInt b
:e

온라인으로 자유롭게 사용해보십시오!

젤리 , 7 바이트

²_’
2Ç¡

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

순서대로 제공된이 관계를 대신 사용하십시오. a(n+1) = a(n)^2 - a(n) + 1

설명

2Ç¡   Main chain, argument in input

2     Start with 2
  ¡   Repeat as many times as the input:
 Ç        the helper link.


²_’   Helper link, argument: z
²     z²
  ’   z - 1
 _    subtraction, yielding z² - (z-1) = z² - z + 1

C, 46 바이트

s(n,p,r){for(p=r=2;n-->0;p*=r)r=p+1;return r;}

무시 했어!

용도 p 제품의 임시 저장한다.

기본적으로, 두 시퀀스를 정의 p(n)하고 r(n), 어디에 r(n)=p(n-1)+1및 p(n)=p(n-1)*r(n).

r(n) 필요한 순서입니다.

R, 50 46 44 바이트

    n=scan();v=2;if(n)for(i in 1:n){v=v^2-v+1};v

전체 시퀀스를 추적하는 대신, n> 1 n> 0 인 한 주어진 2 차 업데이트 규칙을 따르는 제품을 추적합니다 . (이 순서는 "start at one "규칙을 사용합니다)

0에서 시작 규칙을 사용하면 if (n> 1) 대신 if (n)을 사용할 수 있으므로 몇 바이트가 절약됩니다.

해파리 , 13 바이트

p
\Ai
&(*
><2

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

설명

처음부터 시작합시다 :

(*
<

이것은 함수를 정의하는 후크 f(x) = (x-1)*x입니다.

&(*
><

이것은 증가 함수와 함께 이전 후크를 구성하여 함수를 제공합니다 g(x) = (x-1)*x+1.

\Ai
&(*
><

마지막으로 정수 입력에 의해 주어진 횟수만큼 h이전 함수의 반복 인 함수 를 생성합니다 g.

\Ai
&(*
><2

마지막으로이 반복을 초기 값에 적용합니다 2. 그만큼p상단에 그냥 결과를 인쇄합니다.

대안 (또한 13 바이트)

p
>
\Ai
(*
>1

이것은 끝까지 증분을 연기합니다.

C, 43 , 34 , 33 바이트

1- 색인 :

F(n){return--n?n=F(n),n*n-n+1:2;}

메인 테스트 :

int main() {
  printf("%d\n", F(1));
  printf("%d\n", F(2));
  printf("%d\n", F(3));
  printf("%d\n", F(4));
  printf("%d\n", F(5));
}

Brachylog , 13 바이트

0,2|-:0&-y+*+

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

이 관계를 대신 사용하십시오.

시퀀스에서 제공된 관계로부터 수정 된이 관계에서 파생됩니다.

a(n+1) = a(n) * (a(n) - 1) + 1.

매스 매 티카, 19 바이트

Nest[#^2-#+1&,2,#]&

또는 21 바이트 :

Array[#0,#,0,1+1##&]&

미로 , 18 바이트

동일한 솔루션을 독립적으로 찾은 Sp3000의 공로

?
#
)}"{!@
* (
(:{

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

사실 , (14) 12 바이트

이것은 0 인덱싱을 사용했습니다. 골프 제안을 환영합니다. 온라인으로 사용해보십시오!

2#,`;πu@o`nF

풀기 :

2#              Start with [2]
  ,`     `n     Take 0-indexed input and run function (input) times
    ;           Duplicate list
     πu         Take product of list and increment
       @o       Swap and append result to the beginning of the list
           F    Return the first item of the resulting list

GolfScript , 12 10 바이트

Dennis 덕분에 2 바이트.

~2\{.(*)}*

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

사용합니다 a(n) = a(n-1) * (a(n-1)-1) + 1.