Cree un Triángulo de Pascal que sea una lista anidada y que contenga ceros en los puntos no utilizados.

En la matriz de salida, los números del Triángulo de Pascal están separados por ceros y rellenados por ceros en cada lado para que estén centrados. Por ejemplo, la fila inferior (última submatriz) no debe tener ceros a la izquierda ni a la derecha; el penúltimo subarreglo tiene un relleno cero en cada lado, y así sucesivamente.

Aquí está la salida para la entrada 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]]

Como de costumbre, la solución con la menor cantidad de bytes gana.

Mathematica, 70 68 bytes

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

Similar a la solución MATL.

Mathematica, 48 bytes

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

CellularAutomation es fantastico.

Jalea, 12 bytes

NR¬ṙ-,1S$³Ð¡

Pruébalo aquí.

Explicación

                   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

Ejemplo de uso: 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]].

Cómo funciona:

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

Sigue mejorando

MATL , 24 22 21 bytes

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

EDITAR (20 de mayo de 2016): a partir de la versión 18.0.0 del lenguaje, el código anterior necesita algunos cambios para ejecutarse. El siguiente enlace incluye esas modificaciones

Pruébalo en línea!

Esto usa un bucle para empujar cada nueva fila a la pila. Se calcula una nueva fila a partir de la fila anterior aplicando convolución [1,0,1]y manteniendo solo el tamaño deseado. Después del bucle, todas las filas se concatenan en una matriz 2D, que se muestra. La matriz 2D se muestra en MATL como tablas numéricas alineadas con columnas.

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>

En serio, 33 bytes

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

Pruébalo en línea

Estoy relativamente seguro de que al menos 7 de esos bytes se pueden eliminar, por lo que esperaré para publicar una explicación hasta que termine de jugar más.

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

Pruébalo en línea!