Code-golf: générer le triangle de pascal

Question

Générer une liste de listes (ou d'impression, je n'ai pas l'esprit) un le Triangle de Pascal de taille N avec le moins de lignes de code possible!

Voici ma tentative (118 caractères dans la version 2.6 de python à l'aide d'un truc):

c,z,k=locals,[0],'_[1]'
p=lambda n:[len(c()[k])and map(sum,zip(z+c()[k][-1],c()[k][-1]+z))or[1]for _ in range(n)]

Explication:

• le premier élément de la liste de compréhension (lorsque la longueur est de 0) est - [1]
• la prochaine éléments sont obtenus de la façon suivante:
• prendre la liste précédente et de faire deux listes, un collier avec un 0 au début et l'autre à la fin.
  • par exemple, pour la 2ème étape, nous prenons [1] et faire [0,1] et [1,0]
• somme de deux nouvelles listes élément par élément
  • par exemple, nous faisons une nouvelle liste [(0,1),(1,0)] et carte avec la fonction sum.
• répéter n fois et c'est tout.

d'utilisation (avec jolie impression, en fait de code-golf xD):

result = p(10)
lines = [" ".join(map(str, x)) for x in result]
for i in lines:
    print i.center(max(map(len, lines)))

sortie:

             1             
            1 1            
           1 2 1           
          1 3 3 1          
         1 4 6 4 1         
       1 5 10 10 5 1       
      1 6 15 20 15 6 1     
    1 7 21 35 35 21 7 1    
   1 8 28 56 70 56 28 8 1  
1 9 36 84 126 126 84 36 9 1

Answer 1

K (Wikipedia), 15 caractères:

p:{x{+':x,0}\1}

Exemple de sortie:

  p 10
(1
 1 1
 1 2 1
 1 3 3 1
 1 4 6 4 1
 1 5 10 10 5 1
 1 6 15 20 15 6 1
 1 7 21 35 35 21 7 1
 1 8 28 56 70 56 28 8 1
 1 9 36 84 126 126 84 36 9 1
 1 10 45 120 210 252 210 120 45 10 1)

Il est également facile à expliquer:

p:{x {+':x,0} \ 1}
   ^ ^------^ ^ ^
   A    B     C D

• p est une fonction prenant un paramètre implicite x.

• p se déroule (C) une fonction anonyme (B) x temps (A) 1 D).

• La fonction anonyme prend simplement une liste x, ajoute 0 et renvoie un résultat en ajoutant (+) de chaque paire adjacente (':) de valeurs: donc, par exemple en commençant par (1 2 1), il va produire de l' (1 2 1 0), ajouter des paires (1 1+2 2+1 1+0), donner des (1 3 3 1).

---

Mise à jour: Adapté à K4, qui se rase un autre deux personnages. Pour référence, voici l'original K3 version:

p:{x{+':0,x,0}\1}

Answer 2

J , une autre langue de la famille APL, 9 caractères:

 p=:!/~@i.
 

Ceci utilise le verbe "combinaisons" intégré de J.

Sortie:

    p 10
1 1 1 1 1  1  1  1  1   1
0 1 2 3 4  5  6  7  8   9
0 0 1 3 6 10 15 21 28  36
0 0 0 1 4 10 20 35 56  84
0 0 0 0 1  5 15 35 70 126
0 0 0 0 0  1  6 21 56 126
0 0 0 0 0  0  1  7 28  84
0 0 0 0 0  0  0  1  8  36
0 0 0 0 0  0  0  0  1   9
0 0 0 0 0  0  0  0  0   1
 

Answer 3

Haskell , 58 caractères:

 r 0=[1]
r(n+1)=zipWith(+)(0:r n)$r n++[0]
p n=map r[0..n]
 

Sortie:

 *Main> p 5
[[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1],[1,5,10,10,5,1]]
 

Plus lisible:

 -- # row 0 is just [1]
row 0     = [1]
-- # row (n+1) is calculated from the previous row
row (n+1) = zipWith (+) ([0] ++ row n) (row n ++ [0])
-- # use that for a list of the first n+1 rows
pascal n  = map row [0..n]
 

Answer 4

69C en C:

 f(int*t){int*l=t+*t,*p=t,r=*t,j=0;for(*t=1;l<t+r*r;j=*p++)*l++=j+*p;}
 

Utilisez-le comme suit:

 int main()
{
#define N 10
    int i, j;
    int t[N*N] = {N};

    f(t);

    for (i = 0; i < N; i++)
    {
        for (j = 0; j <= i; j++)
            printf("%d ", t[i*N + j]);
        putchar('\n');
    }
    return 0;
}
 

Answer 5

F # : 81 caractères

 let f=bigint.Factorial
let p x=[for n in 0I..x->[for k in 0I..n->f n/f k/f(n-k)]]
 

Explication: Je suis trop fainéant pour être aussi intelligent que les programmeurs Haskell et K. J'ai donc choisi la route suivante: chaque élément du triangle de Pascal peut être identifié de manière unique à l'aide d'une ligne n et d'une colonne k, où la valeur de chaque élément est n!/(k! (n-k)! .