Herausforderung

Erstellen Sie bei einer Folge nicht negativer Ganzzahlen eine Funktion, die eine untergeordnete Pyramide ausgibt, in der die untergeordneten Elemente die Summe beider übergeordneter Zahlen sind.

Das Ergebnis wird als Zeichenfolge über die Registerkarte ausgegeben \t.

Hinweis: Nachgestellte Registerkarten in jeder Zeile sind nicht erforderlich

1\t\t2\t\t3\n\t3\t\t5\t\n\t\t8\t\t results in 
1       2       3
    3       5   
        8       

Optional kann das Ergebnis als Array ausgegeben werden, wobei eine leere Position als Leerzeichen verwendet wird.

[[1,,2,,3],
[,3,,5,],
[,,8,,]]

Beispiel:

Gegebene 4,5,7,3,4,2Ausgabe:

4       5       7       3       4       2
    9       12      10      7       6
        21      22      17      13
            43      39      30
                82      69
                    151

Regeln

• Standard Code-Golfregeln gelten
• Die Eingabe kann eine Zeichenfolge sein, die ein beliebiges Trennzeichen oder ein Array verwendet
• Führende / nachfolgende Zeilenumbrüche und Tabulatoren sind zulässig (jedoch nicht erforderlich, solange die Ausgabe eine umgekehrte Pyramide ist).

Testfälle

Input: 1,3,5

1       3       5
    4       8
        12


Input: 9,8,7,6,5

9       8       7       6       5
    17      15      13      11
        32      28      24
            60      52
                112


Input: 5,5,2,5

[[5,,5,,2,,5],
[,10,,7,,7,],
[,,17,,14,,],
[,,,31,,,]]

Input: 3,3,3

[[3,,3,,3],
[,6,,6,],
[,,12,,]]

Das Gewinnkriterium ist Code-Golf

Hinweis: Diese Herausforderung liegt sehr nahe am Pascal-Dreieck . Der Unterschied ist die benutzerdefinierte Startsequenz (Pascal geht von 1 und im aufsteigenden Modus, dies von einer Eingabe und im absteigenden Modus).

Sandkastenpfosten

APL (Dyalog Unicode) , 31 28 Byte ^SBCS

Stillschweigende Präfixfunktion. Verwendet ein einzelnes Leerzeichen als leere Steckplatzmarkierung. Gibt eine Liste mit Listen mit Zahlen / Leerzeichen zurück.

⍳∘≢{∊(⍺⍴''),,∘' '¨2+/⍣⍺⊢⍵}¨⊂

Probieren Sie es online aus!

⍳∘≢{... }¨⊂ gelten die folgende Funktion für jede
⍳der ɩ ndices  ∘von  ≢Tally mit
⊂dem gesamten Argumente:

 ⊢⍵ das richtige Argument liefern (die ursprüngliche Eingabe)

 2+/⍣⍺ Wenden Sie die paarweise Summe so oft an, wie im linken Argument angegeben

 ,∘' '¨ Fügen Sie jeder Zahl ein Leerzeichen hinzu

 (… ), Fügen Sie das an Folgendes an:

  ⍺⍴'' Elemente des linken Arguments der leeren Zeichenfolge (mit Leerzeichen aufgefüllt)

 ∊ ϵ nlist (abflachen)

05AB1E , 15 Bytes

gFD„		ý'	N×ì,ü+

Probieren Sie es online aus!

Wolfram Language (Mathematica) , 74 Bytes

ArrayPad[Riffle[#,],k++,]&/@NestList[k=0;BlockMap[Tr,#,2,1]&,#,Tr[1^#]-1]&

Probieren Sie es online aus!

Gelee ,  14  13 Bytes

^{14 -> 13 setzt voraus, dass in der Ausgabe des Listenformats nur nachgestellte Leerzeichen zulässig sind. wenn nicht, werde ich auf die 14 zurückgreifen ( gefragt )}

+ƝƬK€z⁶Zṙ"JC$

Eine monadische Verbindung. Die Ausgabe ist eine Liste von Listen, in denen Leerzeichen als Leerzeichen verwendet werden (einschließlich eines einzelnen Eintrags nur für nachgestellte Leerzeichen).

Probieren Sie es online aus! (Enthält eine Fußzeile zum Anzeigen der Listenstruktur, da das Ausführen des monadischen Links als vollständiges Programm implizit die zerschlagene Ausgabe druckt.)

Schale , 22 Bytes

zoΣ~+R"	"oJ"		"msNU¡Ẋ+

Probieren Sie es online aus!

Erläuterung

z(Σ~+R" "(J"  "ms))NU¡Ẋ+  -- example input: [1,2,3]
                     ¡    -- infinitely do and collect in list
                      Ẋ+  -- | sum adjacent
                          -- : [[1,2,3],[3,5],[8],[],[],...
                    U     -- keep up until first repetition: [[1,2,3],[3,5],[8],[]]
z(                )N      -- zip with natural numbers under (example on 1 [1,2,3])
   ~+    (       )        -- | join arguments modified by
     R" "                 -- | | replicate tab: " "
               ms         -- | | show each: ["1","2","3"]
          J"  "           -- | | join with 2 tabs: ["1","  ","2","  ","3"]
                          -- | : [" ","1","  ","2","  ","3"]
  Σ                       -- | concatenate: " 1  2  3"
                          -- : [" 1  2  3","  3  5","   8"]

JavaScript (ES6), 73 Byte

Seltsamer Quellcode ... Wie auch immer, das ist Code-Golf !

Beinhaltet führende und nachfolgende Leerzeichen.

f=(a,p=`
`)=>p+a.join`		`+(1/(y=a.shift())?f(a.map(x=>y+(y=x)),p+`	`):'')

Probieren Sie es online aus!

Perl 5 -a , 62 Bytes

$,="\t\t";do{say"\t"x$i++,@F;map$_+=$F[++$q[@F]],@F}while$#F--

Probieren Sie es online aus!

Python 3 , 101 93 80 Bytes

7 Bytes ( map(str,x)anstelle von for inund init y as '') gespeichert und dank Jo King die nachfolgenden Zeilenumbrüche ( x and[anstelle von print() entfernt .

Dank Ovs wurden 13 Bytes ( [*map(sum,zip(x,x[1:]))]statt [x[j]+x[j+1]for j in range(len(x)-1)]) gespeichert .

f=lambda x,y='':x and[y+'		'.join(map(str,x))]+f([*map(sum,zip(x,x[1:]))],y+'	')

Probieren Sie es online aus!

Netzhaut , 35 Bytes

+¶<`\d+ *(?=(\d+)?)
    $#1*$.(*_$1*)   

Probieren Sie es online aus! Erläuterung:

+

Wiederholen, bis sich der Puffer nicht mehr ändert.

¶<`

Drucken Sie den Inhalt des Puffers vor dem Ersetzen mit einem nachgestellten Zeilenumbruch und

\d+ *(?=(\d+)?)
    $#1*$.(*_$1*)   

Ersetzen Sie eine einzelne Zahl durch ein Paar Registerkarten, aber eine Zahl gefolgt von einer anderen Zahl durch eine Registerkarte, die Summe und eine andere Registerkarte.

C (Klirren) , 112 Bytes

j,k;f(*i,c){for(j=c+1;--j;puts("")){for(k=c-j;k--;)printf("\t");for(;++k<j;i[k]+=i[k+1])printf("%d\t\t",i[k]);}}

Probieren Sie es online aus!

Rot , 151 Bytes

func[b][m: length? b repeat n m[loop n - 1[prin"^-"]print replace/all
form b" ""^-^-"c: copy[]repeat i -1 + length? b[append c b/(i) + b/(i + 1)]b: c]]

Probieren Sie es online aus!

Besser lesbar:

f: func [ b ] [
    m: length? b
    repeat n m [
        loop n - 1 [ prin tab ]
        print replace/all form b " " rejoin [ tab tab ]
        c: copy []
        repeat i (length? b) - 1 [
            append c b/(i) + b/(i + 1)
        ]
        b: c
    ]
]

Perl 6 , 50 48 Bytes

{$_,{say "	"x$++~.join("		");$_[1..*]Z+@$_}...0}

Probieren Sie es online aus!

Anonymer Codeblock, der eine Liste von Ganzzahlen aufnimmt und die invertierte Pyramide druckt.

C # (Visual C # Compiler) , 163 Byte

b=>{var s="";var c=b.Length;for(int i=0;i<c;i++){for(int z=0;z<i;z++)s+="\t";for(int x=0;x<c-i;x++){s+=b[x]+"\t\t";b[x]=x==c-i-1?0:b[x]+b[x+1];}s+="\n";}return s;}

Probieren Sie es online aus!

Lesbar:

b =>    {
            var s = "";
            var c = b.Length;
            for (int i = 0; i < c; i++)
            {
                for (int z = 0; z < i; z++)
                    s += "\t";
                for (int x = 0; x < c - i; x++)
                {
                    s += b[x] + "\t\t";
                    b[x] = x == c - i - 1 ? 0 : b[x] + b[x + 1];
                }
                s += "\n";
            }
            return s;
        }

Japt -Rx , 20 18 Bytes

Die zweite Zeile enthält eine nachfolgende Registerkarte.

Nc¡=ä+
Ëq' ² iEç'  

Versuch es

Erläuterung

                  :Implicit input of array U
N                 :The array of inputs (NOT the input array)
 c                :Concatenate
  ¡               :  Map U
    ä+            :    Consecutive sums of U
   =              :    Reassign to U for next iteration
\n                :Reassign the resulting 2D-array to U
Ë                 :Map each array at index E
 q                :  Join with
  '\t             :   Tab
     ²            :   Repeated twice
       i          :  Prepend
          '\t     :   Tab
         ç        :   Repeated
        E         :   E times
                  :Implicitly join with newlines, trim (not strictly necessary) and output.