Le triangle de Pascal est généré en commençant par 1et en ayant chaque ligne formée à partir d'additions successives. Ici, au lieu de cela, nous allons former un triangle en alternant multiplication et addition.

Nous commençons la rangée 1avec juste un solitaire 1. Par la suite, l'addition se fait sur les lignes impaires et la multiplication se fait sur les lignes paires (indexées 1). Lorsque vous effectuez l'étape d'addition, supposez que les espaces à l'extérieur du triangle sont remplis de 0s. Lorsque vous effectuez l'étape de multiplication, supposez que l'extérieur est rempli de 1s.

Voici le triangle complet jusqu'à 7 lignes. Le *ou +sur la gauche indique quelle étape a été effectuée pour générer cette ligne.

1                1
2 *            1   1
3 +          1   2   1
4 *        1   2   2   1
5 +      1   3   4   3   1
6 *    1   3  12  12   3   1
7 +  1   4  15  24  15   4   1

Défi

Étant donné l'entrée n, sortez la ne ligne de ce triangle.

Règles

• Vous pouvez choisir d'indexer à la place, mais sachez ensuite que les lignes d'addition et de multiplication doivent basculer, de sorte que le même triangle exact soit généré comme ci-dessus. Veuillez indiquer dans votre soumission si vous choisissez de le faire.
• L'entrée et la sortie peuvent être supposées correspondre au type d'entier natif de votre langue.
• L'entrée et la sortie peuvent être données dans n'importe quel format pratique .
• Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
• Si possible, veuillez inclure un lien vers un environnement de test en ligne afin que d'autres personnes puissent essayer votre code!
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) gagne.

Exemples

Affichage de deux exemples possibles de sortie sur plusieurs: une liste ou une chaîne séparée par des espaces.

4
[1, 2, 2, 1]

8
"1 4 60 360 360 60 4 1"

Pascal , 249 247 233 octets

Eh bien, c'est le triangle alternatif de Pascal .

_{1 octet enregistré grâce à @ Mr.Xcoder}

function f(n,k:integer):integer;begin if((k<1)or(k>n)or(n=1))then f:=n mod 2 else if n mod 2=0then f:=f(n-1,k-1)*f(n-1,k)else f:=f(n-1,k-1)+f(n-1,k)end;
procedure g(n:integer);var k:integer;begin for k:=1to n do write(f(n,k),' ')end;

Essayez-le en ligne!

Python 2 , 97 93 86 81 78 octets

-4 octets grâce à Rod. -10 octets grâce à Halvard Hummel.

f=lambda n:n and[[i+j,i*j][n%2]for i,j in zip([n%2]+f(n-1),f(n-1)+[n%2])]or[1]

0 indexé.

Essayez-le en ligne!

Gelée , 17 12 octets

µ×+LḂ$?Ḋ1;µ¡

Il s'agit d'un programme complet (ou lien niladique) qui prend en entrée STDIN.

Essayez-le en ligne!

Comment ça marche

µ×+LḂ$?Ḋ1;µ¡  Main link. No arguments. Implicit argument: 0

          µ¡  Start a monadic chain and apply the ntimes quick to the previous one.
              This reads an integer n from STDIN and executes the previous chain n
              times, with initial argument 0, returning the last result.
µ             Start a monadic chain. Argument: A (array or 0)
       Ḋ          Dequeue; yield A without its first element.
   LḂ$?           If the length of A is odd:
 ×                    Multiply A and dequeued A.
                  Else:
  +                   Add A and dequeued A.
        1;        Prepend a 1 to the result.

Python 2 , 96 89 87 octets

• 2 octets Merci à M. Xcoder: s=[1]

• Un peu différent de la réponse totalement humaine

s=a=[1]
for i in range(1,input()):a=s+[[k+l,k*l][i%2]for k,l in zip(a[1:],a)]+s
print a

Essayez-le en ligne!

CJam , 25 octets

{1a\{2%!_2$+\{.*}{.+}?}/}

0 indexé.

Essayez-le en ligne!

Explication

Il s'agit d'un bloc anonyme qui prend le numéro de la pile et laisse le résultat sur la pile.

1a                        Push [1].
  \                       Bring the number to the top.
   {                 }/   For reach number 0 .. arg-1, do:
    2%!                    Push 0 if even, 1 if odd.
       _                   Copy that.
        2$+                Copy the list so far and prepend the 0 or 1 to it.
           \               Bring the 0 or 1 back to the top.
            {.*}{.+}?      If 1, element-wise multiplication. If 0, element-wise addition.

Mathematica, 92 octets

(s={i=1};While[i<#,s=Flatten@{1,{Tr/@#,Times@@@#}[[i~Mod~2+1]]&@Partition[s,2,1],1};i++];s)&

Essayez-le en ligne! (pour travailler les mathématiques, "Tr" est remplacé par "Total")

Haskell , 76 72 octets

Solution indexée 0:

(p!!)
p=[1]:[zipWith o(e:l)l++[1]|(l,(o,e))<-zip p$cycle[((*),1),((+),0)]]

Essayez-le en ligne!

Explication

p définit récursivement le triangle alternatif, le cas de base / premier élément de celui-ci est [1]

p=[1]:[                                                            ]

Il construit ensuite le triangle en prenant la ligne précédente ( l). Pour savoir quoi en faire, nous devons garder une trace de l'opérateur correct ( o) et de l'élément neutre correspondant ( e):

                           |(l,(o,e))<-zip p$cycle[((*),1),((+),0)]

À partir de cela, créez la nouvelle ligne en dupliquant la ligne et pour une copie, nous ajoutons l'élément neutre, les compressons avec l'opérateur et ajoutons un 1:

       zipWith o(e:l)l++[1]

R , 108 98 octets

-10 octets en remplaçant le signe de multiplication réel par un signe plus. S'il vous plaît, pardonnez-moi.

f=function(n){if(n<3)return(rep(1,n))else{v=f(n-1)};if(n%%2)`*`=`+`;return(c(1,v[3:n-2]*v[-1],1))}

Essayez-le en ligne!

Assez satisfait de la méthode générale (première fois que j'ai aliasé une primitive), mais je suis sûr qu'il y a encore du golf à faire, en particulier avec la gestion maladroite des cas où n <3, ce qui conduit à beaucoup de passe-partout.

Husk , 17 16 octets

!G₅;1¢e*+
:1Sż⁰t

Essayez-le en ligne!

Une solution indexée 1.

Explication

La première ligne est la fonction principale, qui appelle la fonction d'assistance sur la deuxième ligne. La fonction d'assistance est généralement appelée avec ₁, mais dans ce cas, j'utilise la fonction d' étiquettes débordantes de Husk: si vous faites référence à une ligne N dans un programme avec M <N lignes, vous obtenez la ligne N mod M avec la fonction de modification M / N s'y est appliqué. La deuxième fonction de modification est flip, donc j'utilise ₅pour inverser les arguments de la fonction d'assistance sans coût supplémentaire en octets.

Voici la fonction d'assistance.

:1Sż⁰t  Takes a function f and a list x.
   ż    Zip preserving elements of longer list
    ⁰   using function f
  S  t  x and its tail,
:1      then prepend 1.

Voici la fonction principale.

!G₅;1¢e*+  Takes a number n.
      e*+  2-element list of the functions * and +
     ¢     repeated infinitely.
 G         Left scan this list
  ₅        using the flipped helper function
   ;1      with initial value [1].
!          Get n'th element.

C # (.NET Core) , 143 134 128 octets

-4 octets grâce à Phaeze
-5 octets grâce à Zac Faragher
-6 octets grâce à Kevin Cruijssen

n=>{int[]b={1},c;for(int i=0,j;++i<n;b=c)for(c=new int[i+1],c[0]=c[i]=1,j=0;++j<i;)c[j]=i%2<1?b[j-1]+b[j]:b[j-1]*b[j];return b;}

Essayez-le en ligne!

Explication:

n =>
{
    int[] b = { 1 }, c;               // Create first layer
    for(int i = 0, j; ++i < n; b = c) // Iterate for every layer, replace last layer with a new one
        for(c = new int[i+1],         // Create new layer
            c[0] = c[i] = 1,          // First and last elements are always 1
            j = 0;
            ++j < i; )                // Replace every element (besides 1st and last)...
                c[j] = i % 2 == 0 ?
                    b[j - 1] + b[j] : // ... with addition...
                    b[j - 1] * b[j];  // ... or multiplication of two from previous layers
    return b;                         // Return latest layer
};

Python 2 , 83 octets

Donnez un peu d'amour à l' exec
index 0

l=[1];exec"l[1:]=[[a+b,a*b][len(l)%2]for a,b in zip(l,l[1:])]+[1];"*input()
print l

Essayez-le en ligne!

Pyth , 22 octets

Des tonnes d'octets enregistrées grâce à @FryAmTheEggman ! La solution initiale est ci-dessous.

u++1@,+VGtG*VGtGlG1Q[1

Suite de tests complète (indexée 0).

Pyth , 40 38 36 35 octets

Cela semble waaaaaaaay trop raisonnablement long. Les suggestions sont les bienvenues.

K]1VStQ=K++]1m@,sd*hded%N2C,KtK]1;K

Testez la suite ou essayez-la en ligne!

J , 32 octets

[:(1,]{::(}.@,-.)(*;+)[)~/2|]-i.

Essayez-le en ligne!

Perl 5 , 111 + 2 (-na) = 113 octets

sub t{($r,$c)=@_;!--$r||!$c||$c>=$r?1:eval"t($r,$c)".($r%2?"*":"+")."t($r,$c-1)"}say map{t($F[0],$_).$"}0..$_-1

Essayez-le en ligne!

Mathematica, 70 octets

Fold[#2@@@Partition[#,2,1,{-1,1},{}]&,{1},PadRight[{},#,{1##&,Plus}]]&

Essayez-le dans le bac à sable Wolfram ! Cela ne fonctionne malheureusement pas en mathématiques. Il est indexé 0.

Explication: Partition[#,2,1,{-1,1},{}]prend une liste et retourne toutes les sous-listes à deux éléments, plus les listes à 1 élément pour le début et la fin - par exemple, {1,2,3,4}devient {{1}, {1,2}, {2,3}, {3,4}, {4}}. PadRight[{},#,{1##&,Plus}]fait une liste alternée de 1##&(effectivement Times) et Plus, dont la longueur est le numéro d'entrée. Puis Foldapplique à plusieurs reprises la fonction de partition avec les Pluses et les Timeses qui lui sont appliqués, pour faire les lignes du triangle.

Rubis , 83 82 octets

->n{a=[1];p=0;n.times{a=[p=1-p,*a,p].each_cons(2).map{|x|x.reduce([:+,:*][p])}};a}

Essayez-le en ligne!

Ceci est indexé 0.

Raquette , 116 octets

(define(t n[i 1][r'(1)])(if(= n 1)r(t(- n 1)(- 1 i)(cons 1(append(map(if(> i 0)* +)(cdr r)(reverse(cdr r)))'(1))))))

Essayez-le en ligne!

TI-Basic (TI-84 Plus CE), 100 octets

Prompt X
{1→M
For(A,2,X
LM→L
A→dim(M
For(B,2,A–1
If A/2=int(A/2
Then
LL(B–1)LL(B→LM(B
Else
LL(B–1)+LL(B→LM(B
End
End
1→LM(dim(LM
End
LM

1-indexé, invite l'utilisateur à entrer et imprime une liste contenant la ne ligne du triangle alternatif de Pascal.

En boucle: _L M est la ligne actuelle et _L L est la ligne précédente.

TI-Basic est un langage tokenisé . Tous les jetons utilisés ici sont des jetons d'un octet.

Je pense que je peux jouer au golf plus loin en modifiant M en place depuis la fin.

Explication:

Prompt X            # 3 bytes; get user input, store in X
{1→M                # 5 bytes, store the first row into LM
For(A,2,X           # 7 bytes, Loop X-1 times, with A as the counter, starting at 2
LM→L                # 5 bytes, copy list M into list L
A→dim(M             # 5 bytes, extend M by one
For(B,2,A–1         # 9 bytes, for each index B that isn't the first or last...
If A/2=int(A/2      # 10 bytes,    if A is even...
Then                # 2 bytes,     then...
LL(B–1)LL(B→LM(B     # 17 bytes,        the Bth item in this row is the Bth times the (B-1)th of the previous row
Else                # 2 bytes,     else...
LL(B–1)+LL(B→LM(B    # 18 bytes,        the Bth item in this row is the Bth plus the (B-1)th of the previous row
End                 # 2 bytes,     endif
End                 # 2 bytes,  endfor
1→LM(dim(LM         # 9 bytes, the last item is always 1
End                 # 2 bytes, endfor
LM                  # 2 bytes, Implicitly print the final row

JavaScript (ES6), 71 69 66 octets

f=n=>n?(p=f(n-1),[...p.map((v,i)=>i--?n%2?v*p[i]:v+p[i]:1),1]):[1]

Essayez-le en ligne!

0 indexé.
-3 octets par @Arnauld

f=n=>n?(p=f(n-1),[...p.map((v,i)=>i--?n%2?v*p[i]:v+p[i]:1),1]):[1]

for (var i = 0; i < 10; ++i) {
  console.log(JSON.stringify(f(i)));
}