Thử thách

Chúng ta hãy tưởng tượng một Nloạt các số nguyên từ 0 đến Mbao gồm, và hãy gọi nó là số nguyên F.

Có s (M + 1) ** Ncó thể Ftrong tổng số.

Có bao nhiêu Fs như vậy thỏa mãn tất cả các bất đẳng thức sau (chỉ số là một dựa trên)?

• F[n] + F[n+1] <= M cho 1 <= n < N
• F[N] + F[1] <= M

Viết một chương trình hoặc chức năng mà phải mất hai số nguyên dương N và Mvà kết quả đầu ra câu trả lời trong bất kỳ hình thức thuận tiện.

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

(N,M) => Answer

(1,1) => 1
(2,1) => 3
(3,1) => 4
(4,1) => 7

(1,2) => 2
(2,2) => 6
(3,2) => 11
(4,2) => 26

(10,3) => 39175
(10,4) => 286555
(10,5) => 1508401

(25,3) => 303734663372
(25,4) => 43953707972058
(25,5) => 2794276977562073

(100,3) => 8510938110502117856062697655362747468175263710
(100,4) => 3732347514675901732382391725971022481763004479674972370
(100,5) => 60964611448369808046336702581873778457326750953325742021695001

Giải trình

M (max value of element) = 1

F[1] + F[1] <= 1; F = [0]
(1,1) => 1

F[1] + F[2] <= 1; F = [0,0], [0,1], [1,0]
(2,1) => 3

F = [0,0,0], [0,0,1], [0,1,0], [1,0,0]
(3,1) => 4

F = [0,0,0,0], [0,0,0,1], [0,0,1,0], [0,1,0,0], [0,1,0,1], [1,0,0,0], [1,0,1,0]
(4,1) => 7

---

M = 2

F[1] + F[1] <= 2; F = [0], [1]
(1,2) => 2

F = [0,0], [0,1], [0,2], [1,0], [1,1], [2,0]
(2,2) => 6

F = [0,0,0], [0,0,1], [0,0,2], [0,1,0], [0,1,1], [0,2,0], [1,0,0], [1,0,1],
[1,1,0], [1,1,1], [2,0,0]
(3,2) => 11

(4,2) => 26 (left as exercise for you)

Quy tắc

• Đây là một thách thức phức tạp hạn chế . Độ phức tạp thời gian của mã của bạn phải là đa thức MvàN (ví dụ: bạn không thể tạo tất cả các (M + 1) ** Nbộ dữ liệu và sau đó kiểm tra điều kiện). Hãy giải thích cách tiếp cận của bạn trong trình của bạn.
• Luật golf tiêu chuẩn được áp dụng. Câu trả lời ngắn nhất trong byte thắng.

Python với numpy , 59 byte

lambda M,N:trace(mat(tri(M+1)[::-1])**N)
from numpy import*

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

Sử dụng phép nhân ma trận để đếm đường dẫn. Nếu độ chính xác nổi là một vấn đề, matcó thể chỉ định mat(...,int).

Bình thường , 27 byte

.N?Ys:RTtYh-QNgQ+NTs:Rdtszh

Trình diễn

Yêu cầu đầu vào ở định dạng:

M
N

Đây là chương trình động cổ điển, ở phía bên trái của các giá trị được đặt cho đến nay, đầu bên phải và kích thước hiện tại của khoảng cách.

Cách thức hoạt động, trong mã giả / Python:

.N          | define memoized fill(left, right, gap):
?           | if cap > 0 then
s:RTtY      | sum(fill(i, right, gap - 1)
h-QN        |     for i in range(M - left + 1))
gQ+NT       | else M >= left + right
            | output:
s:Rdtsz     | sum(fill(i, i, N - 1)
h           |     for i in range(M + 1))

Qđược sử dụng cho M, zđược sử dụng cho N, :là fill, Nlà left, Tlà right, Ylà gap.

MATL , 13 12 byte

Q:&>~PiY^Xds

Hãy thử trực tuyến! Đây là bản dịch trực tiếp câu trả lời Python của xnor và câu trả lời MATL đầu tiên của tôi, vì vậy rất có thể nó không tối ưu. Ví dụ, có khả năng là một cách ngắn hơn để có được một ma trận tam giác phía trên bên trái hơn t&lYRP. Chỉnh sửa: Và hóa ra là có, cụ thể là :&>~P. Cảm ơn Luis Mendo cho -1 byte!

               M is the first input and N the second
Q:             increment M and generate range from 1 to M+1
  &>           compare vector element wise with itself with greater-than function
               results in a upper-right triangular matrix
    ~          inverse to get lower-left triangular matrix
     P         flip rows to get upper-left triangular matrix
      i        input N
       Y^      take the matrix to the power of N
         Xds   compute the sum of the main diagonal

Stax , 17 byte

°(√&╒íƽ╨⌂'├╖▼1_Z

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

Giải nén, không được chỉnh sửa và nhận xét, nó trông như thế này.

^1](    [1, 0, ... 0] with M zeroes
:)      get all rotations of the array
{       begin block
  {:+rm map each array to reverse(prefixSums(arr))
},v*    execute preceding block N-1 times
F       for each array, execute the rest of the program
  iT    remove the last i elements from the array, where i is the iteration index
  F+    add the remaining elements to the running total
        implicitly print output

Chạy cái này

R , 72 byte

function(M,N)sum(diag(Reduce(`%*%`,rep(list(outer(0:M,0:M,"+")<=M),N))))

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

Cách tiếp cận của cổng xnor.

Thất bại cho các trường hợp thử nghiệm lớn hơn vì R chỉ có hỗ trợ số nguyên 32 bit (chúng được truyền tới doublemột khi đạt được giá trị int tối đa), do đó, cần sử dụng gmphoặc một thư viện số học chính xác tùy ý khác.

Kỳ lạ thay, R thiếu một toán tử công suất ma trận, như ^luôn luôn áp dụng theo nguyên tố.