Số Motzkin thứ n là số đường dẫn từ (0, 0) đến (n, 0) trong đó mỗi bước có dạng (1, -1), (1, 0) hoặc (1, 1) và đường dẫn không bao giờ đi dưới y = 0.

Đây là một minh họa về các đường dẫn này cho n = 1, 2, 3, 4, từ liên kết trên:

Trình tự mong muốn là OEIS A001006 . OEIS có một số đặc điểm khác của chuỗi.

Bạn sẽ được cung cấp một số nguyên dương n làm đầu vào. Bạn nên xuất số Motzkin thứ n.

Dưới đây là số Motzkin từ 1 đến 10:

1, 2, 4, 9, 21, 51, 127, 323, 835, 2188

Tất cả các phương pháp đầu vào và đầu ra tiêu chuẩn được cho phép. Tiêu chuẩn áp dụng.

Đây là mã golf. Ít byte nhất sẽ thắng.

MATL , 13 14 byte

i-2/t.5+hH4Zh

Thí dụ:

>> matl i-2/t.5+hH4Zh
> 6
51

EDIT (ngày 16 tháng 6 năm 2017): bạn có thể dùng thử trực tuyến! Cũng lưu ý rằng trong các phiên bản hiện đại của ngôn ngữ (sau ngày thử thách này), icó thể bị xóa.

Giải trình

Khá đơn giản, sử dụng tương đương (xem phương trình (10)) với hàm siêu bội :

Từ định nghĩa của hàm siêu bội

rõ ràng là thứ tự của hai đối số đầu tiên có thể được hoán đổi cho nhau, giúp tiết kiệm một byte.

i         % input                                                   
-2/       % divide by -2
t.5+      % duplicate and add 0.5
h         % horizontal concatenation into a vector                               
H         % number 2
4         % number literal                                          
Zh        % hypergeometric function with three inputs (first input is a vector)

Võng mạc , 59 58 byte

+`(\D*)1(1*)
:$1<$2:$1>$2:$1_$2:
:(_|()<|(?<-2>)>)+:(?!\2)

Đưa đầu vào trong unary . Đầu vào 7 (nghĩa là 1111111) mất khá nhiều thời gian nhưng vẫn hoàn thành trong chưa đầy một phút. Tôi sẽ không đi xa hơn thế.

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

Giải trình

Một đặc điểm khác nhau của các số Motzkin là số chuỗi gồm ba ký tự khác nhau, trong đó hai trong số chúng được cân bằng chính xác (do đó có mối quan hệ chặt chẽ với các số Catalan, giống nhau mà không có ký tự thứ ba độc lập với số dư).

Nhóm cân bằng NET của khá giỏi trong việc phát hiện chuỗi xuất hiện một cách chính xác, vì vậy chúng tôi chỉ đơn giản là tạo ra tất cả các chuỗi có độ dài N(sử dụng _, <và >vai ba nhân vật) và sau đó chúng tôi đếm có bao nhiêu những được cân bằng một cách chính xác. Ví dụ: N = 4các chuỗi hợp lệ là:

____
__<>
_<_>
_<>_
<__>
<_>_
<>__
<<>>
<><>

So với định nghĩa trong thử thách, _tương ứng với một (1,0)bước, <đến (1,1)và >đi (1,-1).

Đối với mã thực tế, mã :được sử dụng như một dấu phân cách giữa các chuỗi khác nhau. Regex thứ hai chỉ là một hình thức chơi golf của regex .NET tiêu chuẩn cho các chuỗi cân bằng .

Một điều cần lưu ý là chỉ có một :chuỗi được chèn giữa các chuỗi trong mỗi bước, nhưng biểu thức chính thứ hai khớp với một đầu và một dấu :(và vì các kết quả khớp không thể trùng nhau, điều này có nghĩa là các chuỗi liền kề được tạo từ một mẫu trong bước cuối cùng không thể khớp với nhau ). Tuy nhiên, đây không phải là một vấn đề, bởi vì nhiều nhất một trong ba điều đó có thể khớp với nhau:

• Nếu chuỗi kết thúc trùng _khớp, tiền tố không có đó _đã được cân bằng chính xác và <hoặc >sẽ loại bỏ số dư đó.
• Nếu chuỗi kết thúc trùng >khớp, chuỗi được cân bằng với điều đó >, do đó _hoặc <sẽ loại bỏ sự cân bằng đó.
• Chuỗi kết thúc trong <không bao giờ có thể được cân bằng.

Python 2, 51 byte

M=lambda n:n<1or sum(M(k)*M(n-2-k)for k in range(n))

Sử dụng công thức từ Mathworld

Tiết kiệm chars bằng cách đặt các M[n-1]hạn vào tổng như k=n-1, mang đến cho M[-1]*M[n-1], với M[-1]=1như một phần của điều kiện ban đầu.

Chỉnh sửa: Một char viết ngắn hơn tổng số đệ quy:

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

Các cách tiếp cận khác hóa ra lâu hơn:

M=lambda n,i=0:n and(i>0)*M(n-1,i-1)+M(n-1,i)+M(n-1,i+1)or i==0
M=lambda n:+(n<2)or(3*~-n*M(n-2)+(n-~n)*M(n-1))/(n+2)

Bình thường, 15 byte

Ls*V+KyMb1+t_K1

Điều này xác định một chức năng y. Dùng thử trực tuyến: Trình diễn

Giải trình:

Hãy y[n]là số nMotzkin thứ. Tôi tính y[n]theo công thức

y[n] = dot product of (y[0], ..., y[n-1], 1) and (y[n-2], ..., y[0], 1)

Lưu ý rằng vectơ thứ nhất lớn hơn vectơ thứ hai (trừ khi tính toán y[0]). Khi đây là trường hợp, hơn Pyth sẽ tự động bỏ qua 1 ở cuối vectơ đầu tiên, để cả hai vectơ có độ dài bằng nhau.

Ls*V+KyMb1+t_K1
L                 define a function y(b), which returns:
      yMb            compute the list [y[0], y[1], ..., y[b-1]]
     K               assign it to K
  *V                 vectorized multiplication of
    +K   1             * K with a 1 at the end
          +t_K1        * reverse(K), remove the first element, and append 1
 s                   return the sum (dot product)

Công thức này là một biến thể của một trong những công thức được liệt kê trên OEIS. Nó có thể là một chút ngu ngốc. Do 1 ở cuối vectơ đầu tiên (làm cho độ dài không bằng nhau), tôi thực sự không phải đưa ra đệ quy một trường hợp cơ bản. Và tôi đã có hy vọng, rằng hai +...1s có thể được chơi golf bằng cách nào đó. Hóa ra tôi không thể.

Bạn có thể định nghĩa một đệ quy tương tự với một sản phẩm chấm có vectơ có độ dài bằng nhau và xác định trường hợp cơ sở y[0] = 1có cùng số byte.

CJam (20 byte)

.5X]{__W%.*:++}qi*W=

Bản demo trực tuyến

Như Mego đã lưu ý trong các nhận xét về câu hỏi, điều này liên quan rất chặt chẽ với các số Catalan: thay đổi .5thành 1và bù chỉ số bằng một (hoặc đơn giản là loại bỏ .5hoàn toàn và giữ nguyên chỉ số) để lấy số Catalan.

Sự tái phát được sử dụng là

a (n + 2) - a (n + 1) = a (0) * a (n) + a (1) * a (n-1) + ... + a (n) * a (0). [Bernhart]

từ trang OEIS. Sự tái phát tương ứng cho các số Catalan được liệt kê là

a (n) = Sum_ {k = 0..n - 1} a (k) a (n - 1 - k).

Nghiêm túc, 21 byte

,;╗r`;τ╜█@;u@τ╣║\*`MΣ

Mượn một số mã từ giải pháp Số Catalan của quintopia , cụ thể là sự cải tiến tôi đã thực hiện trong các nhận xét.

Tôi sử dụng công thức sau:

Vì nCklà 0 k > n, tôi tổng hợp tất cả các cách n-1, vì tất cả các giá trị đó sẽ là 0 và do đó không ảnh hưởng đến tổng.

Dùng thử trực tuyến

Giải trình:

,;╗r`;τ╜█@;u@τ╣║\*`MΣ
,;╗                    push input, dupe, store one copy in register 0
   r                   push range(0, n) ([0,n-1])
    `             `M   map the function:
     ;τ╜█@               dupe k, push C(n, 2*k), swap with k
          ;u@τ╣║\        push the kth Catalan number
                 *       multiply
                    Σ  sum

R, 64 byte

f=function(n)ifelse(n<2,1,f(n-1)+sum(rev(s<-sapply(2:n-2,f))*s))

Cũng sử dụng công thức Mathworld của câu trả lời python của @ xnor . Nhờ các quy tắc ưu tiên, 2:n-2tương đương với 0:(n-2).

Các trường hợp thử nghiệm:

> f(0)
[1] 1
> f(1)
[1] 1
> f(5)
[1] 21
> f(10)
[1] 2188
> sapply(0:20,f)
 [1]        1        1        2        4        9       21       51      127
 [9]      323      835     2188     5798    15511    41835   113634   310572
[17]   853467  2356779  6536382 18199284 50852019

Toán học, 31 30 byte

AppellF1[-#/2,.5,-#/2,2,4,4]&

Để giải trí, đây là phiên bản 37 byte

Hypergeometric2F1[(1-#)/2,-#/2,2,4]&

và phiên bản 52 byte

SeriesCoefficient[1-x-Sqrt[1-2x-3x^2],{x,0,#+2}]/2&

Thạch , 17 14 13 byte

×US;
1;HÇƓ¡1ị

Điều này sử dụng mối quan hệ lặp lại từ câu trả lời của @ PeterTaylor . Hãy thử trực tuyến!

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

×US;      Define a helper link. Left argument: a (list)

×U        Multiply (×) a by its reverse (U).
  S       Compute the sum of the resulting list.
   ;      Prepend it to a.
          Return the result.

1;HÇƓ¡1ị  Define the main link.

1         Set the left argument to 1.
 ;H       Append the half of 1 to 1. Result: [1, 0.5].
    Ɠ     Read an integer n from STDIN.
   Ç ¡    Call the helper link (Ç) n times.
      1ị  Retrieve the result at index 1.

Toán học, 44 42 34 byte

Sum[#!/(i!(i+1)!(#-2i)!),{i,0,#}]&

Phiên bản 35 byte:

Coefficient[(1+x+1/x)^#,x]/#&[#+1]&

Pari / GP , 38 36 26 byte

n->(1+x+x^2)^n++/n\x^n++%x

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

Sử dụng phương trình (11) từ MathWorld :

$M_n = \dfrac{1}{n + 1} \dbinom{n + 1}{1}_2$

$\binom{n}{k}_2$$\binom{n}{k}_2$$x^{n + k}$$(1 + x + x^2)^n$

05AB1E , 13 12 byte

ÝI<ãʒ.øDŸQ}g

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

Trong khi hầu hết các câu trả lời sử dụng một công thức hoặc quan hệ lặp lại, đây là một cách tiếp cận đếm đơn giản.

Mỗi đường dẫn có thể đi qua lưới được biểu diễn bằng danh sách tọa độ y của nó. Đối với n phân đoạn, có tổng số (n + 1) điểm, nhưng điểm đầu tiên và điểm cuối cùng nhất thiết phải là 0, do đó, để lại (n-1) điểm để chỉ định.

Ý           # range [0..n]
 I<         # n - 1
   ã        # cartesian power

Bây giờ chúng ta có một danh sách các đường dẫn (chưa bao gồm 0 ban đầu và 0 cuối cùng). Bằng cách xây dựng, không ai trong số họ từng xuống dưới 0. Tuy nhiên, một số trong số họ có độ dốc bất hợp pháp (ví dụ: nhảy từ 0 đến 2), vì vậy chúng tôi cần lọc chúng ra.

ʒ      }g   # count how many paths satistfy the following condition
 0.ø        # surround with 0
      Q     # is equal to
    DŸ      # its own fluctuating range

Ÿlà phạm vi dao động tích hợp. Nếu có bất kỳ cặp số không liền kề nào, nó sẽ điền vào các số còn thiếu (ví dụ [0, 2] trở thành [0, 1, 2]). Chỉ có đường dẫn hợp pháp sẽ được giữ nguyên.

Một cách có lẽ trực quan hơn để kiểm tra độ dốc bất hợp pháp sẽ là üαà(khẳng định mức tối đa của sự khác biệt tuyệt đối theo cặp bằng 1). Tuy nhiên, điều này bỏ lỡ đường dẫn [0, 0, ... 0] phẳng, tốn thêm một byte để sửa.

Cuối cùng, lưu ý rằng mã thực tế sử dụng .ønơi giải thích này sử dụng 0.ø. Thay vì bao quanh đường dẫn bằng 0, điều này bao quanh đầu vào ẩn với hai bản sao của đường dẫn. Điều này biến hệ thống tọa độ lộn ngược và từ trong ra ngoài, nhưng nếu không thì tương đương.

Stax , 12 byte

îu¬@Y≤ÅÉÑ(πε

Chạy và gỡ lỗi nó

Tôi không biết làm thế nào để sắp chữ toán học, nhưng điều này chủ yếu dựa vào một cấu trúc lập trình động

M(0) = 1
M(1) = 1
M(n + 1) = M(n) + sum(M(k) * M(n - k - 1) for k in [0..n-1])

Hồng ngọc, 50

thực hiện đơn giản các mối quan hệ tái phát.

g=->n{n<2?1:(3*(n-1)*g[n-2]+(2*n+1)*g[n-1])/(n+2)}

Brain-Flak , 90 byte

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

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

${\binom{n}{0}}_2 - {\binom{n}{2}}_2$$\binom{n}{k}_2$$C_n = \binom{2n}{n} - \binom{2n}{n+1}$

ES6, 44 byte

f=(n,k=0)=>n<1?1:k<n&&f(k)*f(n-2-k)+f(n,k+1)

Cổng đơn giản của giải pháp Python đệ quy của @ xnor. Cần n<1?1:bởi vì n<1||sẽ làm cho f(0)trở lại true.

Haskell , 55 byte

Thực hiện đơn giản các đệ quy.

a n|n>2=((2*n+1)*a(n-1)+(3*n-3)*a(n-2))`div`(n+2)
a n=n

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