Erstellen Sie ein Pascal-Dreieck, das eine verschachtelte Liste ist und an den nicht verwendeten Stellen Nullen enthält.

Im Ausgabearray werden die Zahlen des Pascalschen Dreiecks durch Nullen getrennt und auf jeder Seite durch Nullen aufgefüllt, so dass sie zentriert sind. Beispielsweise darf die untere Zeile (letztes Unterarray) links und rechts keine Nullen haben. Das vorletzte Sub-Array hat auf jeder Seite eine Null-Auffüllung und so weiter.

Hier ist die Ausgabe für die Eingabe 5:

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

Wie üblich gewinnt die Lösung mit den wenigsten Bytes.

Mathematica, 70 68 Bytes

NestList[ListConvolve[{1,0,1},#,2]&,Join[#,{1},#],#2]&[0~Table~#,#]&

Ähnlich wie bei der MATL-Lösung.

Mathematica, 48 Bytes

CellularAutomaton[{#+#3&@@#&,{},1},{{1},0},#-1]&

CellularAutomation ist fantastisch.

Gelee, 12 Bytes

NR¬ṙ-,1S$³Ð¡

Probieren Sie es hier aus.

Erläuterung

                   This is a list of functions, each operating on the input, n:
NR                 Get the range [-n -n+1 ... 0 ... n-1 n].
  ¬                Logical NOT the entire range: [0 0 ... 1 ... 0 0].
         ³Ð¡       Repeat n times, and cumulate the results:
   ṙ-,1                Rotate by both -1 and 1
       S               Sum the results.
        $              (Joins the above two functions)

Haskell, 66 Bytes

q n|d<-0<$[2..n]=scanl(\(s:t)_->zipWith(+)(0:s:t)$t++[0])(d++1:d)d

Anwendungsbeispiel: q 4-> [[0,0,0,1,0,0,0],[0,0,1,0,1,0,0],[0,1,0,2,0,1,0],[1,0,3,0,3,0,1]].

Wie es funktioniert:

d <- 0<$[2..n]                      -- bind d to a list of (length n)-1 zeros
scanl                               -- build a list
                         (d++1:d)   -- starting with  [d ++ 1 ++ d]
      \(s:t)_                    d  -- by combining the previous element with the
                                    -- elements of d, but ignoring them, i.e.
                                    -- build a list of (length d) by repeatedly
                                    -- modifying the start element by
          zipWith(+)                -- adding element-wise
                    (0:s:t)         -- the previous element prepended by 0  
                           t++[0]   -- and the tail of the previous element
                                    -- followed by a 0 

Python 3, 172 158 133 Bytes

def p(n):
 x=2*n+1;y=range
 a=[[0]*x]*n;a[0][n]=1
 for i in y(1,n+1):
  for j in y(x):a[i][j]=a[i-1][j-1]+a[i-1][(j+1)%(x)]
 return a

Wird immer besser

MATL , 24 22 21 Bytes

tEq:=Gq:"t5BX+8L)]N$v

BEARBEITEN (20. Mai 2016): Ab Version 18.0.0 der Sprache benötigt der obige Code einige Änderungen, um ausgeführt zu werden. Der folgende Link enthält diese Änderungen

Probieren Sie es online aus!

Dies verwendet eine Schleife, um jede neue Zeile auf den Stapel zu schieben. Aus der vorherigen Zeile wird eine neue Zeile berechnet, wobei die Faltung angewendet wird [1,0,1]und nur die gewünschte Größe beibehalten wird. Nach der Schleife werden alle Zeilen zu einem 2D-Array verkettet, das angezeigt wird. 2D-Arrays werden in MATL als spaltenausgerichtete numerische Tabellen angezeigt.

t           % implicit input n. Duplicate
Eq          % 2*n-1
:           % range [1,2,...,2*n-1]
=           % gives [0,0,...1,...0,0]. This is the first row
Gq:         % range [1,2,...,n-1]
"           % for each. Repeat n-1 times
  t         %   duplicate latest row. This duplicate will become the next row
  5B        %   push array [1,0,1] (5 converted to binary)
  X+        %   convolution
  8L        %   predefined literal [2,-1i]. Used for indexing
  )         %   apply that index: remove one element at each end
]           % end for each
N$v         % concatenate all rows into a 2D array. Implicitly display

Javascript, 152 146 Bytes

f=i=>[...Array(i)].map((x,j)=>(z=[...Array(i*2-1)].map((_,k)=>+!!~[i-j,i+j].indexOf(k+1)),y=j?z.map((_,k)=>_||(k&&(k+1 in y)?y[k-1]+y[k+1]:_)):z))

f=i=>[...Array(i)].map(
    (x,j)=>(
        z=[...Array(i*2-1)].map(
            (_,k)=>
                +!!~[i-j,i+j]
                    .indexOf(k+1)
        ),
        y=j?z.map(
            (_,k)=>_||
                (k&&(k+1 in y)?
                    y[k-1]+y[k+1]
                :_)
        ):z
    )
)

F=i=>JSON.stringify(f(+i)).replace(/],|^.|.(?=.$)/g,'$&\n')
I.oninput()

<input id=I onInput="O.innerHTML=F(I.value)" value=5><pre id=O>

Im Ernst, 33 Bytes

╩╜r`╣;lD0nkdZΣ`M╜rRZ`i0nkd@;)kΣ`M

Probieren Sie es online aus

Ich bin mir ziemlich sicher, dass mindestens 7 dieser Bytes abgeschabt werden können, also werde ich warten, um eine Erklärung zu veröffentlichen, bis ich mit dem weiteren Golfen fertig bin.

PHP , 106 Bytes

for(;$r++<$a=$argn;)for($c=-$a;++$c<$a;)$t[$r][$c]=$r>1|$c?$t[$r-1][$c-1]+$t[$r-1][$c+1]?:0:1;print_r($t);

Probieren Sie es online aus!