정의

a (1) = 1
a (2) = 1
n> 2에 대한 a (n) = a (na (n-1)) + a (na (n-2)) 여기서 n은 정수

태스크

양의 정수가 주어지면 n생성 a(n)합니다.

테스트 케이스

참고

의무적 OEIS A005185

code-golf sequence arithmetic

— 새는 수녀
소스

레티 나 , 84 83 79 74 바이트

바이트 수는 ISO 8859-1 인코딩을 가정합니다.

.+
$*;1¶1¶
+`;(?=(1)+¶(1)+)(?=(?<-1>(1+)¶)+)(?=(?<-2>(1+)¶)+)
$3$4¶
G3=`
1

온라인으로 사용해보십시오! 첫 번째 줄은 줄 바꿈으로 구분 된 테스트 스위트를 활성화합니다.

나는 이것을 나중에 더 골프화해야 할 것이다.

— 마틴 엔더
소스

9

하스켈, 35 33 바이트

a n|n<3=1|b<-a.(-)n=b(b 1)+b(b 2)

함수를 정의합니다 a.

— 앤더스 카 소르 그
소스

2

바인드와 함께 멋진 트릭! (b.b)1+(b.b)2합보다 짧은 것이 좋지 않습니까?

— xnor

예, 감사합니다. @xnor.

— Anders Kaseorg

8

줄리아, 29 바이트

!n=n<3||!(n-!~-n)+!(n-!~-~-n)

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

작동 원리

우리는 !목적에 맞게 단항 연산자 를 재정의합니다 .

경우 n이 인 1 또는 2 , n<3반환 사실 이 우리의 반환 값입니다.

만약 N 보다 큰 2 , n<3반환 거짓 과 || 지점이 실행됩니다. 이 정의의 간단한 구현 ~-n수율 1 - N 및 ~-~-n수율 N - 2 .

— 데니스
소스

7

Sesos, 54 바이트

0000000: eefb5b 04f83a a75dc2 36f8d7 cf6dd0 af7b3b 3ef8d7  ..[..:.].6...m..{;>..
0000015: cfed12 f661f0 ae9d83 ee63e6 065df7 ce6183 af7383  ....a.....c..]..a..s.
000002a: 76ef3c 3f6383 7eff9c b9e37f                       v.<?c.~.....

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

분해

또는 Brainfuck 표기법에서 :

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

— 앤더스 카 소르 그
소스

6

C, 43 42 바이트

@Dennis 덕분에 1 바이트 절약

모든 대답은 동일합니다. 다른 것을해야합니다!

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

a(n){return n<3?:a(n-a(n-2))+a(n---a(n));}

설명 : 기본적입니다 a(n-a(n-2))+a(n-a(n-1))만 swaggy로 ^{정의되지 않은} 행동 (내 전화 (GCC)와 ideone에 작품).

— 내기
소스

4

1. 컴파일러도 언급해야합니다. "swag"은 정의되지 않은 동작입니다. 2. GCC를 사용하면 및 1사이 가 필요하지 않습니다 . ?:

— Dennis

@Dennis 흥미롭게도 동일한 공식이 반복적 인 PowerShell 답변에서 작동합니다 ... $b+=$b[$_-$b[$_-2]]+$b[$_---$b[$_]]

— AdmBorkBork

@TimmyD 일부 컴파일러는 n-- 전에 a (n)을 컴파일 할 수 있으며, 이에 대한 표준 (또는 정의 된) 동작은 없습니다. 따라서 정의되지 않은 동작.

— betseg

@betseg Yep, 동의합니다. 그것이 반드시 C에 고유하지는 않다고 지적하십시오.

— AdmBorkBork

@TimmyD 아, 나는 그것을 오해했다. 방금 모두가 사용하는 기능을 변경하고 싶기 때문에 내 것이 달라지고 멍청했습니다.

— betseg

5

Mathematica, 36 바이트

바이트 수는 ISO 8859-1 인코딩 및 Mathematica $CharacterEncoding가 WindowsANSI(Windows의 기본값, 다른 설정은 작동하지만 일부는 UTF-8그렇지 않은 것으로) 설정되어 있다고 가정합니다 .

±1=±2=1
±n_:=±(n-±(n-1))+±(n-±(n-2))

±단항 연산자로 정의합니다 .

중복을 제거하려고 시도했지만 동일한 바이트 수로 끝났습니다.

±1=±2=1
±n_:=Tr[±(n-±(n-#))&/@{1,2}]

— 마틴 엔더
소스

Retina에서 할 경우 +200 현상금을 줄 수 있습니다

— Leaky Nun

@LeakyNun 괜찮아? :)

— Martin Ender

이틀 후.

— Leaky Nun

@LeakyNun 곧 바운티를 쉽게 내 놓으면 담당자가 남지 않을 것입니다.

— mbomb007

채팅에서이 토론을 계속 합시다 .

— LegionMammal978

4

젤리 , 15 14 바이트

2Rạ⁸ß€$⁺Sµ1>?2

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

작동 원리

2Rạ⁸ß€$⁺Sµ1>?2  Main link. Argument: n (integer)

2R              Yield [1, 2].
      $         Combine the previous three links into a monadic chain.
   ⁸                Yield n.
  ạ                 Take the absolute difference of the return value and n.
    ß€              Recursively call the main link on each result.
       ⁺            Duplicate the chain.
                    The first copy maps [1, 2] to [a(n - 1), a(n - 2)].
                    The second copy maps [a(n - 1), a(n - 2)] to
                    [a(n - a(n - 1)), a(n - a(n - 2))].
        S           Take the sum.
         µ          Combine all links to the left into a chain.
            ?       If...
           > 2          n is greater than 2, call the chain.
          1         Else, return 1.

— 데니스
소스

Sesos에서 할 경우 +400 현상금을 줄 수 있습니다.

— Leaky Nun

@LeakyNun Sesos 답변이있는 것 같습니다. 당신의 의견 다음날에 나왔습니다.

— Yytsi

4

젤리 , 14 12 11 바이트

ịḣ2S;
1Ç⁸¡2ị

이것은 반복적 인 접근 방식입니다.

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

작동 원리

1Ç¡2ị   Main link. Argument: n

1       Set the return value to 1.
 Ç¡     Call the helper link n times, updating the return value after each call.
   2ị   Extract the second element of the resulting array.


ịḣ2S;   Helper link. Argument: A (array)

ị       At-index; retrieve the elements of A at the values of A.
 ḣ2     Head 2; extract the first two results.
    S   Take the sum of the result.
     ;  Prepend the sum to A.

— 데니스
소스

3

파이썬, 45 40 바이트

a=lambda n:n<3or a(n-a(n-1))+a(n-a(n-2))

도전에 대한 간단한 순진한 해석.

@LeakyNun 덕분에 5 바이트를 절약했습니다!

— 구리
소스

3

하스켈, 39 37 바이트

h n|n<3=1|n>2=h(n-h(n-1))+h(n-h(n-2))

가드를 사용하여 챌린지에 설명 된 것과 정확히 동일

— 칼카 스토어
소스

죄송합니다, (동일한) haskell 솔루션을 게시하기 전에 귀하의 솔루션을 보지 못했습니다. 그러나 줄 바꿈을 고려해야하므로 바이트 수 38이 아닙니까?

— Laikoni

그리고 가드이어야 n<3위해 h 2 할 수 1.

— Laikoni

@Laikoni 개행을 2 바이트로 계산하지 않는 한, 여러 줄 ( "" ") 문자열이있는 Pythons len 기능에 따르면 37입니다. 그래, 다른 문제가 해결되었습니다.

— KarlKastor

TIL notepad ++는 개행을 두 문자로 계산합니다.

— 라이 코니

@Laikoni는 줄 바꿈을 없 got습니다.

— KarlKastor

3

R, 50 바이트

a=function(n)ifelse(n<3,1,a(n-a(n-1))+a(n-a(n-2)))

용법:

> a(1)
  1
> a(20)
  12

— DSkoog
소스

3

CJam, 19 18 바이트

XXri{_($2$$+}*]-3=

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

반복적 인 접근 방식을 사용합니다.

— 마틴 엔더
소스

3

C #, 51 44 바이트

int a(int n)=>n<3?1:a(n-a(n-1))+a(n-a(n-2));

~~익명으로~~ 고맙습니다 pinkfloydx33 으로 인해 ~~이것이 단축 될 수 있는지 궁금합니다~~ !

— downrep_nation
소스

1

C # 6 식 바디 기능int a(int n)=>n<3?1:a(n-a(n-a))+a(n-a(n-2));

— pinkfloydx33

휴대 전화에서 입력하는 동안 오타가있는 것 같습니다. -a첫 번째 부분 집합에서 가장 안쪽 은-1

— pinkfloydx33

나는 그것을 알아 차리지 못했고, rq를 수정했다

— downrep_nation

3

자바 스크립트 (ES6), 45 바이트 34 바이트

ES6의 재귀 솔루션. 모든 골프 팁을 높이 평가합니다.

a=n=>n>2?a(n-a(n-1))+a(n-a(n-2)):1

더 짧아 진 / u / ismillo 에 감사합니다 .

— BugHunterUK
소스

2

골프 스크립트, 29 바이트

~[1 1]{..0=(=\..1=(=@+\+}@*2=

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

— 새는 수녀
소스

2

05AB1E, 29 바이트

반복적 인 솔루션.

XˆXˆÍL>v¯¤ys-è¯y¯yÍè-è+ˆ}¯¹<è

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

— 에미 냐
소스

2

APL, 20 바이트

{⍵≤2:1⋄+/∇¨⍵-∇¨⍵-⍳2}

설명:

{⍵≤2:1⋄+/∇¨⍵-∇¨⍵-⍳2}
 ⍵≤2:1               If argument is 2 or less, return 1
      ⋄              Otherwise:
               ⍵-⍳2  Subtract [1, 2] from the argument
             ∇¨      Recursive call on both
           ⍵-        Subtract both results from the argument     
         ∇¨          Recursive call on both again
       +/            Sum

— 마리 누스
소스

2

VBA Excel 87 바이트

비 재귀, n = 100000에서 작동하기를 원하기 때문에 다음과 같이 말합니다.

Function A(N):ReDim B(N):For i=3 To N:B(i)=B(i-B(i-1)-1)+B(i-B(i-2)-1)+1:Next:A=B(N)+1

... return줄 끝에서 (바이트 # 87)을 눌러 End Function"free"에 대한 문장 을 얻으십시오 . n = 1과 2의 초기화를 피하기 위해 B 값은 -1로 오프셋됩니다.

정상적으로 스프레드 시트의 호출, 예를 들면 =A(100000)얻을 수48157

재귀 버전, 61 바이트 ,

Function Y(N):If N<3 Then Y=1 Else Y=Y(N-Y(N-1))+Y(N-Y(N-2))

n> 30에 대해 불합리하게 느려지기 시작하고 n> 40에 대해 전혀 작동하지 않는다고 말할 수 있습니다.

— 조판
소스

우리는 성능에 관심이 없습니다. 우리는 코드 길이에 관심이 있습니다. 더 짧은 솔루션을 답의 맨 위로 이동해야합니다.

— mbomb007

1

@ mbomb007 골프에서 우승 할 수있는 곳이 없기 때문에 작업 프로그램을 구성하는 요소를 스스로 선택합니다. 단일 바이트 정수조차도 처리 할 수 없다면 내가 쉽게 할 수있는 해결책이있을 때 내가 걱정하는 한 충분하지 않습니다.

— Joffan

2

루비, 36 바이트

직접 구현. 모든 골프 제안은 환영합니다.

a=->n{n<3?1:a[n-a[n-1]]+a[n-a[n-2]]}

— Sherlock9
소스

Afaik, you can get rid of the a=. If you post it here, it suffices when your code starts with the ->. It counts as an anonymous function then.

— Seims

@Seims Unfortunately, as the function calls itself with a[n-1] and such, the function needs to be named.

— Sherlock9

2

Java 7, 68 61 51 bytes

17 saved thanks to Leaky Nun.

int a(int n){return n<3?1:a(n-a(n-1))+a(n-a(n-2));}

— Justin
소스

Welcome to PPCG!

— AdmBorkBork

Welcome to PPCG! You might like Tips for Golfing in Java. An alternate form would be: int a(int n){return n<3?1:a(n-a(n-2))+a(n---a(n));}, but unfortunately it uses the same amount of bytes as the answer you already have.. Also, I would specify that your answer is in Java 7, since the Java 8 answer would be shorter: n->return n<3?1:a(n-a(n-1))+a(n-a(n-2)) (39 bytes).

— Kevin Cruijssen

Thanks for the welcomes guys, and thanks for the tip on Java8 - I didn't realize lambdas were allowed like that - although they're allowed like that in Python, so I guess I just never thought about it. Does the lambda need a semi-colon?

— Justin

@JustinTervay I don't use Java 8 a lot, but from what I've heard the semi-colon isn't counted on single-line expressions, according to a comment by @DavidConrad and @CAD97 in one of my own Java answers.

— Kevin Cruijssen

2

Oasis, 9 7 5 bytes (non-competing)

Non-competing, since the language postdates the challenge. Thanks to Kenny Lau for saving 4 bytes. Code:

ece+V

Expanded form (V is short for 11):

a(n) = ece+
a(0) = 1
a(1) = 1

Code:

e        # Stack is empty, so a(n - 1) is used, and it calculates a(n - a(n - 1))
 c       # Calculate a(n - 2)
  e      # Calculate a(n - a(n - 2))
   +     # Add up

Try it online!. Calculates n = 1000 in 0.1 seconds.

— Adnan
소스

1

PowerShell v2+, 85 79 69 bytes

param($n)$b=1,1;2..$n|%{$b+=$b[$_-$b[$_-1]]+$b[$_-$b[$_-2]]};$b[$n-1]

Takes input $n, sets $b to be an array of @(1, 1), then enters a loop from 2 .. $n. Each iteration we tack onto $b the latest calculation in the sequence with a simple += and the definition of the sequence. We then output the appropriate number from $b (with a -1 because arrays in PowerShell are zero-indexed). This works if $n is 1 or 2 because both of those values are pre-populated into the lower indices of $b from the start, so even if the loop tacks on junk, it's ignored anyway.

Recursive solution 78 76 bytes

$a={param($k)if($k-lt3){1}else{(&$a($k-(&$a($k-1))))+(&$a($k-(&$a($k-2))))}}

First time I've used the equivalent of a lambda as the answer, as usually an iterative solution is shorter (as you can see from all the nested parens). ~~But, in this case, the nested parens are almost duplicated in the iterative solution with the nested array calls, so the recursive solution is shorter.~~ Nope, the iterative solution is indeed shorter (see above).

Call it via the execution-operator, like &$a 20. Just a straight-up recursive call.

— AdmBorkBork
소스

1

JavaScript (ES6), 66 bytes

n=>[...Array(n+1)].reduce((p,_,i,a)=>a[i]=i<3||a[i-p]+a[i-a[i-2]])

Non-recursive version for speed; recursive version is probably shorter but I'll leave it for someone else to write. I always like it when I get to use reduce. Note: 1 byte saved by returning true (which casts to 1 when used in an integer context) for of a(1) and a(2).

— Neil
소스

1

Pyth, 16 bytes

L|<b3smy-bytdtBb

L                  def y(b):
 |<b3                b < 3 or …
      m      tBb       map for d in [b - 1, b]:
       y-bytd            y(b - y(d - 1))
     s                 sum

Defines a function y.

Try it online (added yMS20 to print the first 20 values)

— Anders Kaseorg
소스

1

Forth, 76 bytes

I finally got it working!

: Q recursive dup dup 3 < if - 1+ else 2dup 2 - Q - Q -rot 1- Q - Q + then ;

Try it online

Explanation:

: Q recursive                           \ Define a recursive function Q
    dup dup 3 <                         \ I moved a dup here to golf 2 bytes
    if                                  \ If n < 3, return 1
        - 1                             \ Golf: n-n is zero, add one. Same as 2drop 1+
    else
        2dup 2 - Q - Q                  \ Copy n until 4 on stack, find Q(n-Q(n-2))
        -rot                            \ Move the result below 2 copies of n
        1- Q - Q +                      \ Find Q(n-Q(n-2)), then add to previous ^
    then ;

Try it online (slightly un-golfed from above)

Unfortunately, mutual recursion is a bit too wordy to use for golfing.

— mbomb007
소스

1

Maple, 43 41 bytes

a:=n->`if`(n>2,a(n-a(n-1))+a(n-a(n-2)),1)

Usage:

> a(1);
  1
> a(20);
  12

This problem is certainly a good candidate for memoization. Using option cache, the run times are cut down significantly:

aC := proc(n) 
      option cache; 
      ifelse( n > 2, aC( n - aC(n-1) ) + aC( n - aC(n-2) ), 1 ); 
end proc:

This can be seen using:

CodeTools:-Usage( aC(50) );

— DSkoog
소스

0

J, 29 28 bytes

1:`(+&$:/@:-$:@-&1 2)@.(2&<)

Uses the recursive definition.

Usage

Extra commands are used for formatting multiple input/output.

   f =: 1:`(+&$:/@:-$:@-&1 2)@.(2&<)
   (,:f"0) >: i. 20
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
1 1 2 3 3 4 5 5 6  6  6  8  8  8 10  9 10 11 11 12

Explanation

1:`(+&$:/@:-$:@-&1 2)@.(2&<)  Input: n
                        2&<   If n < 2
1:                              Return 1
                              Else
               -&1 2            Subtract [1, 2] from n to get [n-1, n-2]
            $:@                 Call recursively on n-1 and n-2
           -                    Subtract each of the results from n
        /@:                     Reduce using
      $:                          A recursive call on each
    +&                            Then summation
                                Return that value as the result

— miles
소스

0

dc, 62 bytes

?si2sa1dd2:a:a[la1+dsadd1-;a-;alad2-;a-;a+r:ali;a0=A]dsAxli;af

This solution makes use of arrays and recursion.

?si          # Take input from stdin and store it in register `i'
2sa          # Initialise register `a' with 2, since we'll be putting in the first
             #   two values in the sequence
1dd2         # Stack contents, top-down: 2 1 1 1
:a           # Pop index, then pop value: Store 1 in a[2]
:a           # Ditto:                     Store 1 in a[1]
[            # Open macro definition
 la 1+ dsa   # Simple counter mechanism: Increment a and keep a copy on stack

# The STACK-TRACKER(tm): Top of stack will be at top of each column, under the
#   dashed line. Read commands from left to right, wrapping around to next line.
#   This will be iteration number n.
  dd   1-    ;a       -          ;a            la            d          
#-----------------------------------------------------------------------
# n    n-1   a[n-1]   n-a[n-1]   a[n-a[n-1]]   n             n          
# n    n     n        n          n             a[n-a[n-1]]   n          
# n    n     n                                 n             a[n-a[n-1]]
#                                                            n          
#                                                                       

  2-            ;a            -             ;a            +      r    :a
#-----------------------------------------------------------------------
# n-2           a[n-2]        n-a[n-2]      a[n-a[n-2]]   a[n]   n      
# n             n             a[n-a[n-1]]   a[n-a[n-1]]   n      a[n]   
# a[n-a[n-1]]   a[n-a[n-1]]   n             n                           
# n             n                                                       

 li;a        # Load index of target element, and fetch that element's current value
             #    Uninitialised values are zero
 0=A         # If a[i]==0, execute A to compute next term
]dsAx        # Close macro definition, store on `A' and execute
li;a         # When we've got enough terms, load target index and push value
f            # Dump stack (a[i]) to stdout

— Joe
소스

In conclusion, if anyone is building an IDE for dc, let me know!

— Joe

0

Erlang, 46 bytes

f(N)when N<3->1;f(N)->f(N-f(N-1))+f(N-f(N-2)).

— c.P.u1
소스

0

Lua, 59 bytes

function a(n)return n<3 and 1 or a(n-a(n-1))+a(n-a(n-2))end

— brianush1
소스

호프 스타터 Q- 시퀀스

정의

태스크

테스트 케이스

참고

레티 나 , 84 83 79 74 바이트

하스켈, 35 33 바이트

줄리아, 29 바이트

작동 원리

Sesos, 54 바이트

분해

C, 43 42 바이트

Mathematica, 36 바이트

젤리 , 15 14 바이트

작동 원리

젤리 , 14 12 11 바이트

작동 원리

파이썬, 45 40 바이트

하스켈, 39 37 바이트

R, 50 바이트

CJam, 19 18 바이트

C #, 51 44 바이트

자바 스크립트 (ES6), 45 바이트 34 바이트

골프 스크립트, 29 바이트

05AB1E, 29 바이트

APL, 20 바이트

VBA Excel 87 바이트

루비, 36 바이트

Java 7, 68 61 51 bytes

Oasis, 9 7 5 bytes (non-competing)

PowerShell v2+, 85 79 69 bytes

Recursive solution 78 76 bytes

JavaScript (ES6), 66 bytes

Pyth, 16 bytes

Forth, 76 bytes

Maple, 43 41 bytes

J, 29 28 bytes

Usage

Explanation

dc, 62 bytes

Erlang, 46 bytes

Lua, 59 bytes