Pascals alternierendes Dreieck


21

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

2
@totallyhuman Nein, das Einzige, was man tun sollte, ist die ndritte Reihe.
AdmBorkBork

Antworten:


16

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!



7

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!


1
Gute Arbeit, ich hatte einen (viel) längeren Ansatz . Ich hatte aber noch keine Zeit zum Golfen.
Mr. Xcoder

1
Ich denke, das map([int.__add__ ,int.__mul__][i%2],[i%2]+a,a+[i%2])sollte funktionieren (nicht getestet)
Rod


1
Nein, das ist rekursiv. Sie müssen den Namen angeben.
Mr. Xcoder


5

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.


3

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.

Warten 2%!sollte 1 wenn gerade und 0 wenn ungerade, nein drücken?
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)&

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


3

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]

3

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.


85 Bytes . Ich liebe deine Lösung wirklich mit `*`=`+`! ziemlich schlau. Der Rest meiner Verbesserungen sind nur Standard-Golftechniken, die ich gerne auf Ihren Wunsch hin erläutere :)
Giuseppe

80 Bytes . Ich habe mich von Ihrer Notiz über die Behandlung von Fällen inspirieren lassen, in denenn<3
Giuseppe

2

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.

2

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

Sie sollten in der Lage sein, die b-Array-Initialisierung auf zu ändern, var b=new[]{1};und der Compiler wird den Array-Typ für Sie bestimmen.
JustinM - Wiedereinsetzung von Monica

1
Ein anderer Weg, um die erste Schicht zu konstruieren, ist int[]b={1};- 11 Bytes vs 20 as is oder 16 as in @Phaezes Vorschlag
Zac Faragher

1
@ZacFaragher und Phaeze danke!
Grzegorz Puławski

1
Ich weiß , es ist schon eine Weile, aber Sie können Golf 6 weitere Bytes: 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;}. Ich habe kombiniert cwie folgt int[]b={1},c;; verkürzt i%2==0auf i%2<1; Und entferne die Klammern der Schleife, indem du alles hineinlegst.
Kevin Cruijssen

Groß! Thanks @KevinCruijssen
Grzegorz Puławski


1

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 !


Die Verwendung von "Reduzieren" scheint viel kürzer zu sein . Ich bin auch nicht davon überzeugt, dass dies optimal ist.
FryAmTheEggman

@FryAmTheEggman Siehe meine Revisionshistorie. Ich sagte, ich habe versucht, eine Problemumgehung mit Reduce zu finden u(konnte es aber nicht herausfinden). Vielen Dank!
Mr. Xcoder

Wenn Pyth ein eingebautes Prepend-Append haben würde ...
Mr. Xcoder



1

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.




0

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


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]

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


1
Die Verwendung eines Ternärs sollte 3 Bytes einsparen:i--?n%2?v*p[i]:v+p[i]
Arnauld
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.