Triángulo Alterno de Pascal

21

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 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"
AdmBorkBork
fuente
2
@totallyhuman No, lo único que debe ser stdout debería ser la nfila th.
AdmBorkBork

Respuestas:

16

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!

Uriel
fuente
248 bytes
Sr. Xcoder
7

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!

totalmente humano
fuente
1
Buen trabajo, tuve un enfoque (mucho) más largo . Aunque todavía no tuve tiempo de jugarlo.
Sr. Xcoder
1
Supongo que map([int.__add__ ,int.__mul__][i%2],[i%2]+a,a+[i%2])debería funcionar (no probado)
Rod
1
Esto debería ser correcto
Halvard Hummel
1
No, esto es recursivo. Debes incluir el nombre.
Sr. Xcoder
5

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.
Dennis
fuente
3

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.
Gato de negocios
fuente
Esperar 2%!debe presionar 1 si es par y 0 si es impar, ¿no?
Esolanging Fruit
3

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

J42161217
fuente
3

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]
ბიმო
fuente
3

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.

Criminalmente vulgar
fuente
85 bytes . ¡Realmente amo tu solución `*`=`+`! muy inteligente. El resto de mis mejoras son solo técnicas de golf estándar, que me complacería explicarle a su solicitud :)
Giuseppe
80 bytes . Me inspiré en su nota sobre el manejo de casos donden<3
Giuseppe
2

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.
Zgarb
fuente
2

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
};
Grzegorz Puławski
fuente
Debería poder cambiar la inicialización de su matriz b var b=new[]{1};y el compilador determinará el tipo de matriz por usted.
JustinM - Restablece a Mónica el
1
Otra forma de construir la primera capa es int[]b={1};- 11 bytes vs 20 como es o 16 como en la sugerencia de @Phaeze
Zac Faragher
1
@ZacFaragher y Phaeze gracias!
Grzegorz Puławski
1
Sé que ha sido un buen tiempo, pero se puede jugar golf 6 bytes más: 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;}. Me he combinado casí int[]b={1},c;; acortado i%2==0a i%2<1; Y quitó los corchetes del bucle poniendo todo dentro.
Kevin Cruijssen
¡Excelente! Gracias @KevinCruijssen
Grzegorz Puławski
1

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!

Zarigüeya muerta
fuente
1

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!

Sr. Xcoder
fuente
Usar reduce parece ser mucho más corto . Tampoco estoy convencido de que esto sea óptimo, ¿creo que sub 20 es manejable?
FryAmTheEggman
@FryAmTheEggman Vea mi historial de revisiones. Dije que estaba tratando de encontrar una solución alternativa con reduce u(pero no pude resolverlo). ¡Gracias!
Sr. Xcoder
Si Pyth tuviera un anteponer-agregar incorporado ...
Sr. Xcoder
1

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!

Xcali
fuente
1

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.

No un arbol
fuente
0

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.

Nnnes
fuente
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!

Gato de negocios
fuente
0

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

pizzapants184
fuente
0

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

Birjolaxew
fuente
1
El uso de un ternario debería ahorrar 3 bytes:i--?n%2?v*p[i]:v+p[i]
Arnauld