Fast jeder hier ist mit Pascals Dreieck vertraut. Es besteht aus aufeinanderfolgenden Zeilen, wobei jedes Element die Summe der beiden Nachbarn oben links und oben rechts ist. Hier sind die ersten 5Zeilen (aus dem Generate Pascal-Dreieck entlehnt ):

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

Reduzieren Sie diese Zeilen nach links

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

Sortieren Sie sie in aufsteigender Reihenfolge

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

Lesen Sie dieses Dreieck zeilenweise

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

Geben Sie bei einer Eingabe ndie nth-Zahl in dieser Reihe aus. Dies ist OEIS 107430 .

Regeln

• Sie können zwischen 0- und 1-basierter Indizierung wählen. Bitte geben Sie bei Ihrer Einreichung an, welche.
• Es kann davon ausgegangen werden, dass die Eingabe und Ausgabe in den systemeigenen Ganzzahltyp Ihrer Sprache passen.
• Die Eingabe und Ausgabe kann durch jede bequeme Methode erfolgen .
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

JavaScript (ES6), 79 Byte

0-indiziert.

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

Demo

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

console.log([...Array(79).keys()].map(n => f(n)).join(', '))

Wie?

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

Dieser Algorithmus generiert direkt die sortierten Zeilen des Pascalschen Dreiecks. Es aktualisiert n entsprechend der Länge der vorherigen Zeile, bis ein [n] existiert. Beispielsweise sind für n = 19 6 Iterationen erforderlich :

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

Oktave , 46 Bytes

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

1-basiert.

Probieren Sie es online!

Erläuterung

Betrachten Sie n=4als Beispiel.

pascal(n) gibt eine Pascal-Matrix:

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

Die Reihen des Pascal-Dreiecks sind die Antidiagonalen dieser Matrix. So wird es vertikal mit gespiegeltflip(···)

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

die Antidiagonalen in Diagonalen verwandelt.

spdiags(···) extrahiert die Diagonalen (ungleich Null) von links unten und ordnet sie als mit Nullen aufgefüllte Spalten an:

 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(···)sortiert jede Spalte dieser Matrix und weist das Ergebnis der Variablen zu 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

Die logische Indizierung (···)(~~M)wird jetzt verwendet, um die Nicht-Zeros dieser Matrix in Spalten-Hauptreihenfolge (abwärts, dann quer) zu extrahieren. Das Ergebnis ist ein Spaltenvektor:

 1
 1
 1
 1
···
10
10
20

Schließlich wird der n-te Eintrag dieses Vektors mit extrahiert (···)(n), was in diesem Fall ergibt 1.

Python 2 , 86 78 72 Bytes

-8 Bytes dank Rod

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

Probieren Sie es online!

Ungolfed

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)

Probieren Sie es online!

Die Funktion berechnet rekursiv die Zeile des Pascalschen Dreiecks. Angesichts der gegenwärtigen Zeile als row, map(sum, zip([0] + row, row + [0])).
Bei jedem Aufruf nwird die Länge der aktuellen Zeile reduziert. Wenn die Funktion in der rechten Zeile ankommt, sollte die nthniedrigste Nummer der Zeile zurückgegeben werden.
Da sich die erste Hälfte einer Zeile in aufsteigender Reihenfolge befindet und jede Zeile symmetrisch ist, befindet sich die Nummer am Index n/2(0-indexierte Ganzzahldivision).

Wolfram Language (Mathematica) , 55 Byte

Die Indizierung basiert auf 1.

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

Probieren Sie es online!

Erläuterung

Dies ist wahrscheinlich golffähig, ich bin kein sehr erfahrener Mathematica-Benutzer.

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

Generieren Sie für jedes n ∈ [0, Eingabe] ∩ ∩ die Tabelle der Binome mit jedem k ∈ [0, n] ∩ ℤ .

Sort/@

Sortieren Sie jeden. Verwendet eine Abkürzung für Map[function,object]- function/@object.

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

Reduzieren Sie die resultierende Liste und rufen Sie das Element ab, dessen Index in der Liste die Eingabe ist.

APL (Dyalog) , 26 bis 25 Bytes

1 Byte gespeichert dank @ngn

{⍵⊃0~⍨∊(⍋⊃¨⊂)¨↓⍉∘.!⍨⍳1+⍵}

Probieren Sie es online!

R , 58 Bytes

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

Probieren Sie es online!

Berechnet n choose kfür jeden n,kin [0,1,...,n]als Matrix, sortiert die Zeilen aufsteigend (*), und entfernt die Nullen, dann wählt das nten Element.

(*) Dadurch werden sie auch in Spalten umgewandelt, aber das ist besser, da R eine Matrix spaltenweise als Vektor speichert, sodass wir sie direkt indizieren und dabei die Reihenfolge beibehalten können.

Haskell , 143 132 125 123 Bytes

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

Die erste Zeile ist eine punktfreie Funktion, die einen Index (0-basiert) verwendet und die entsprechende Nummer in der Sequenz zurückgibt. Probieren Sie es online!

Dies ist mein erstes Haskell-Programm! Ich bin sicher, es kann viel kürzer werden. Trinkgelder sind erwünscht.

2 Bytes dank nimi gespart

Ungolfed

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

JavaScript, 57 Bytes

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-indiziert.

Wie kommt das

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

Dieser Code ist leicht zu verstehen:

• Funktion cberechnet die Formel für die Kombinationsverwendung: C (n, k) = C (n-1, k) + C (n-1, k-1); oder 1, wenn k == 0 oder k == n
• Funktion fversuchen Sie, die Zeilennummer und den Index in der Zeile herauszufinden, und rufen Sie dann die Funktion c auf, um das Ergebnis zu erhalten.

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

In diesem Schritt versuchen wir , den Aufruf der Funktion zu ändern , czu c(i,r)denen macht es genauso wie Parameter f.

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

Wir testen, i<rob die Funktion verwendet wirdf oder Funktion verwendet wird c. Das ist der Grund, warum wir i<rwährend der Funktionsrekursion Moschus halten c.

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

In diesem Schritt verschmelzen wir diese beiden Funktionen zu einer.

Nach etwas mehr Golf haben wir endlich die oben beschriebene Antwort bekommen.

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)

for(i=0,x=1;x<10;x++) {
document.write('<p>')
for(j=0;j<x;j++,i++) document.write(`<b>${f(i)}</b>`)
}

p { text-align: center; }
b { display: inline-block; width: 4ch; font-weight: normal; }

Jelly , 13 Bytes

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

Probieren Sie es online!

Verwendung des Dyalog-Algorithmus von Uriel.

1-indiziert.

Erläuterung:

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

JavaScript (Node.js) , 65 Byte

Nicht einmal ein Array wird verwendet. 0-indiziert.

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)

Probieren Sie es online!

Erläuterung:

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

Pascal , 373 Bytes

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 ist die Funktion.

Probieren Sie es online!

Java 8, 187 Bytes

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

Erläuterung:

Probieren Sie es online aus.

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

MATL , 11 Bytes

:qt!XnSXzG)

1-basiert.

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

Betrachten Sie die Eingabe 4als Beispiel. ;ist der Zeilentrenner für Matrizen oder Spaltenvektoren.

:     % 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

Batch, 128 Bytes

@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-indiziert.

APL (Dyalog Classic) , 17 Byte

⎕⊃∊i!⍨,\⌊.5×i←⍳99

Probieren Sie es online!

0-basierte Indizierung

Beachten Sie, dass (49!98) > 2*53der Binomialkoeffizient 98 über 49 größer als 2 ^{53 ist} , sodass Dyalog zu diesem Zeitpunkt aufgrund von IEEE-Gleitkomma bereits an Genauigkeit verliert

05AB1E , 10 Bytes

0-indiziert

ÝεDÝc{}˜sè

Probieren Sie es online!

Erläuterung

Ý             # push range [0 ... input]
 ε    }       # apply to each element
  DÝc         # N choose [0 ... N]
     {        # sort
       ˜      # flatten result to a list
        sè    # get the element at index <input>

Jelly , 11 Bytes

Ḷc€`Ṣ€Fḟ0ị@

Probieren Sie es online!

Ein monadischer Link, der den Index aufnimmt und eine Ganzzahl zurückgibt - verwendet eine 1-basierte Indizierung.

Wie?

Führt die Herausforderung so aus, wie sie geschrieben wurde, nur mit mehr rechts von Pascals Dreieck (Nullen), das dann weggeworfen wird ...

Ḷ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 --------------^

Rot , 206 Bytes

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

Probieren Sie es online!

Erläuterung:

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
]

Perl, 48 Bytes

Enthält +1fürp

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

Verwendet die Indexierung zur Basis 0.

J, 46 41 Bytes

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

0-indiziert

Probieren Sie es online!

Anmerkungen:

• <.2&!@,:^:_1ergibt die relevante Zeilennummer des Pascalschen Dreiecks durch Abrunden des Kehrwerts von y choose 2.
• /:~@(i.!<:)@] berechnet die Zeile und sortiert sie.
• [-2!] gibt den Index in die Zeile.

Julia , 70 Bytes

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

1-basiert

Erläuterung:

Es findet zuerst die Zeilennummer, dann die Spaltennummer und berechnet dann das Binomial

Gelee , 17 Bytes

1+2\1,1j$$СṢ€Ẏ⁸ị

Probieren Sie es online!

Pyth, 15 Bytes

@u+GSm.cHdhHhQY

0-indiziert

Versuch es

Erläuterung

@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.

Sauber , 80 Bytes

import StdEnv

\n=flatten[sort[prod[j+1..i]/prod[1..i-j]\\j<-[0..i]]\\i<-[0..]]!!n

Probieren Sie es online!

Als Lambda-Funktion.

Ruby , 56 Bytes

->n{a=0;n-=a until n<a+=1;[*2..a].combination(n/2).size}

0-basiert

Holen Sie sich zuerst die Zeile und die Spalte in das Dreieck und berechnen Sie dann den dieser Position entsprechenden Binomialkoeffizienten.

Probieren Sie es online!

Eigentlich 8 Bytes

Hauptsächlich basierend auf Jonathan Allans Jelly-Antwort . Verwendet die 0-Indizierung.

;r♂╣♂SΣE

Probieren Sie es online!

Ungolfing

          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.

Kokosnuss , 69 Bytes

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

Probieren Sie es online!

Pari / GP , 47 Bytes

n->concat([vecsort(Vec((1+x)^i))|i<-[0..n]])[n]

Probieren Sie es online!

C (GCC) , 140 123 Bytes

• 17 Bytes dank ceilingcat gespart .

F(n){n=n?n*F(~-n):1;}f(n,j,k,c){for(c=j=0;j<n;j++)for(k=0;k<=j/2;k++)if(++c==n||j&1|k-j/2&&++c==n)return F(j)/F(k)/F(j-k);}

Probieren Sie es online!