1, 2, 4, 8, 16, Sọ 33?


24

Thử thách

Viết hàm / chương trình xuất ra nphần tử thứ hoặc nphần tử đầu tiên trong chuỗi số được biết đến:

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

Oh, đợi đã ... Tôi quên vài số đầu tiên:

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

Heck, tôi sẽ thêm một vài biện pháp tốt:

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

Các số này là các số Catalan tổng quát được cho theo công thức (không có chỉ mục):

a(n+1)=a(n)+k=2n1a(k)a(n1k)

Ở đâu

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

Đây là OEIS A004149 .

Bạn có thể chọn nếu bạn muốn có chuỗi số 0 hoặc một chỉ mục. Trình tự tất nhiên phải giống nhau, vì vậy bạn phải viết lại công thức nếu bạn có nó một chỉ mục.


Chỉnh sửa cho tôi nếu tôi sai ở đây, nhưng sửa đổi cho công thức một chỉ mục là thay đổi a(n-1-k)thành a(n-k), đúng không?
Sumner18

9
Điều này làm tôi nhớ đến Định luật mạnh về số lượng nhỏ
Luis Mendo

Câu trả lời:


22

Python , 51 byte

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

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

Đơn giản hóa công thức một chút:

một(n)= =Σk= =2n-1một(k)một(n-2-k)

một(-1)= =một(0)= =một(1)= =một(2)= =1


8
Chúc mừng 100k !!
Stewie Griffin

Vì tôi cũng đã đến giải pháp này một cách độc lập, tôi phải nói rằng con đường hướng tới nó hơi gập ghềnh ...
Erik the Outgolfer

10

Perl 6 , 44 byte

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

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

Khối mã ẩn danh trả về một chuỗi các giá trị vô hạn lười biếng. Điều này thực hiện khá nhiều trình tự như được mô tả, với phím tắt mà nó nén nhân tất cả các phần tử cho đến sau phần tử thứ hai với phần ngược lại của danh sách bắt đầu từ phần tử thứ tư và thêm phần phụ 1ở cuối.

Giải trình:

{                                          }  # 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

10

05AB1E , 14 13 11 byte

$ƒˆ¯Âø¨¨¨PO

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

Xuất ra phần tử thứ n, được lập chỉ mục 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


7

Haskell, 49 43 39 byte

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

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

Đối với n<3các sumlà 0, do đó max ... 1làm tăng nó 1.

Chỉnh sửa: -6 byte nhờ @Jo King.



6

05AB1E , 17 13 byte

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

Không ngắn hơn câu trả lời 05AB1E hiện có , nhưng tôi muốn thử chức năng đệ quy của phiên bản 05AB1E mới để thực hành cho chính mình. Có lẽ có thể bị đánh gôn bởi một vài byte. EDIT: Và nó thực sự có thể, vui lòng xem phiên bản đệ quy của @Grimy 's 05AB1E câu trả lời dưới đây, đó là 13 byte .

n

n£è
£

Giải trình:


một(n)= =một(n-1)+Σk= =2n-1(một(k)một(n-1-k))

một(0)= =một(1)= =một(2)= =một(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)

Phiên bản 13 byte của @Grimy (đảm bảo nâng cao câu trả lời của anh ấy nếu bạn chưa có!):

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

n


1λèλ1šÂ¨¨¨øPO
λλ1šÂ¨¨¨øPOmột(0)= =1

Giải trình:


một(n)= =Σk= =2n-1(một(k)một(n-2-k))

một(-1)= =một(0)= =một(1)= =một(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)

1
Điều thú vị là điều này có thể giải quyết (1200) trong 40 giây trên tio, trong khi các cách tiếp cận đệ quy khác hết thời gian cho số n hơn 100 ...
Stewie Griffin

1
Tôi cũng đã tạo (nhưng không xuất bản) một phiên bản đệ quy. Đó là 13 byte cho n thuật ngữ đầu tiên hoặc 11 byte cho danh sách vô hạn . Vỏ đặc biệt a (n-1) tốn rất nhiều byte và không cần thiết (xem ví dụ công thức của xnor ).
Grimmy

@Grimy Bạn có phiền nếu tôi thêm các giải pháp đệ quy của bạn vào câu trả lời của tôi (tất nhiên là ghi có cho bạn) không? Tôi sẽ để lại câu trả lời ban đầu của tôi là tốt. Nhưng thật tuyệt khi thấy sự khác biệt giữa công thức gốc và công thức tiết kiệm byte của xnor. :)
Kevin Cruijssen

1
Chắc chắn, điều đó tốt!
Grimmy

@StewieGriffin Vâng, tôi cũng bị ấn tượng bởi tốc độ của các hàm vô hạn đệ quy này. Có lẽ một trong những thế mạnh của Elixir, và chắc chắn là do tải lười biếng tích hợp. Nó tính toán n=100trong 0,65 giây , nhưng khi tôi tắt tính năng tải nhanh, nó sẽ hết thời gian sau 60 giây, thậm chí là chon=25 .
Kevin Cruijssen





2

Japt , 19 17 16 byte

Xuất ra nthuật ngữ thứ, 1 chỉ mục.

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

Thử nó

@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

1

Haskell , 65 byte

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

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

Bạn có thể sử dụng hoặc fđể lấy một phần tử của chuỗi hoặc chuyển danh sách các giá trị đến gvà lấy tất cả các chỉ mục cho danh sách đó.


1

Forth (gforth) , 99 81 byte

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

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

Đầu ra là thuật ngữ thứ n và đầu vào là 1 chỉ mục

Chỉnh sửa: Đã lưu 17 byte bằng cách chuyển sang công thức của xnor. Đã lưu thêm 1 byte bằng cách sử dụng 1 chỉ mục

Giải thích mã

: 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

1

Than , 26 byte

F⁵⊞υ¹FN⊞υΣ✂E⮌υ×κ§υλ³→I§υ±⁴

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. In số thứ n được lập chỉ mục 0, mặc dù nó tính toán bằng cách sử dụng chỉ mục 1 trong nội bộ. Giải trình:

F⁵⊞υ¹

Bắt đầu với a[0] = a[1] = a[2] = a[3] = a[4] = 1. Có, đây là 1 chỉ mục, nhưng sau đó có thêm giá trị zeroth. Đó là mã golf cho bạn.

FN

Tính một nđiều khoản bổ sung . Điều này là quá mức cần thiết, nhưng nó làm cho việc tìm kiếm thuật ngữ mong muốn dễ dàng hơn khi n<5.

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

Đối với mỗi thuật ngữ, hãy tính thuật ngữ tiếp theo là tổng của các điều khoản cho đến nay nhân với số lần đảo ngược của các điều khoản cho đến nay, không bao gồm ba thuật ngữ.

Đây là một no-op được sử dụng để lừa Char than phân tích dạng 2 đối số Slice, nếu không tôi sẽ phải sử dụng một cách ít chơi golf hơn để loại bỏ ba thuật ngữ.

I§υ±⁴

Đầu ra nhiệm kỳ thứ 4 cuối cùng.


1

Bình thường , 30 byte

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

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

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



1

Octave , 73 byte

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

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

-2 byte nhờ Stewie Griffin. Một lần nữa, cách tiếp cận bắt buộc chiến thắng trong cách tiếp cận đệ quy chức năng. Đó là một trong những dưới đây.

Octave , 75 byte

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

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

Captcha muốn xác minh tôi là một con người khi đăng bài này. Thành thật mà nói, tôi không chắc lắm .


Tôi không thể thấy bất kỳ cách rõ ràng nào để rút ngắn cách tiếp cận vòng lặp ... Có vẻ như chơi golf khá tốt! Ngoài ra, không thường xuyên tôi thấy lập chỉ mục dựa trên zero trong Octave :)
Stewie Griffin

@StewieGriffin Vì đệ quy có một số điểm bù, nên bạn không thực sự quan trọng nếu bạn chọn zero- hoặc một chỉ mục. Tôi nghĩ có lẽ tôi có thể cạo một số byte nếu tôi đã lập chỉ mục 2, nhưng điều đó có vẻ như gian lận. Dù sao, trực giác của bạn đã đúng - bằng cách nào đó, điều này thực sự ngắn hơn theo cách đệ quy ẩn danh. Tôi nghĩ ưu điểm chính là nó xử lý tốt việc tạo ra bốn giá trị ban đầu vì nó chỉ trả về 1 cho n<4.
Sanchises

1
@StewieGriffin Tất nhiên, nhân ma trận cũ tốt. Làm tốt!
Sanchise


0

C / C ++ , 70 69 67 byte

-1 byte nhờ Jonathan.

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

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


Có thể a(n-1-k)được a(n+~k)không?
Jonathan Frech

@JonathanFrech thậm chí a(++k)*a(n-k)có khả năng hoạt động và nó giảm thêm 2 byte từ đó for. Nhưng tôi ngửi thấy hành vi không xác định.
polfosol _ఠ

Đó dường như là một vấn đề tuần tự; chắc chắn nhất là UB.
Jonathan Frech
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.