Das Pascalsche Dreieck wird erzeugt, indem 1jede Zeile aus aufeinanderfolgenden Additionen gebildet wird. Stattdessen bilden wir hier ein Dreieck, indem wir Multiplikation und Addition abwechseln.

Wir beginnen die Reihe 1mit nur einem Einzelgänger 1. Danach werden die ungeraden Zeilen addiert und die geraden Zeilen multipliziert (1-indiziert). Wenn Sie den Additionsschritt ausführen, nehmen Sie an, dass die Räume außerhalb des Dreiecks mit 0s gefüllt sind . Wenn Sie den Multiplikationsschritt ausführen, nehmen Sie an, dass die Außenseite mit 1s gefüllt ist .

Hier ist das volle Dreieck bis auf 7 Zeilen. Das *oder +auf der linken Seite zeigt, welcher Schritt ausgeführt wurde, um diese Zeile zu generieren.

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

Herausforderung

Bei gegebener Eingabe nwird die ndritte Zeile dieses Dreiecks ausgegeben .

Regeln

• Sie können stattdessen 0-index wählen, aber beachten Sie, dass die Additions- und Multiplikationszeilen flip-flop sein müssen, damit genau dasselbe Dreieck wie oben generiert wird. Bitte geben Sie bei Ihrer Einreichung an, ob Sie dies tun möchten.
• Es kann davon ausgegangen werden, dass die Eingabe und Ausgabe in den systemeigenen Ganzzahltyp Ihrer Sprache passen.
• Die Ein- und Ausgabe kann in jedem beliebigen Format erfolgen .
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
• Fügen Sie nach Möglichkeit einen Link zu einer Online-Testumgebung hinzu, damit andere Benutzer Ihren Code ausprobieren können!
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Beispiele

Es werden zwei mögliche Beispiele für die Ausgabe von vielen angezeigt: eine Liste oder eine durch Leerzeichen getrennte Zeichenfolge.

4
[1, 2, 2, 1]

8
"1 4 60 360 360 60 4 1"

Pascal , 249 247 233 Bytes

Nun, das ist Pascals alternierendes Dreieck.

_{1 Byte gespart dank @ 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;

Probieren Sie es online!

Python 2 , 97 93 86 81 78 Bytes

-4 Bytes dank Rod. -10 Bytes dank 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-indiziert.

Probieren Sie es online!

Jelly , 17 12 Bytes

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

Dies ist ein vollständiges Programm (oder ein Niladic Link), das Eingaben von STDIN entgegennimmt.

Probieren Sie es online!

Wie es funktioniert

µ×+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 Dank an Herrn Xcoder: s=[1]

• Ein bisschen anders als die Antwort von totalhuman

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

Probieren Sie es online!

CJam , 25 Bytes

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

0-indiziert.

Probieren Sie es online!

Erläuterung

Dies ist ein anonymer Block, der die Nummer vom Stapel nimmt und das Ergebnis auf dem Stapel belässt.

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

Probieren Sie es online! (Um die Mathematik zu bearbeiten, wird "Tr" durch "Total" ersetzt.)

Haskell , 76 72 Bytes

0-indizierte Lösung:

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

Probieren Sie es online!

Erläuterung

p definiert rekursiv das alternierende Dreieck, dessen Basisfall / erstes Element ist [1]

p=[1]:[                                                            ]

Dann baut es das Dreieck auf, indem es die vorhergehende Linie ( l) nimmt. Um zu wissen, was damit zu tun ist, müssen wir den richtigen Operator ( o) und das entsprechende neutrale Element ( e) im Auge behalten :

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

Erstellen Sie daraus die neue Zeile, indem Sie die Zeile duplizieren. Bei einer Kopie stellen wir das neutrale Element voran, komprimieren sie mit dem Operator und fügen eine 1 hinzu:

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

R , 108 98 Bytes

-10 Byte durch Ersetzen des tatsächlichen Multiplikationszeichens durch ein Pluszeichen. Bitte verzeih mir.

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

Probieren Sie es online!

Sehr zufrieden mit der allgemeinen Methode (ich habe zum ersten Mal ein Primitiv als Alias ​​verwendet), aber ich bin mir sicher, dass noch einiges zu tun ist, insbesondere bei der umständlichen Behandlung von Fällen mit n <3, die zu viel Boilerplate führen.

Schale , 17 16 Bytes

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

Probieren Sie es online!

Eine 1-indizierte Lösung.

Erläuterung

Die erste Zeile ist die Hauptfunktion, die die Hilfsfunktion in der zweiten Zeile aufruft. Die Hilfsfunktion wird normalerweise mit aufgerufen ₁, aber in diesem Fall verwende ich die Funktion für überlaufende Bezeichnungen von Husk: Wenn Sie in einem Programm mit M <N Zeilen auf eine Zeile N verweisen , erhalten Sie die Zeile N mod M mit der Modifikatorfunktion M / N darauf angewendet. Die zweite Modifikatorfunktion ist , damit ich die Argumente der Hilfsfunktion ohne zusätzliche Bytekosten spiegeln kann.flip₅

Hier ist die Hilfsfunktion.

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

Hier ist die Hauptfunktion.

!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 dank Phaeze
-5 Bytes dank Zac Faragher
-6 Bytes dank 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;}

Probieren Sie es online!

Erläuterung:

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

Gib exec
0-indizierten etwas Liebe

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

Probieren Sie es online!

Pyth , 22 Bytes

Tonnenweise Byte gespart dank @FryAmTheEggman ! Die anfängliche Lösung ist unten.

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

Vollständige Testsuite (0-indiziert).

Pyth , 40 38 36 35 Bytes

Das fühlt sich zu lang an. Vorschläge sind willkommen.

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

Test Suite oder Online testen !

J , 32 Bytes

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

Probieren Sie es online!

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

Probieren Sie es online!

Mathematica, 70 Bytes

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

Probieren Sie es am Wolfram Sandkasten ! In der Mathematik funktioniert das leider nicht. Es ist 0-indiziert.

Erläuterung: Partition[#,2,1,{-1,1},{}]Nimmt eine Liste und gibt alle Unterlisten mit zwei Elementen sowie Listen mit einem Element für Anfang und Ende zurück, z . B. {1,2,3,4}wird {{1}, {1,2}, {2,3}, {3,4}, {4}}. PadRight[{},#,{1##&,Plus}]erstellt eine abwechselnde Liste von 1##&(effektiv Times) und Plus, deren Länge die eingegebene Nummer ist. Wendet dann Foldwiederholt die Partitionsfunktion mit den darauf angewendeten Pluses und Timeses an, um die Zeilen des Dreiecks zu erstellen.

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}

Probieren Sie es online!

Dies ist 0-indiziert.

Schläger , 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))))))

Probieren Sie es 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-indiziert, fordert den Benutzer zur Eingabe auf und druckt eine Liste mit dem n dritten Zeile von Pascals alternierendem Dreieck.

Während der Schleife: _L M ist die aktuelle Zeile und _L L ist die vorherige Zeile.

TI-Basic ist eine Token-Sprache . Alle hier verwendeten Token sind Ein-Byte-Token.

Ich denke, ich kann dies weiter verbessern, indem ich M am Ende an der richtigen Stelle ändere.

Erläuterung:

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]

Probieren Sie es online!

0-indiziert.
-3 Bytes von @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)));
}