El triángulo de Pascal se genera al comenzar 1y formar cada fila a partir de adiciones sucesivas. Aquí, en cambio, formaremos un triángulo alternando la multiplicación y la suma.

Comenzamos la fila 1con solo un solitario 1. Posteriormente, la suma se realiza en las filas impares, y la multiplicación se realiza en las filas pares (1 indexado). Al realizar el paso de suma, suponga que los espacios fuera del triángulo están llenos de 0s. Al realizar el paso de multiplicación, suponga que el exterior está lleno de 1s.

Aquí está el triángulo completo hasta 7 filas. El *o +a la izquierda muestra qué paso se realizó para generar esa fila.

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

Reto

Dada entrada n, salida de la nfila th de este triángulo.

Reglas

• En su lugar, puede optar por un índice 0, pero luego tenga en cuenta que las filas de suma y multiplicación deben flip-flop, de modo que se genere exactamente el mismo triángulo que el anterior. Indique en su envío si elige hacer esto.
• Se puede suponer que la entrada y la salida encajan en el tipo entero nativo de su idioma.
• La entrada y la salida se pueden dar en cualquier formato conveniente .
• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• Si es posible, incluya un enlace a un entorno de prueba en línea para que otras personas puedan probar su código.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

Ejemplos

Mostrando dos ejemplos posibles de salida de muchos: una lista o una cadena separada por espacios.

4
[1, 2, 2, 1]

8
"1 4 60 360 360 60 4 1"

Pascal , 249 247 233 bytes

Bueno, este es el triángulo alterno de Pascal .

_{1 byte guardado gracias a @ 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;

Pruébalo en línea!

Python 2 , 97 93 86 81 78 bytes

-4 bytes gracias a Rod. -10 bytes gracias a 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 indexado.

Pruébalo en línea!

Jalea , 17 12 bytes

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

Este es un programa completo (o enlace niladic) que recibe información de STDIN.

Pruébalo en línea!

Cómo funciona

µ×+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 bytes

• 2 bytes Gracias al Sr. Xcoder: s=[1]

• Un poco diferente a la respuesta totalmente humana

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

Pruébalo en línea!

CJam , 25 bytes

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

0 indexado.

Pruébalo en línea!

Explicación

Este es un bloque anónimo que toma el número de la pila y deja el resultado en la pila.

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 bytes

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

Pruébalo en línea! (para trabajar en matemáticas, "Tr" se reemplaza por "Total")

Haskell , 76 72 bytes

Solución indexada 0:

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

Pruébalo en línea!

Explicación

p define recursivamente el triángulo alterno, el caso base / primer elemento del mismo es [1]

p=[1]:[                                                            ]

Luego construye el triángulo tomando la línea anterior ( l). Para saber qué hacer con él, necesitamos hacer un seguimiento del operador correcto ( o) y el elemento neutral correspondiente ( e):

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

A partir de esto, construya la nueva línea duplicando la línea y para una copia anteponemos el elemento neutral, los comprimimos con el operador y agregamos un 1:

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

R , 108 98 bytes

-10 bytes reemplazando el signo de multiplicación real con un signo más. Por favor perdoname.

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

Pruébalo en línea!

Bastante satisfecho con el método general (la primera vez que he usado un alias primitivo), pero estoy seguro de que todavía se puede jugar al golf, especialmente con el manejo incómodo de casos donde n <3, lo que lleva a una gran cantidad de repeticiones.

Casco , 17 16 bytes

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

Pruébalo en línea!

Una solución indexada 1.

Explicación

La primera línea es la función principal, que llama a la función auxiliar en la segunda línea. La función auxiliar generalmente se llama con ₁, pero en este caso estoy usando la función de etiquetas desbordantes de Husk: si hace referencia a una línea N en un programa con M <N líneas, obtiene la línea N mod M con la función modificadora M / N aplicado a ella. La segunda función modificadora es flip, así que estoy usando ₅para voltear los argumentos de la función auxiliar sin costo adicional de bytes.

Aquí está la función auxiliar.

: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.

Aquí está la función principal.

!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 bytes

-4 bytes gracias a Phaeze
-5 bytes gracias a Zac Faragher
-6 bytes gracias a 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;}

Pruébalo en línea!

Explicación:

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 bytes

Dale un poco de amor a exec
0 indexado

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

Pruébalo en línea!

Pyth , 22 bytes

¡ Ahorró toneladas de bytes gracias a @FryAmTheEggman ! La solución inicial está abajo.

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

Conjunto de pruebas completo (0 indexado).

Pyth , 40 38 36 35 bytes

Esto se siente muuuuucho demasiado razonablemente largo. Las sugerencias son bienvenidas.

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

Test Suite o Pruébelo en línea!

J , 32 bytes

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

Pruébalo en línea!

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

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

Pruébalo en línea!

Mathematica, 70 bytes

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

¡Pruébalo en el sandbox de Wolfram ! No funciona en matemáticas, desafortunadamente. Está indexado a 0.

Explicación: Partition[#,2,1,{-1,1},{}]toma una lista y devuelve todas las sublistas de dos elementos, más las listas de 1 elemento para el inicio y el final, por ejemplo, se {1,2,3,4}convierte en {{1}, {1,2}, {2,3}, {3,4}, {4}}. PadRight[{},#,{1##&,Plus}]hace una lista alterna de 1##&(efectivamente Times) y Plus, cuya longitud es el número de entrada. Luego Foldaplica repetidamente la función de partición con los Pluses y Timeses aplicados a ella, para hacer las filas del triángulo.

Ruby , 83 82 bytes

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

Pruébalo en línea!

Esto está indexado a 0.

Raqueta , 116 bytes

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

Pruébalo en línea!

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

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 indexado, solicita al usuario que ingrese e imprime una lista que contiene la nfila th del triángulo alterno de Pascal.

Durante el bucle: _L M es la fila actual y _L L es la fila anterior.

TI-Basic es un lenguaje tokenizado . Todas las fichas utilizadas aquí son fichas de un byte.

Creo que puedo seguir jugando al golf modificando M en el lugar desde el final.

Explicación:

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 bytes

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

Pruébalo en línea!

0 indexado.
-3 bytes por @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)));
}