Seidel Triangle은 Pascal의 Triangle과 유사한 수학적 구조이며 Bernoulli 수와 관련이있는 것으로 알려져 있습니다.

처음 몇 행은 다음과 같습니다.

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

각 행은 다음과 같이 생성됩니다.

행 번호가 짝수 (1 색인) 인 경우 :

• 이전 행의 첫 번째 항목을 내립니다.

• 다음 모든 항목은 이전 항목과 그 위에있는 항목의 합계입니다.

• 마지막 항목 복제

행 번호가 홀수 인 경우 :

• 이전 행의 마지막 항목을 내립니다.

• 뒤로 가면 각 항목은 이전 항목과 그 위에있는 항목의 합계입니다.

• 이제 첫 번째 항목이 무엇인지 복제하십시오.

기본적으로 지그재그 패턴으로 삼각형을 구성합니다.

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

자세한 내용 은 Bernoulli 번호 의 Wikipedia 페이지 를 참조하십시오 .

도전 과제 :

n함수 인수로 또는 STDIN에서 주어진 경우 , nSeidel 삼각형 의 세 번째 행 또는 첫 번째 행을 인쇄하거나 리턴 하십시오.n 행. 0 또는 1 인덱싱을 사용할 수 있습니다.

음수 또는 정수가 아닌 입력을 처리 할 필요가 없습니다 (1 인덱싱 된 경우 0). 보다 큰 출력을 처리 할 필요가 없습니다.2147483647 = 2^31 - 1

이것이 코드 골프이므로 가능한 한 적은 바이 트로이 작업을 수행하십시오.

예 :

이 예제에서 리턴 값은 n0 색인 된 세 번째 행입니다.

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 바이트

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

온라인으로 사용해보십시오!

행은 0 색인화됩니다.

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

자바 스크립트 (SpiderMonkey) , 67 바이트

이 코드는 sort()메소드를 남용하고 모든 엔진에서 작동하지는 않습니다.

행은 0 색인화됩니다.

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

온라인으로 사용해보십시오!

어떻게?

sort()매개 변수를 무시하고 0 또는 양의 정수를 리턴하는 콜백 함수와 함께 메소드를 사용하여 조건부로 배열을 반전 시킵니다. 집에서 이것을 시도하지 마십시오! 이것은 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

V8은 아마도 배열의 길이 (10 개 이하의 요소)에 따라 다른 정렬 알고리즘을 사용하고있을 것입니다.

댓글

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[]

펄 6 , 52 바이트

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

온라인으로 사용해보십시오!

하스켈 , 89 87 82 바이트

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

다만 s지그재그 순서로 행을 인쇄하기 첫 번째 행의 익명 함수는 행의 절반을 뒤집습니다.

5 바이트를 절약 한 @nimi에게 감사합니다!

온라인으로 사용해보십시오!

젤리 , 12 바이트

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

온라인으로 사용해보십시오!

파이썬 3 , 98 91 바이트

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

온라인으로 사용해보십시오!

0부터 시작하는 행 번호 매기기로 전환하면 7 바이트가 절약되었습니다.

Julia 0.6 , 85 바이트

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))))

온라인으로 사용해보십시오!

이것은 Julia의 재귀 솔루션입니다. 1 기반 인덱싱이 있습니다. 따라서 테스트.

논리를 이해하기위한 ungolfed 버전 :

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

Asa 보너스는 비 재귀 버전이지만 더 길다.

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)

파이썬 2 , 103 97 바이트

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]

온라인으로 사용해보십시오!

비 재귀 버전 (읽기 쉬움) :

파이썬 2 , 106 바이트

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]

온라인으로 사용해보십시오!

확실히 더 나은 것이 가능합니다!

파이썬 3 , 91 바이트

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

온라인으로 사용해보십시오!