Créez un triangle de Pascal qui est une liste imbriquée et contient des zéros dans les emplacements inutilisés.

Dans le tableau de sortie, les nombres du triangle de Pascal sont séparés par des zéros et remplis par des zéros de chaque côté afin qu'ils soient centrés. Par exemple, la ligne du bas (dernier sous-tableau) ne doit pas avoir de zéros à gauche et à droite; l'avant-dernier sous-tableau a un remplissage nul de chaque côté, et ainsi de suite.

Voici la sortie pour l'entrée 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]]

Comme d'habitude, la solution avec le moins d'octets l'emporte.

Mathematica, 70 68 octets

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

Similaire à la solution MATL.

Mathematica, 48 octets

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

CellularAutomation est fantastique.

Gelée, 12 octets

NR¬ṙ-,1S$³Ð¡

Essayez-le ici.

Explication

                   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 octets

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

Exemple d'utilisation: 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]].

Comment ça fonctionne:

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 octets

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

Continue à s'améliorer

MATL , 24 22 21 octets

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

EDIT (20 mai 2016): à partir de la version 18.0.0 de la langue, le code ci-dessus a besoin de quelques modifications pour s'exécuter. Le lien ci-dessous inclut ces modifications

Essayez-le en ligne!

Cela utilise une boucle pour pousser chaque nouvelle ligne sur la pile. Une nouvelle ligne est calculée à partir de la ligne précédente en appliquant une convolution avec [1,0,1]et en conservant uniquement la taille souhaitée. Après la boucle, toutes les lignes sont concaténées dans un tableau 2D, qui s'affiche. Les tableaux 2D sont affichés dans MATL sous forme de tableaux numériques alignés sur les colonnes.

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 octets

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>

Sérieusement, 33 octets

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

Essayez-le en ligne

Je suis relativement certain qu'au moins 7 de ces octets peuvent être rasés, donc je vais attendre de poster une explication jusqu'à ce que j'aie fini de jouer plus loin.

PHP , 106 octets

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

Essayez-le en ligne!