Tam giác Seidel là một công trình toán học tương tự như Tam giác Pascal và được biết đến với sự kết nối với các số Bernoulli.

Một vài hàng đầu tiên là:

      1
      1  1
   2  2  1
   2  4  5  5
16 16 14 10 5
16 32 46 56 61 61

Mỗi hàng được tạo như sau:

Nếu số hàng là chẵn (1 chỉ mục):

• Đưa xuống mục đầu tiên của hàng trước

• Mỗi mục tiếp theo là tổng của mục trước và mục bên trên

• Nhân đôi mục cuối cùng

Nếu số hàng là số lẻ:

• Đưa xuống mục cuối cùng của hàng trước

• Đi ngược lại , mỗi mục là tổng của mục trước và mục bên trên

• Nhân đôi những gì bây giờ là mục đầu tiên.

Về cơ bản, chúng tôi xây dựng hình tam giác theo mô hình zig-zag:

    1
    v
    1 > 1
        v
2 < 2 < 1
v
2 > 4 > 5 > 5

Để biết thêm thông tin, xem trang Wikipedia về số Bernoulli.

Các thách thức:

Được cung cấp ndưới dạng đối số hàm hoặc từ STDIN, in hoặc trả về nhàng thứ ba của tam giác Seidel hoặc các nhàng đầu tiên . Bạn có thể sử dụng lập chỉ mục 0 hoặc 1.

Bạn không cần xử lý đầu vào âm hoặc không nguyên (cũng không phải 0, nếu 1 chỉ mục). Bạn không phải xử lý đầu ra lớn hơn2147483647 = 2^31 - 1

Vì đây là mã golf, hãy thực hiện điều này trong càng ít byte càng tốt.

Ví dụ:

Trong các ví dụ này, giá trị trả về là nhàng thứ 0, được lập chỉ mục 0.

Input   ->  Output

0           1
1           1 1
2           2 2 1
6           272 272 256 224 178 122 61
13          22368256 44736512 66750976 88057856 108311296 127181312 144361456 159575936 172585936 183194912 191252686 196658216 199360981 199360981

Brain-Flak , 66 byte

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

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

Hàng là 0 chỉ mục.

# Push 1 (the contents of row 0) on other stack; use implicit zero as parity of current row
<>(())<>

# Do a number of times equal to input:
{({}[()]<

  # Subtract the row parity from 1
  (()[{}]<

    # For each entry in old row:
    <>{

      # Add to previous entry in new row and push twice
      (({}<>{}))<>

    }

  >)

>)}{}

# If row parity is odd:
{{}

  # Reverse stack for output
  <>{({}<>)<>}

# Switch stacks for output
}<>

JavaScript (SpiderMonkey) , 67 byte

Mã này lạm dụng sort()phương thức và không hoạt động trên tất cả các công cụ.

Các hàng được lập chỉ mục 0.

f=(n,a=[1],r)=>n--?f(n,[...a.map(n=>k+=n,k=0),k].sort(_=>n|r),!r):a

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

Làm sao?

Chúng tôi có điều kiện đảo ngược một mảng bằng cách sử dụng sort()phương thức với hàm gọi lại mà bỏ qua các tham số của nó và trả về 0 hoặc một số nguyên dương. Đừng thử điều này ở nhà! Điều này chỉ hoạt động đáng tin cậy trên SpiderMonkey.

let A = [1,2,3,4,5] and B = [1,2,3,4,5,6,7,8,9,10,11]

             | SpiderMonkey (Firefox)  | V8 (Chrome)             | Chakra (Edge)
-------------+-------------------------+-------------------------+------------------------
A.sort(_=>0) | 1,2,3,4,5               | 1,2,3,4,5               | 1,2,3,4,5
A.sort(_=>1) | 5,4,3,2,1               | 5,4,3,2,1               | 1,2,3,4,5
B.sort(_=>0) | 1,2,3,4,5,6,7,8,9,10,11 | 6,1,3,4,5,2,7,8,9,10,11 | 1,2,3,4,5,6,7,8,9,10,11
B.sort(_=>1) | 11,10,9,8,7,6,5,4,3,2,1 | 6,11,1,10,9,8,7,2,5,4,3 | 1,2,3,4,5,6,7,8,9,10,11

Lưu ý rằng V8 có thể đang sử dụng các thuật toán sắp xếp khác nhau tùy thuộc vào độ dài của mảng (ít hơn hoặc hơn 10 phần tử).

Đã bình luận

f = (                     // f = recursive function taking:
  n,                      //   n   = row counter
  a = [1],                //   a[] = current row, initialized to [1]
  r                       //   r   = 'reverse' flag, initially undefined
) =>                      //
  n-- ?                   // decrement n; if it was not equal to zero:
    f(                    //   do a recursive call with:
      n,                  //     - the updated value of n
      [ ...a.map(n =>     //     - a new array:
          k += n, k = 0   //       - made of the cumulative sum of a[]
        ), k              //         with the last value appended twice
      ].sort(_ => n | r), //       - reversed if n is not equal to 0 or r is set
      !r                  //     - the updated flag r
    )                     //   end of recursive call
  :                       // else:
    a                     //   stop recursion and return a[]

Perl 6 , 52 byte

{(1,{[[\+] |.reverse,0]}...*)[$_].sort((-1)**$_*-*)}

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

Haskell , 89 87 82 byte

(cycle[r,id]!!)<*>s
r=reverse
s 0=[1]
s n=let a=zipWith(+)(0:a)$(r.s$n-1)++[0]in a

Chỉ cần sin các dòng theo thứ tự zig-zag, hàm ẩn danh trên hàng đầu tiên đảo ngược một nửa số hàng.

Cảm ơn @nimi vì đã tiết kiệm 5 byte!

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

Thạch , 12 byte

1;0SƤUƊ⁸¡U⁸¡

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

Python 3 , 98 91 byte

from itertools import*
f=lambda n:n and[*accumulate(f(n-1)[::n&1or-1]+[0])][::n&1or-1]or[1]

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

Chuyển sang đánh số hàng dựa trên 0 đã lưu 7 byte.

Julia 0,6 , 85 byte

r(l,n=cumsum(l))=[n...,n[end]]
w=reverse
f(n)=n<2?[1]:n%2<1?r(f(n-1)):w(r(w(f(n-1))))

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

Đây là một giải pháp đệ quy trong Julia. Lưu ý rằng nó có lập chỉ mục 1 dựa trên. Do đó các bài kiểm tra.

Phiên bản Ungolfed, để hiểu logic:

function new_row(last_row)
    new_row = cumsum(last_row)
    push!(new_row, new_row[end])
    return new_row
end


function triangle(n)
    if n == 1
        return [1]
    elseif mod(n,2) == 0
        return new_row(triangle(n-1))
    else
        return reverse(new_row(reverse(triangle(n-1))))
    end
end

Phần thưởng Asa, đây là phiên bản không đệ quy, nhưng phần này dài hơn:

w=reverse;c=cumsum
r(l,i)=i%2<1?c([l...,0]):w(c(w([0,l...])))
f(n,l=[1])=(for i=2:n l=r(l,i)end;l)

Python 2 , 103 97 byte

f=lambda n,r=[1],k=2:n and f(n-1,[sum(r[-2::-1][:i],r[-1])for i in range(k)],k+1)or r[::-(-1)**k]

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

Phiên bản không đệ quy (dễ đọc hơn):

Python 2 , 106 byte

def f(n,r=[1],j=1):
 while n:
	a=r[-2::-1];r=r[-1:];n-=1;j=-j
	for x in a+[0]:r+=[r[-1]+x]
 return r[::-j]

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

Chắc chắn, tốt hơn là có thể!

Python 3 , 91 byte

from numpy import *
s=lambda n:n and cumsum(s(n-1)[::n%2*2-1]+[0]).tolist()[::n%2*2-1]or[1]

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