Crea un triangolo di Pascal che è un elenco nidificato e contiene zeri nei punti non utilizzati.

Nell'array di output, i numeri del triangolo di Pascal sono separati da zero e riempiti da zero su ciascun lato in modo che siano centrati. Ad esempio, la riga inferiore (ultimo sotto-array) non deve avere zero a sinistra e a destra; il penultimo array secondario ha un'imbottitura zero su ciascun lato e così via.

Ecco l'output per l'input 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]]

Come al solito, vince la soluzione con il minor numero di byte.

Mathematica, 70 68 byte

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

Simile alla soluzione MATL.

Mathematica, 48 byte

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

CellularAutomation è fantastico.

Gelatina, 12 byte

NR¬ṙ-,1S$³Ð¡

Provalo qui.

Spiegazione

                   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 byte

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

Esempio di utilizzo: 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]].

Come funziona:

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 byte

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

Continua a migliorare

MATL , 24 22 21 byte

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

MODIFICA (20 maggio 2016): dalla versione 18.0.0 della lingua, il codice sopra riportato necessita di alcune modifiche per essere eseguito. Il link seguente include tali modifiche

Provalo online!

Questo utilizza un ciclo per spingere ogni nuova riga nello stack. Una nuova riga viene calcolata dalla riga precedente applicando la convoluzione [1,0,1]e mantenendo solo la dimensione desiderata. Dopo il ciclo, tutte le righe vengono concatenate in un array 2D, che viene visualizzato. Gli array 2D vengono visualizzati in MATL come tabelle numeriche allineate a colonna.

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 byte

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>

Scherzi a parte, 33 byte

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

Provalo online

Sono relativamente certo che almeno 7 di questi byte possano essere eliminati, quindi aspetterò di pubblicare una spiegazione fino a quando non avrò finito di giocare a golf.

PHP , 106 byte

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

Provalo online!