파스칼의 삼각형 (정렬)


24

여기에있는 대부분의 사람들은 파스칼의 트라이앵글에 익숙합니다. 연속적인 행으로 구성되며 각 요소는 왼쪽 상단과 오른쪽 상단의 두 이웃의 합입니다. 첫 번째 5행은 Generate Pascal의 triangle 에서 차용 한 것입니다 .

    1
   1 1
  1 2 1
 1 3 3 1
1 4 6 4 1
  . . .

이 행을 왼쪽으로 축소

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
. . .

오름차순으로 정렬

1
1 1
1 1 2
1 1 3 3
1 1 4 4 6
. . .

이 삼각형을 행별로 읽으십시오

[1, 1, 1, 1, 1, 2, 1, 1, 3, 3, 1, 1, 4, 4, 6 ...]

입력이 주어지면 이 시리즈의 숫자를 n출력하십시오 n. 이다 OEIS 107430 .

규칙

  • 0 또는 1 기반 인덱싱을 선택할 수 있습니다. 제출 한 내용을 기재하십시오.
  • 입력 및 출력은 언어의 기본 정수 유형에 맞는 것으로 가정 할 수 있습니다.
  • 입력 및 출력은 편리한 방법 으로 제공 할 수 있습니다 .
  • 전체 프로그램 또는 기능이 허용됩니다. 함수 인 경우 출력하지 않고 출력을 반환 할 수 있습니다.
  • 표준 허점 은 금지되어 있습니다.
  • 이것은 이므로 모든 일반적인 골프 규칙이 적용되며 가장 짧은 코드 (바이트)가 이깁니다.

6
아주 좋은 제목!
Luis Mendo

1
OEIS 링크에 따라 이항 계수 대신이 시퀀스를 생성하는 데 필요한 유일한 변경은 정수 나누기입니다. 그것은 확실히 "사소한"에 해당합니다.
피터 테일러

5
@PeterTaylor 이것은 나에게 명백한 속임수처럼 보이지 않습니다. 특히 이항식이 내장되지 않은 언어의 경우 흥미로운 골프 기회로 이어질 수있는 다른 많은 방법이 있습니다.
Arnauld

4
@PeterTaylor 나는 이것이 복제본이라고 확신하지 못한다. 지금까지 MATL, JavaScript 및 Pascal 답변은 두 가지 과제에서 다소 다릅니다. 그러나 내 투표는 망치로 열리므로 아직 투표하지 않습니다.
AdmBorkBork

4
@AdmBorkBork에 전적으로 동의합니다. 다시 열기 투표로 계산하십시오. 이제 3이됩니다. 다시 열려면 몇 표가 필요합니까?
Luis Mendo

답변:


9

자바 스크립트 (ES6), 79 바이트

인덱스가 0입니다.

f=(n,a=[L=1])=>a[n]||f(n-L,[...a.map((v,i)=>k=(x=v)+~~a[i-1-i%2]),L++&1?k:2*x])

데모

방법?

f = (                       // f = recursive function taking:
  n,                        //   n = target index
  a = [L = 1]               //   a[] = current row, L = length of current row
) =>                        //
  a[n] ||                   // if a[n] exists, stop recursion and return it
  f(                        // otherwise, do a recursive call to f() with:
    n - L,                  //   n minus the length of the current row
    [                       //   an array consisting of:
      ...a.map((v, i) =>    //     replace each entry v at position i in a[] with:
        k =                 //       a new entry k defined as:
        (x = v) +           //       v +
        ~~a[i - 1 - i % 2]  //       either the last or penultimate entry
      ),                    //     end of map()
      L++ & 1 ?             //     increment L; if L was odd:
        k                   //       append the last updated entry
      :                     //     else:
        2 * x               //       append twice the last original entry
    ]                       //   end of array update
  )                         // end of recursive call

이 알고리즘은 파스칼 삼각형의 정렬 된 행을 직접 생성합니다. a [n] 이 존재할 때까지 이전 행의 길이에 따라 n을 업데이트 합니다. 예를 들어, n = 19에 6 회 반복이 필요합니다 .

 L | n  | a[]
---+----+------------------------
 1 | 19 | [ 1 ]
 2 | 18 | [ 1, 1 ]
 3 | 16 | [ 1, 1, 2 ]
 4 | 13 | [ 1, 1, 3, 3 ]
 5 |  9 | [ 1, 1, 4, 4, 6 ]
 6 |  4 | [ 1, 1, 5, 5, 10, 10 ]
                        ^^

잘 하셨어요. 그래도 작동 방식을 정확히 이해하고 있는지 확실하지 않습니다. 나의 시도는 너보다 훨씬 길었다.
kamoroso94

@ kamoroso94 설명을 추가했습니다.
Arnauld

나는 이것을 좋아한다! 그것이 무엇을하고 있는지 알아내는 것을 정말로 즐겼습니다.
얽히고 설킨

6

옥타브 , 46 바이트

@(n)(M=sort(spdiags(flip(pascal(n)))))(~~M)(n)

1 기반.

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

설명

고려 n=4예를 들어.

pascal(n) 파스칼 매트릭스를 제공합니다 :

 1     1     1     1
 1     2     3     4
 1     3     6    10
 1     4    10    20

파스칼 삼각형의 행은이 행렬의 대각 대각선입니다. 따라서 수직으로 뒤집습니다.flip(···)

 1     4    10    20
 1     3     6    10
 1     2     3     4
 1     1     1     1

안티 대각선을 대각선으로 변환합니다.

spdiags(···) 왼쪽 아래에서 시작하여 (0이 아닌) 대각선을 추출하여 0으로 채워진 열로 정렬합니다.

 1     1     1     1     0     0     0
 0     1     2     3     4     0     0
 0     0     1     3     6    10     0
 0     0     0     1     4    10    20

M=sort(···)이 행렬의 각 열을 정렬하고 결과를 변수에 할당합니다 M.

 0     0     0     1     0     0     0
 0     0     1     1     4     0     0
 0     1     1     3     4    10     0
 1     1     2     3     6    10    20

(···)(~~M)이제 논리적 인덱싱을 사용하여이 행렬의 0이 아닌 값을 열 주요 순서로 (아래로, 가로로) 추출합니다. 결과는 열 벡터입니다.

 1
 1
 1
 1
···
10
10
20

마지막 n으로이 벡터 의- 번째 항목은을 사용하여 추출되며이 (···)(n)경우에는을 제공합니다 1.


5

파이썬 2 , 86 78 72 바이트

Rod 덕분에 -8 바이트

g=lambda n,r=[1]:r[n:]and r[n/2]or g(n-len(r),map(sum,zip([0]+r,r+[0])))

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

언 골프

def g(n, row=[1]):
  if n < len(row):
    return row[n/2]
  else:
    next_row = map(sum, zip([0] + row, row + [0]))
    return g(n - len(row), next_row)

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

이 함수는 파스칼의 삼각형 행을 재귀 적으로 계산합니다. 현재 행을 row,로 지정했습니다 map(sum, zip([0] + row, row + [0])).
각 호출 n에서 현재 행의 길이만큼 줄어 듭니다. 함수가 오른쪽 행에 도착하면 nth가장 적은 수의 행이 리턴되어야합니다.
행의 전반부는 오름차순이고 각 행은 대칭이므로 숫자는 인덱스 n/2(0- 인덱스, 정수 나누기)입니다.


4

Wolfram Language (Mathematica) , 55 바이트

인덱싱은 1 기반입니다.

(##&@@@Sort/@Table[n~Binomial~k,{n,0,#},{k,0,n}])[[#]]&

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

설명

이것은 골프를 칠 가능성이 높으며, 숙련 된 Mathematica 사용자는 아닙니다.

Table[n~Binomial~k,{n,0,#},{k,0,n}]

n ∈ [0, 입력] ∩ ℤ 에 대해 각 k ∈ [0, n] ∩ ℤ 으로 이항 표를 생성하십시오 .

Sort/@

각각 정렬하십시오. Map[function,object]– 의 속기를 사용합니다 function/@object.

(##&@@@...)[[#]]

결과 목록을 병합하고 목록의 색인이 입력 인 요소를 검색하십시오.



3

R , 58 바이트

function(n)(m=apply(outer(0:n,0:n,choose),1,sort))[m>0][n]

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

n choose k각각 n,k[0,1,...,n]행렬로 계산 하고 행을 오름차순 (*)으로 정렬하고 0을 제거한 다음 nth 요소 를 선택합니다 .

(*) 이것도 열로 변환 하지만 R은 행렬 을 단위로 벡터로 저장하므로 순서를 유지하면서 직접 색인을 만들 수 있기 때문에 더 좋습니다.


3

하스켈 , 143 132 125 123 바이트

((p>>=s.h)!!)
p=[1]:map(\r->zipWith(+)(0:r)(r++[0]))p
h r=splitAt(div(length r)2)r
s(a,b)=reverse b!a
(h:t)!b=h:(b!t)
x!_=x

첫 번째 줄은 인덱스가없는 (0부터 시작) 포인트없는 함수이며 시퀀스에서 적절한 숫자를 반환합니다. 온라인으로 사용해보십시오!

이것은 나의 첫 Haskell 프로그램입니다! 훨씬 짧아 질 것입니다. 팁을 부탁드립니다.

nimi 덕분에 2 바이트 절약

언 골프

pascalRows = [1] : map (\row -> zipWith (+) (0:row) (row++[0])) pascalRows
halves row = splitAt (div (length row) 2) row
joinSorted (first, second) = interleave (reverse second) first
interleave [] _ = []
interleave longer shorter = (head longer) : (interleave shorter (tail longer))
f n = (concatMap (joinSorted.halves) pascalRows) !! n

당신은 여전히 i기능을 가지고 있으며 s이름이으로 변경되었습니다 !. 당신이 중위 기능을 사용하는 경우에는 삭제할 수 있습니다 ()주위를 reverse b: s(a,b)=reverse b!a.
nimi

@nimi Ah, 감사합니다 .TIO에서 변경했지만 여기 코드에서 누락되었습니다. 괄호 팁 주셔서 감사합니다.
DLosc

3

자바 스크립트, 57 바이트

f=(i,r=1)=>i<r?i>1?f(i-2,--r)+f(i<r?i:r-1,r):1:f(i-r,r+1)

인덱스가 0입니다.

어떻게 되나요?

0 단계 :

c=(i,r)=>i?r&&c(i-1,r-1)+c(i,r-1):1
f=(i,r=1)=>i<r?c(i>>1,r-1):f(i-r,r+1)

이 코드는 이해하기 쉽습니다.

  • 함수 c는 조합 사용 공식을 계산합니다 : C (n, k) = C (n-1, k) + C (n-1, k-1); k == 0 또는 k == n 인 경우 1
  • 함수 f는 행 번호와 행에서 색인을 찾은 다음 결과를 얻기 위해 함수 c를 호출합니다.

1 단계:

c=(i,r)=>i>1?--r&&c(i-2,r)+c(i,r):1
f=(i,r=1)=>i<r?c(i,r):f(i-r,r+1)

이 단계에서, 우리는 함수의 호출을 수정하려고 cc(i,r)의 매개 변수와 동일로 만드는을 f.

2 단계:

c=(i,r)=>i>1?--r&&c(i-2,r)+c(i<r?i:r-1,r):1
f=(i,r=1)=>i<r?c(i,r):f(i-r,r+1)

i<r함수 사용 여부를 테스트 f합니다 c. 그것이 우리 i<r가 기능의 재귀 동안 유지를 머스크하는 이유 c입니다.

3 단계 :

f=(i,r=1)=>i<r?i>1?--r&&f(i-2,r)+f(i<r?i:r-1,r):1:f(i-r,r+1)

이 단계에서는이 두 기능을 하나로 병합합니다.

골프를 더 한 후에, 우리는 마침내 위에서 설명한 답을 얻었습니다.


2

젤리 , 13 바이트

0rcþ`ZṢ€Ẏḟ0⁸ị

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

Uriel의 Dyalog 알고리즘 사용

1- 색인.

설명:

0rcþ`ZṢ€Ẏḟ0⁸ị
0r            Return inclusive range from 0 to n
    `         Call this dyad with this argument on both sides
   þ           Outer product with this dyad
  c             Binomial coefficient
     Z        Zip
       €      Call this link on each element
      Ṣ        Sort
        Ẏ     Concatenate elements
         ḟ0   Remove 0s
           ⁸ị Take the nth element

설명을 추가해 주시겠습니까? 나는 þ여기서 무엇 을하고 있는지 알 수 없습니다 .
Shaggy

1
@Shaggy 외부 제품이므로 설명을 추가하겠습니다.
Erik the Outgolfer

2

자바 스크립트 (Node.js) , 65 바이트

배열조차 사용되지 않습니다. 인덱스가 0입니다.

f=(n,i=0,g=x=>x?x*g(x-1):1)=>n>i?f(n-++i,i):g(i)/g(c=n>>1)/g(i-c)

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

설명:

f=(n,i=0,                 )=>                                     // Main Function
         g=x=>x?x*g(x-1):1                                        // Helper (Factorial)
                             n>i?                                 // Is n > i?
                                 f(n-++i,i):                      // If so, call function
                                                                  // f(n-i-1, i+1) to skip
                                                                  // . i+1 terms
                                            g(i)/g(c=n>>1)/g(i-c) // If not, since sorting 
                                                                  // . the binomial coeffs
                                                                  // . equals to writing
                                                                  // . the first floor(i/2)
                                                                  // . coefficients twice
                                                                  // . each, so a shortcut

1

파스칼 , 373 바이트

function t(n,k,r:integer):integer;begin if(n<k)then t:=r-1 else t:=t(n,k+r,r+1)end;
function s(n,k:integer):integer;begin if(k=0)then s:=n else s:=s(n+k,k-1)end;
function f(n,k:integer):integer;begin if((k<1)or(k>n))then f:=0 else if n=1 then f:=1 else f:=f(n-1,k-1)+f(n-1,k)end;
function g(n:integer):integer;var k:integer;begin k:=t(n,0,1);g:=f(k,(n-s(0,k-1)+2)div 2)end;

g 기능입니다.

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


n=1 then일 수 있습니다 n=1then.
Jonathan Frech

SImilarly, 그것은 if(k=0)then될 수있는 것처럼 보입니다 if k=0then.
얽히고 설킨

일부 숫자가 항상 0보다 큰 경우 word대신 대신 사용해야 합니다 integer.
tsh

1

자바 8, 187 바이트

n->{int r=~-(int)Math.sqrt(8*n+1)/2+1,a[]=new int[r],k=r,x=0;for(;k-->0;a[k]=p(r,k))x+=k;java.util.Arrays.sort(a);return a[n-x];}int p(int r,int k){return--r<1|k<2|k>r?1:p(r,k-1)+p(r,k);}

설명:

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

n->{                   // Method with integer as both parameter and return-type
  int r=~-(int)Math.sqrt(8*n+1)/2+1,
                       //  Calculate the 1-indexed row based on the input
      a[]=new int[r],  //  Create an array with items equal to the current row
      k=r,             //  Index integer
      x=0;             //  Correction integer
  for(;k-->0;          //  Loop down to 0
    a[k]=p(r,k))       //   Fill the array with the Pascal's Triangle numbers of the row
    x+=k;              //   Create the correction integer
  java.util.Arrays.sort(a);
                       //  Sort the array
  return a[n-x];}      //  Return the `n-x`'th (0-indexed) item in this sorted array

// Separated recursive method to get the k'th value of the r'th row in the Pascal Triangle
int p(int r,int k){return--r<1|k<2|k>r?1:p(r,k-1)+p(r,k);}

1

MATL , 11 바이트

:qt!XnSXzG)

1 기반.

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

4예를 들어 입력 을 고려하십시오 . ;행렬 또는 열 벡터의 행 구분 기호입니다.

:     % Implicit input: n. Push the row vector [1 2 ... n]          
      S STACK: [1 2 3 4]
q     % Subtract 1, emlement-wise: gives [0 1 ... n-1]
      % STACK: [0 1 2 3]
t!    % Duplicate and transpose into a column vector
      % STACK: [0 1 2 3], [0; 1; 2; 3]
Xn    % Binomial coefficient, element-wise with broadcast. Gives an
      % n×n matrix where entry (i,j) is binomial(i,j), or 0 for i<j
      % STACK: [1 1 1 1;
                0 1 2 3;
                0 0 1 3;
                0 0 0 1]
S     % Sort each column
      % STACK: [0 0 0 1;
      %         0 0 1 1;
      %         0 1 1 3;
      %         1 1 2 3]
Xz    % Keep only nonzeros. Gives a column vector
      % STACK: [1; 1; 1; 1; 1; 2; 1; 1; 3; 3]
G)    % Get the n-th element. Implicitly display
      % STACK: 1

1

배치, 128 바이트

@set/as=2,t=r=m=i=1
:l
@if %1 geq %t% set/as+=r,t+=r+=1&goto l
@for /l %%i in (%s%,2,%1)do @set/ar-=1,m=m*r/i,i+=1
@echo %m%

인덱스가 0입니다.


설명을 추가해 주시겠습니까? 나는 여기서 논리를 따를 수 없다.
AdmBorkBork

@AdmBorkBork 처음 세 줄 은 시리즈 의 행 r과 열 %1-(s-2)을 계산합니다 %1. 그런 다음 네 번째 줄은 이항 계수 (n k) = n!/(n-k)!k!= n(n-1)...(n+1-k)/(1)(2)...k= 를 계산하는 데 사용합니다 (n/1)((n-1)/2)...((n+1-k)/k). 필요할 때 MathJax는 어디에 있습니까?
Neil



1

젤리 , 11 바이트

Ḷc€`Ṣ€Fḟ0ị@

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

인덱스를 가져와 정수를 반환하는 모나드 링크는 1 기반 인덱스를 사용합니다.

방법?

파스칼의 삼각형 (0)의 오른쪽을 더 많이 사용하여 버리면 거의 도전을 수행합니다 ...

Ḷc€`Ṣ€Fḟ0ị@ - Link: integer, i    e.g. 1   or    9
Ḷ           - lowered range            [0]       [0,1,2,3,4,5,6,7,8]
   `        - repeat left as right arg [0]       [0,1,2,3,4,5,6,7,8]
 c€         - binomial choice for €ach [[1]]     [[1,0,0,0,0,0,0,0,0],[1,1,0,0,0,0,0,0,0],[1,2,1,0,0,0,0,0,0],[1,3,3,1,0,0,0,0,0],[1,4,6,4,1,0,0,0,0],[1,5,10,10,5,1,0,0,0],[1,6,15,20,15,6,1,0,0],[1,7,21,35,35,21,7,1,0],[1,8,28,56,70,56,28,8,1]]
    Ṣ€      - sort €ach                [[1]]     [[0,0,0,0,0,0,0,0,1],[0,0,0,0,0,0,0,1,1],[0,0,0,0,0,0,1,1,2],[0,0,0,0,0,1,1,3,3],[0,0,0,0,1,1,4,4,6],[0,0,0,1,1,5,5,10,10],[0,0,1,1,6,6,15,15,20],[0,1,1,7,7,21,21,35,35],[1,1,8,8,28,28,56,56,70]]
      F     - flatten                  [1]       [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,2,0,0,0,0,0,1,1,3,3,0,0,0,0,1,1,4,4,6,0,0,0,1,1,5,5,10,10,0,0,1,1,6,6,15,15,20,0,1,1,7,7,21,21,35,35,1,1,8,8,28,28,56,56,70]
       ḟ0   - filter discard zeros     [1]       [1,1,1,1,1,2,1,1,3,3,1,1,4,4,6,1,1,5,5,111,1,6,6,15,15,21,1,7,7,21,21,35,35,1,1,8,8,28,28,56,56,70]
         ị@ - index into (sw@p args)    1         3 --------------^

1

빨강 , 206 바이트

f: func[n][t: copy[[1]]l: 0
while[l < n][a: copy last t insert append a 0 0 b: copy[]repeat i k:(length? a)- 1[append b a/(i) + a/(i + 1)]append t reduce[b]l: l + k]foreach p t[sort p]pick split form t{ }n]

1 기반

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

설명:

f: func [n] [
    t: copy [[1]]                       ; start with a list with one sublist [1]
    l: 0                                ; there are 1 items overall
    while [l < n] [                     ; while the number of items is less than the argument
        a: copy last t                  ; take the last sublist 
        insert append a 0 0             ; prepend and append 0 to it  
        b: copy []                      ; prepare a list for the sums  
        repeat i k: (length? a) - 1 [   ; loop throught the elements of the list
            append b a/(i) + a/(i + 1)] ; and find the sum of the adjacent items
        append t reduce [b]             ; append the resulting list to the total list
        l: l + k                        ; update the number of the items
    ]
    foreach p t [sort p]                ; sort each sublist
    v: pick split form t { } n          ; flatten the list and take the n-th element
]

1

펄, 48 바이트

포함 +1을 위해p

perl -pe '$_-=$%until$_<++$%;$./=$_/--$%for 1..$_/2;$_=$.' <<< 19

기본 0 인덱싱을 사용합니다.


1

J, 46 41 바이트

f=:](([-2!]){/:~@(i.!<:)@])[:<.2&!@,:^:_1

0 인덱스

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

노트:

  • <.2&!@,:^:_1의 역수를 내림으로써 파스칼 삼각형의 관련 행 번호를 제공합니다 y choose 2.
  • /:~@(i.!<:)@] 행을 계산하고 정렬합니다.
  • [-2!] 행에 색인을 제공합니다.

안녕하세요. 사이트에 오신 것을 환영합니다! 이것은 좋은 첫 번째 대답입니다 :)
DJMcMayhem

1

줄리아 , 70 바이트

f(x)=map(n->binomial(n-1,ceil(Int,x/2-(n^2-n)/4-1)),round(Int,√(x*2)))

1 기반

설명:

먼저 행 번호를 찾은 다음 열 번호를 찾은 다음 이항을 계산합니다.


PPCG에 오신 것을 환영합니다!
Martin Ender 2019

그래 행복한 얼굴
지미 첸


0

Pyth, 15 바이트

@u+GSm.cHdhHhQY

0 인덱스

시도 해봐

설명

@u+GSm.cHdhHhQY
 u          hQY   Reduce on [0, ..., input], starting with the empty list...
  +G              ... append to the accumulator...
    Sm.cHdhH      ... the sorted binomial coefficients.
@              Q  Take the 0-indexed element.



0

실제로 8 바이트

Jonathan Allan의 Jelly 답변을 바탕으로 합니다. 0 인덱싱을 사용합니다.

;r♂╣♂SΣE

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

언 골핑

          Implicit input n.
;         Duplicate n.
 r        Lowered range. [0..n-1].
  ♂╣      Pascal's triangle row of every number.
    ♂S    Sort every row.
      Σ   Sum each row into one array.
       E  Get the n-th element of the array (0-indexed).
          Implicit return.

단일 숫자를 생성해야합니다. n시리즈의 일. 이것은 배열을 생성합니다.
재귀 적

으악. 결정된. 감사합니다 @recursive
Sherlock9



당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.