Định nghĩa

1. a (1) = 1
2. a (2) = 1
3. a (n) = a (na (n-1)) + a (na (n-2)) cho n> 2 trong đó n là số nguyên

Bài tập

Cho số nguyên dương n, tạo a(n).

Tủ thử

n  a(n)
1  1
2  1
3  2
4  3
5  3
6  4
7  5
8  5
9  6
10 6
11 6
12 8
13 8
14 8
15 10
16 9
17 10
18 11
19 11
20 12

Tài liệu tham khảo

• Bắt buộc OEIS A005185

Võng mạc , 84 83 79 74 byte

Số lượng byte giả định mã hóa ISO 8859-1.

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

Hãy thử trực tuyến! (Dòng đầu tiên cho phép bộ kiểm tra được phân tách bằng nguồn cấp.)

Tôi sẽ phải đánh gôn cái này sau.

Haskell, 35 33 byte

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

Xác định một hàm a.

Julia, 29 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Chúng tôi xác định lại toán tử đơn nguyên !cho mục đích của chúng tôi.

Nếu n là 1 hoặc 2 , n<3trả về true và đây là giá trị trả về của chúng tôi.

Nếu n lớn hơn 2 , n<3trả về false và | | nhánh được thực thi. Đây là một cách thực hiện đơn giản của định nghĩa, trong đó ~-nmang lại n - 1 và ~-~-nmang lại n - 2 .

Sesos, 54 byte

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.~.....

Dùng thử trực tuyến

Tháo rời

set numin
set numout
add 1
fwd 1
add 1
fwd 6
get
sub 1
jmp
    jmp
        sub 1
        fwd 1
        add 1
        rwd 1
    jnz
    fwd 1
    sub 1
    rwd 2
    add 2
    jmp
        rwd 4
        jmp
            sub 1
            fwd 3
            add 1
            rwd 3
        jnz
        fwd 4
        jmp
            sub 1
            rwd 3
            add 1
            rwd 1
            add 1
            fwd 4
        jnz
        rwd 3
        jmp
            sub 1
            fwd 3
            add 1
            rwd 3
        jnz
        fwd 4
        add 2
        jmp
            rwd 5
            jmp
                rwd 1
                jmp
                    sub 1
                    fwd 2
                    add 1
                    rwd 2
                jnz
                fwd 1
                jmp
                    sub 1
                    rwd 1
                    add 1
                    fwd 1
                jnz
                rwd 1
                sub 1
            jnz
            fwd 2
            jmp
                sub 1
                rwd 1
                add 1
                rwd 1
                add 1
                fwd 2
            jnz
            fwd 1
            jmp
                rwd 2
                jmp
                    sub 1
                    fwd 1
                    add 1
                    rwd 1
                jnz
                fwd 2
                jmp
                    sub 1
                    rwd 2
                    add 1
                    fwd 2
                jnz
                fwd 1
            jnz
            fwd 3
            sub 1
        jnz
        rwd 2
        jmp
            sub 1
            rwd 3
            add 1
            fwd 3
        jnz
        fwd 1
        sub 1
    jnz
    fwd 2
jnz
rwd 7
put

Hoặc trong ký hiệu Brainfuck:

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

C, 43 42 byte

Đã lưu 1 byte nhờ @Dennis

Mỗi câu trả lời đều giống nhau, tôi phải làm một cái gì đó khác nhau!

Hãy thử trực tuyến!

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

Giải thích: về cơ bản a(n-a(n-2))+a(n-a(n-1))nhưng với hành vi ^{không xác định được} (không hoạt động trên điện thoại của tôi (gcc) và ideone).

Toán học, 36 byte

Số lượng byte giả định mã hóa ISO 8859-1 và Mathicala $CharacterEncodingđược đặt thành WindowsANSI(mặc định trên Windows; các cài đặt khác cũng có thể hoạt động, nhưng một số như UTF-8chắc chắn là không).

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

Xác định ±là một toán tử đơn nguyên.

Tôi đã cố gắng loại bỏ sự trùng lặp, nhưng cuối cùng lại có cùng số byte:

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

Thạch , 15 14 byte

2Rạ⁸߀$⁺Sµ1>?2

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm (mất vài giây).

Làm thế nào nó hoạt động

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.

Thạch , 14 12 11 byte

ịḣ2S;
1Ç⁸¡2ị

Đây là một cách tiếp cận lặp đi lặp lại.

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

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.

Python, 45 40 byte

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

Giải thích đơn giản ngây thơ của thách thức.

Đã lưu 5 byte nhờ @LeakyNun!

Haskell, 39 37 byte

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

chính xác như được mô tả trong thử thách, sử dụng lính canh

R, 50 byte

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

Sử dụng:

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

CJam, 19 18 byte

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

Hãy thử trực tuyến!

Sử dụng phương pháp lặp.

C #, 51 44 byte

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

tôi tự hỏi nếu điều này có thể được rút ngắn bằng cách làm cho nó ẩn danh nhờ Pinkfloydx33!

JavaScript (ES6), 45 byte 34 byte

Một giải pháp đệ quy trong ES6. Bất kỳ lời khuyên chơi golf đánh giá cao nhiều.

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

Cảm ơn bạn / u / ismillo vì đã rút ngắn hơn nữa.

Golf, 29 byte

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

Hãy thử trực tuyến!

05AB1E, 29 byte

Một giải pháp lặp đi lặp lại.

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

Dùng thử trực tuyến

APL, 20 byte

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

Giải trình:

{⍵≤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          

VBA Excel 87 byte

Không đệ quy, vì tôi muốn điều này hoạt động với n = 100000, giả sử:

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

... và nhấn return(byte # 87) ở cuối dòng để nhận End Functioncâu lệnh "miễn phí". Lưu ý rằng giá trị B được bù bằng -1 để tránh khởi tạo cho n = 1 và 2.

Gọi vào bảng tính như bình thường, ví dụ =A(100000)để có được48157

Phiên bản đệ quy, 61 byte ,

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

bắt đầu trở nên chậm một cách vô lý với n> 30 và không thể nói là hoạt động hoàn toàn cho n> 40.

Ruby, 36 byte

Một thực hiện trực tiếp. Bất kỳ đề nghị chơi golf đều được chào đón.

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

Java 7, 68 61 51 byte

17 được cứu nhờ Leaky Nun.

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

Oasis , 9 7 5 byte (không cạnh tranh)

Không cạnh tranh , vì ngôn ngữ hoãn thách thức. Cảm ơn Kenny Lau đã lưu 4 byte. Mã số:

ece+V

Hình thức mở rộng ( Vviết tắt của 11):

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

Mã số:

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

Hãy thử trực tuyến! . Tính n = 1000 trong 0,1 giây.

PowerShell v2 +, 85 79 69 byte

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

Lấy đầu vào $n, đặt $bthành một mảng @(1, 1), sau đó nhập một vòng lặp từ 2 .. $n. Mỗi lần lặp chúng ta $bxử lý phép tính mới nhất trong chuỗi với một +=định nghĩa đơn giản và định nghĩa của chuỗi. Sau đó, chúng tôi xuất số thích hợp từ $b(với một -1vì các mảng trong PowerShell không được lập chỉ mục). Công trình này nếu $nđược 1hoặc 2vì cả hai trong những giá trị được trước được điền vào các chỉ số thấp hơn $btừ khi bắt đầu, vì vậy ngay cả khi đinh vòng lặp trên rác, nó bỏ qua anyway.

Giải pháp đệ quy 78 76 byte

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

Lần đầu tiên tôi đã sử dụng tương đương với lambda làm câu trả lời, vì thông thường, một giải pháp lặp lại ngắn hơn (như bạn có thể thấy từ tất cả các parens lồng nhau). Nhưng, trong trường hợp này, các parens lồng nhau gần như được nhân đôi trong giải pháp lặp với các lệnh gọi mảng lồng nhau, vì vậy giải pháp đệ quy ngắn hơn. Không, giải pháp lặp lại thực sự ngắn hơn (xem ở trên).

Gọi nó thông qua toán tử thực thi, như &$a 20. Chỉ cần một cuộc gọi đệ quy thẳng lên.

JavaScript (ES6), 66 byte

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

Phiên bản không đệ quy cho tốc độ; phiên bản đệ quy có thể ngắn hơn nhưng tôi sẽ để nó cho người khác viết. Tôi luôn thích nó khi tôi sử dụng reduce. Lưu ý: 1 byte được lưu bằng cách trả về true(sẽ chuyển sang 1sử dụng trong ngữ cảnh số nguyên) cho a(1)và a(2).

Bình thường, 16 byte

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

Xác định một hàm y.

Dùng thử trực tuyến (được thêm vào yMS20để in 20 giá trị đầu tiên)

Forth, 76 byte

Tôi cuối cùng cũng hiểu cách nó vận hành!

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

Dùng thử trực tuyến

Giải trình:

: 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 ;

Hãy thử trực tuyến (hơi không chơi golf từ trên cao)

Thật không may, đệ quy lẫn nhau là một chút quá dài để sử dụng cho golf.

Maple, 43 41 byte

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

Sử dụng:

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

Vấn đề này chắc chắn là một ứng cử viên tốt để ghi nhớ. Sử dụng bộ đệm tùy chọn , thời gian chạy được cắt giảm đáng kể:

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

Điều này có thể được nhìn thấy bằng cách sử dụng:

CodeTools:-Usage( aC(50) );

J, 29 28 byte

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

Sử dụng định nghĩa đệ quy.

Sử dụng

Các lệnh bổ sung được sử dụng để định dạng nhiều đầu vào / đầu ra.

   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

Giải trình

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

dc, 62 byte

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

Giải pháp này sử dụng mảng và đệ quy.

?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

Erlang, 46 byte

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

Lua, 59 byte

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