Il triangolo di Pascal viene generato iniziando con 1e facendo formare ogni riga da aggiunte successive. Qui, invece, formeremo un triangolo alternando moltiplicazione e addizione.

Iniziamo a remare 1solo con un solitario 1. Successivamente, l'addizione viene eseguita sulle righe dispari e la moltiplicazione viene eseguita sulle righe pari (1 indicizzata). Quando si esegue la fase di aggiunta, assumere che gli spazi esterni al triangolo siano riempiti con 0s. Quando si esegue la fase di moltiplicazione, supporre che l'esterno sia pieno di 1s.

Ecco il triangolo completo fino a 7 righe. La *o +a sinistra mostra quale passaggio è stato eseguito per generare quella riga.

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

Sfida

Dato input n, genera la nriga th di questo triangolo.

Regole

• Puoi invece scegliere 0-index, ma tieni presente che le righe di addizione e moltiplicazione devono essere flip-flop, in modo che lo stesso triangolo esatto sia generato come sopra. Si prega di indicare nella richiesta se si sceglie di farlo.
• Si può presumere che l'input e l'output si adattino al tipo intero nativo della tua lingua.
• L'input e l'output possono essere forniti in qualsiasi formato conveniente .
• È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
• Se possibile, includi un collegamento a un ambiente di test online in modo che altre persone possano provare il tuo codice!
• Sono vietate le scappatoie standard .
• Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Esempi

Mostra due possibili esempi di output di molti: un elenco o una stringa separata da spazio.

4
[1, 2, 2, 1]

8
"1 4 60 360 360 60 4 1"

Pascal , 249 247 233 byte

Bene, questo è il triangolo alternato di Pascal .

_{1 byte salvato grazie 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;

Provalo online!

Python 2 , 97 93 86 81 78 byte

-4 byte grazie a Rod. -10 byte grazie 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-indicizzati.

Provalo online!

Gelatina , 17 12 byte

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

Questo è un programma completo (o collegamento niladic) che accetta input da STDIN.

Provalo online!

Come funziona

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

• 2 byte Grazie a Mr. Xcoder: s=[1]

• Un po 'diverso dalla risposta totalmente umana

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

Provalo online!

CJam , 25 byte

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

0-indicizzati.

Provalo online!

Spiegazione

Questo è un blocco anonimo che prende il numero dallo stack e lascia il risultato nello stack.

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 byte

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

Provalo online! (per lavorare sulla matematica "Tr" è sostituito da "Totale")

Haskell , 76 72 byte

Soluzione indicizzata 0:

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

Provalo online!

Spiegazione

p definisce ricorsivamente il triangolo alternato, il caso base / primo elemento è [1]

p=[1]:[                                                            ]

Quindi crea il triangolo prendendo la riga precedente ( l). Per sapere cosa farne dobbiamo tenere traccia dell'operatore corretto ( o) e dell'elemento neutro corrispondente ( e):

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

Da questo costruiamo la nuova linea duplicando la linea e per una copia anteponiamo l'elemento neutro, comprimilo con l'operatore e aggiungi un 1:

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

R , 108 98 byte

-10 byte sostituendo il segno di moltiplicazione effettivo con un segno più. Ti prego, perdonami.

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

Provalo online!

Abbastanza soddisfatto del metodo generale (la prima volta che ho creato un'anteprima di una primitiva), ma sono sicuro che ci sia ancora da giocare a golf, specialmente con la gestione scomoda dei casi in cui n <3 che porta a un sacco di boilerplate.

Buccia , 17 16 byte

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

Provalo online!

Una soluzione con 1 indice.

Spiegazione

La prima riga è la funzione principale, che chiama la funzione di aiuto sulla seconda riga. La funzione helper di solito viene chiamata con ₁, ma in questo caso sto usando la funzione di etichette straripanti di Husk: se si fa riferimento a una linea N in un programma con M <N linee, si ottiene la linea N mod M con funzione modificatore M / N applicato ad esso. La seconda funzione di modifica è flip, quindi sto usando ₅per capovolgere gli argomenti della funzione di supporto senza costi di byte aggiuntivi.

Ecco la funzione di aiuto.

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

Ecco la funzione 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 byte

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

Provalo online!

Spiegazione:

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 byte

Dai un po 'di amore a exec
0-indicizzato

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

Provalo online!

Pyth , 22 byte

Tonnellate di byte risparmiate grazie a @FryAmTheEggman ! La soluzione iniziale è di seguito.

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

Suite di test completa (indicizzata 0).

Pyth , 40 38 36 35 byte

Questo sembra troppo lungo. Suggerimenti sono ben accetti

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

Test Suite o provalo online!

J , 32 byte

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

Provalo online!

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

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

Provalo online!

Mathematica, 70 byte

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

Provalo nella sandbox Wolfram ! Sfortunatamente non funziona in matematica. È indicizzato 0.

Spiegazione: Partition[#,2,1,{-1,1},{}]prende un elenco e restituisce tutti gli elenchi di due elementi, più gli elenchi di 1 elemento per l'inizio e la fine - ad esempio, {1,2,3,4}diventa {{1}, {1,2}, {2,3}, {3,4}, {4}}. PadRight[{},#,{1##&,Plus}]crea un elenco alternato di 1##&(effettivamente Times) e Plus, la cui lunghezza è il numero di input. Quindi Foldapplica ripetutamente la funzione di partizione con gli Pluses e Timesad esso applicati, per creare le righe del triangolo.

Rubino , 83 82 byte

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

Provalo online!

Questo è 0-indicizzato.

Racchetta , 116 byte

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

Provalo online!

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

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-indicizzato, richiede all'utente l'immissione e stampa un elenco contenente il file n riga del triangolo alternato di Pascal.

Durante il looping: _L M è la riga corrente e _L L è la riga precedente.

TI-Basic è un linguaggio tokenizzato . Tutti i token utilizzati qui sono token a un byte.

Penso di poter golf ulteriormente modificando M sul posto dalla fine.

Spiegazione:

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 byte

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

Provalo online!

0-indicizzati.
-3 byte di @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)));
}