Fassen Sie es wirklich zusammen.

Schreiben Sie ein Programm oder eine Funktion, die eine nicht leere Liste von Dezimalzahlen (0-9) aufnimmt und ein nach unten zeigendes "Dreieck" von Ziffern mit der Eingabeliste oben ausgibt, wobei jede Ziffer nach der ersten Zeile die Summe der beiden Ziffern ist darüber modulo 10.

Beispielsweise hat die Eingabe [7, 5, 0, 9]eine Ausgabe

7 5 0 9
 2 5 9
  7 4
   1

denn 2ist (7 + 5) mod 10, 5ist (5 + 0) mod 10, 9ist (0 + 9) mod 10, etc. bis zum 1Sein (7 + 4) mod 10.

Wenn die Liste nur einen Eintrag enthält, stimmt die Ausgabe mit der Eingabe überein. zB eine Eingabe von [4]wird ergeben

4

Hier sind einige zusätzliche Beispiele:

[0]

0

[1, 2]

1 2
 3

[8, 7]

8 7
 5

[0, 0]

0 0
 0

[1, 4, 2]

1 4 2
 5 6
  1

[0, 1, 0]

0 1 0
 1 1
  2

[1, 0, 0, 0]

1 0 0 0
 1 0 0
  1 0
   1

[1, 2, 3, 4]

1 2 3 4
 3 5 7
  8 2
   0

[1, 2, 3, 5, 8]

1 2 3 5 8
 3 5 8 3
  8 3 1
   1 4
    5

[9, 2, 4, 5, 3, 2, 2]

9 2 4 5 3 2 2
 1 6 9 8 5 4
  7 5 7 3 9
   2 2 0 2
    4 2 2
     6 4
      0

Beachten Sie, dass in der Ausgabe:

• Die erste Zeile enthält keine führenden Leerzeichen.
• Jede nachfolgende Zeile enthält ein Leerzeichen mehr als die vorherige Zeile.
• Ziffern werden durch ein einzelnes Leerzeichen getrennt.
• Jede Zeile darf maximal ein Leerzeichen enthalten.
• Es kann eine einzelne optionale nachgestellte Newline geben.
• Sie müssen die Zeichen für normale Dezimalstellen (0 bis 9) verwenden.

Der kürzeste Code in Bytes gewinnt. Tiebreaker ist frühere Antwort.

BrainF ** k, 396 391 Bytes

>+>>++++[-<++++++++>]->,----------[++++++++++.>>++++++++[-<++++<------>>]<.,----------]-<+[-<+]->>+[-<<<<<++++++++++.[-]>[-<+>>.<]<[->+<]>+>>>[[->+]->>+<<<+[-<+]->]>+[-<->[[->+]->+>>+<<<<+[-<+]->]<+>->+[->+]->>[->+<]>+>++++++++++>>-<<[-<-[>>]<]<->>>+[-<<<+>>>[-<->]<+++++++++>>>+]++++++++[-<++++<++++++>>]<<<[-<<<<+[-<+]-<+>>+[->+]->>>>+<]>.>.[-]<[-]<<<[->+<]<<+[-<+]>+]>>[-]<<<-<+[-<+]->>+]

Ich konnte der Versuchung nicht widerstehen, dies zu tun. Zumindest ist das Dreieck spitz nach unten.

Die Eingabe erfolgt in Form einer Folge von numerischen Zeichen, gefolgt von einer einzelnen neuen Zeile.

Die Ausgabe enthält in jeder Zeile ein einzelnes Leerzeichen.

Beispiele:

$ bf sd.bf
010
0 1 0 
 1 1 
  2 

$ bf sd.bf
123456
1 2 3 4 5 6 
 3 5 7 9 1 
  8 2 6 0 
   0 8 6 
    8 4 
     2 

$ bf sd.bf
9245322
9 2 4 5 3 2 2 
 1 6 9 8 5 4 
  7 5 7 3 9 
   2 2 0 2 
    4 2 2 
     6 4 
      0 

Erläuterung

Da es ziemlich schwierig ist, den Code aus funktionaler Sicht zu erklären, können wir ihn stattdessen zu verschiedenen Zeiten aus der Perspektive des Bandzustands betrachten. Die Kernidee dabei ist, dass das von uns ausgegebene Dreieck als dicht gepacktes Array (jedenfalls für BF) initialisiert wird, dessen Größe bei jeder Iteration einer Schleife um 1 verringert wird. Ein weiterer wichtiger Gedanke ist, dass wir 255einen "Platzhalter" angeben, nach dem wir auf dem Band suchen können.

Initialisierung

Dies ist der einfachste Schritt. Zu Beginn des Programms führen wir Folgendes aus:

>+>>++++[-<++++++++>]->

Dadurch wird das Band in den folgenden Zustand versetzt (wobei >N<die Position des Zeigers auf dem Band angegeben wird).

[ 0 1 32 255 >0< 0 0 ...]

Die erste Zahl ist hier ein "Puffer" -Standort. Wir werden es nicht langfristig verwenden, aber es ist nützlich, um kleine Operationen zu vereinfachen und Daten zu kopieren.
Die zweite Zahl gibt die Anzahl der Leerzeichen an, die am Anfang jeder Zeile ausgegeben werden, beginnend nach der ersten Zeile. Die erste Zeile enthält keine führenden Leerzeichen.
Die dritte Zahl ist das von uns ausgegebene Leerzeichen.
Die vierte Zahl ist ein Platzhalter 255, so dass wir relativ leicht zu dieser Position zurückkehren können.

Eingang

Von dieser Position aus werden wir alle Zeichen einlesen. Am Ende dieses Schritts hoffen wir, in der folgenden Situation zu sein:

[ 0 1 32 255 a b c d e f ... >255< 0 0 ... ]

Wobei a b c d e f ...die eingegebene numerische Zeichenfolge angibt (nicht die Newline).

Dies erreichen wir mit:

,----------[++++++++++.>>++++++++[-<++++<------>>]<.,----------]-

Das hat einige Nuancen. Zunächst geben wir jedes Zeichen so aus, wie wir es erhalten, und geben danach ein Leerzeichen aus. Zweitens möchten wir den ASCII-Wert nicht auf das Band kopieren, sondern die tatsächliche numerische Ziffer. Drittens möchten wir aufhören, wenn wir eine neue Zeile treffen, und uns zu dieser Zeit an einem guten Ort zurücklassen.
Sagen wir, unser Input ist 6723. Beim ersten Lesen 6sieht unser Band dann so aus:

[ 0 1 32 255 >54< 0 0 ...]

Wir überprüfen, dass dieser Wert nicht gleich 10(eine ASCII-Newline) mit ist ,----------[++++++++++. Wir drucken dann den Wert aus und fahren fort, indem wir gleichzeitig 48 vom Eingabewert subtrahieren und 32 zum Wert daneben addieren ( >>++++++++[-<++++<------>>]<). So bleiben wir hier:

[ 0 1 32 255 6 >32< 0 ...]

Beachten Sie, dass wir während dieses Vorgangs davon ausgehen können, dass alle Ziffern rechts von unserer Eingabe 0 sind. Dies bedeutet, dass wir nicht in Gefahr sind, einen vorherigen Zustand zu ruinieren, wenn wir Werte rechts von 6 * 8und verwenden 4 * 8.
Jetzt geben wir das soeben erzeugte Leerzeichen aus und nehmen eine neue Eingabe vor, wobei wir das dort berechnete Leerzeichen löschen. Schließlich wird die Eingabe durch eine neue Zeile beendet und die Schleife wird beendet, wobei eine Stelle verbleibt, 255an der sich die neue Zeile befunden hätte ( ,----------]-). Dies ist das zweite Platzhalterzeichen, mit dem wir durch das Band navigieren. An diesem Punkt in unserem Szenario ist unser Band genau das:

[ 0 1 32 255 6 7 2 3 >255< 0 0 ... ]

Berechnung

Auf diese Weise wird die Liste der Ziffern zwischen unseren 255Platzhaltern bei jeder Wiederholung der Schleife um eins verkleinert. Wenn nur noch eine Ziffer übrig ist, sind wir fertig und sollten sofort anhalten. (Beachten Sie, dass zu diesem Zeitpunkt jede Ziffer in dieser Liste bereits ausgegeben wurde, sodass wir uns nicht mehr darum kümmern müssen, sie erneut auszugeben.)

Wir verwenden nun diesen Trick navigate auf den ersten 255Platzhalter: <+[-<+]-. Dadurch wird das Band auf der linken Seite effektiv nach a durchsucht 255und nichts dazwischen geändert. Nachdem wir den Zeiger bewegt haben, können wir unsere Ausgangsbedingung überprüfen: Wenn die Liste nur eine Ziffer enthält, wird die Zelle mit den zwei Leerzeichen rechts angezeigt 255. Also prüfen wir das und starten eine Schleife:>>+[-<<

Der erste Schritt in unserer Schleife ist die Ausgabe einer neuen Zeile. Also gehen wir zur ersten Zelle (unserer Pufferzelle), addieren 10 und geben sie aus. Der nächste Schritt ist die Ausgabe aller führenden Leerzeichen. Nach der Ausgabe erhöhen wir unsere Anzahl für die Anzahl der führenden Leerzeichen. Diese Schritte werden folgendermaßen ausgeführt:

-<<<<<++++++++++.[-]>[-<+>>.<]<[->+<]>+>>>

Was uns in diesem Zustand lässt:

[ 0 2 32 255 >6< 7 2 3 255 0 0 0 0 0 0 ]

Der nächste Schritt besteht darin, den ersten Wert in der Liste nach dem zweiten Platzhalter zu kopieren 255:

[[->+]->>+<<<+[-<+]->]

Wir tun dies im Wesentlichen 255, indem wir zwischen unseren Platzhaltern hin und her springen und uns hier zurücklassen:

[ 0 2 32 255 >0< 7 2 3 255 0 6 0 0 ... ]

Wir starten jetzt eine Schleife, die den Rest der Liste durchläuft und anhält, wenn wir Folgendes erreichen 255:>+[-<

Zu diesem Zeitpunkt ist die Ziffer links von uns immer 0. Da wir sie also lieben, fügen wir dort einen Platzhalter 255ein, damit wir zu unserem Platz in der Liste zurückkehren können. Der nächste Schritt besteht darin, den zweiten Platz in der Liste hinter den zweiten Platzhalter zu verschieben 255. Diese Schritte werden folgendermaßen ausgeführt:

->
[[->+]->+>>+<<<<+[-<+]->]

Lassen Sie uns hier: [ 0 2 32 255 255 >0< 2 3 255 7 6 7 0 ] Nun wurden sowohl das 6als 7auch an einen Ort verschoben, an dem die Berechnung erfolgen kann. Wir benötigen zwei Kopien der, 7da die nächste Nummer in der Liste diese ebenfalls benötigt. Das 7unmittelbar nach dem 255dient diesem Zweck, während das andere 7von der Berechnung verbraucht wird.

Zuerst addieren wir die beiden Ziffern:

<+>->+[->+]->>
[->+<]>

Verlassen uns hier:

[ 0 2 32 255 0 255 2 3 255 7 0 >13< 0 ]

Die nächste Kombination von Schritten ist die komplizierteste. Wir müssen sehen, ob die Zahl, auf die wir zeigen, größer als 10 ist, und wenn ja, subtrahieren wir 10. In Wirklichkeit subtrahieren wir 10 davon und sehen, ob es 0an einem beliebigen Punkt der Subtraktion anschlägt. In diesem Fall werden wir 10später darauf zurückkommen. Am Ende sollten wir die Summe modulo 10 haben.

Prepare a 10 to the right
+>++++++++++
Leave yet another 255 for a loop condition later
>>-<<
If the number is greater than 10 end up one space to the left
else one space to the right
[-<-[>>]<]<->
Check if the previous 255 is two spaces to the right and if it is
add 10 back to our sum--we've subtracted too much
>>+[-<<<+>>>[-<->]<+++++++++>>>+]

Zu diesem Zeitpunkt haben wir das Ziel erreicht. Wir haben die Summe Modulo 10! Unabhängig davon, ob die Zahl größer als 10 war oder nicht, landen wir hier:

[ 0 2 32 255 0 255 2 3 255 7 0 3 0 0 >0< ]

Unser nächstes Ziel ist es, diese neue Summe auszugeben, mit einem Leerzeichen zu versehen und sie wieder in unsere Liste aufzunehmen. Wir machen das alles mit unseren bisherigen Techniken des 255-Hoppens und Addierens 48zu unserer Summe, deshalb werde ich nicht im Detail darauf eingehen.

++++++++[-<++++<++++++>>]
<<<[-<<<<+[-<+]-<+>>+[->+]->>>>+<]
>.>.

Und wir sind hier: [ 0 2 32 255 3 255 2 3 255 7 0 0 51 >32< ] Beachten Sie, wie wir nach dem Einfügen einen zusätzlichen 255Platzhalter einfügen, 3damit wir keinen Platz in der Liste verlieren. Zu diesem Zeitpunkt haben wir unsere Summe und ihren Platz ausgegeben, daher müssen wir aufräumen und zu einem Zustand zurückkehren, in dem die nächste Iteration dieser Schleife funktionieren wird. Wir müssen unsere Zellen 51und löschen 32, die eine 7nach rechts bewegen und zu unserem Listenplatzhalter navigieren, damit wir von vorne beginnen können.

[-]<[-]<<<[->+<]<<+[-<+]

Jetzt sind wir hier: [ 0 2 32 255 3 >0< 2 3 255 0 7 0 ... ]
Welches ist genau das, wo wir für unsere nächste Iteration sein wollen. Also nach 255 suchen und weitermachen! ( >+])

Wenn wir von der Schleife genommen werden, haben wir eine ganz neue Liste - bestehend aus den Summen der vorherigen Liste. Das erste Mal sieht es so aus:

 [ 0 2 32 255 3 9 5 0 >0< ]

Jetzt wollen wir diesen ganzen Vorgang auf unserer neuen Liste wiederholen, also werfen wir einen Schritt 255nach links und beginnen von vorne ! Wir müssen ein bisschen aufräumen >>[-]<<und dann unseren Platzhalter mit löschen <-. Danach befinden wir uns genau an der gleichen Stelle wie nach der Eingabe, sodass wir die gleichen Überprüfungen durchführen können:, <+[-<+]->>+und boom! Wir haben unsere volle Schleife! Alles , was wir brauchen , ist der Schließbügel und wann es endet wir haben schon alles ausgeben, so sind wir fertig: ].

Jelly , 20 19 18 Bytes

Ṛ+2\Ṗп%⁵z”@ṚZGḟ”@

Probieren Sie es online!

Hintergrund

Das Generieren der Zahlen ist in Jelly ganz einfach. Die Ausgabe ist etwas komplizierter.

Jelly verfügt über ein eingebautes GGitteratom ( ), das eine 2D-Liste mit Zeilenumbrüchen und Spaltenabständen anzeigt. Wir nehmen das 2D-Array von Zahlen (generiert mit jeder Zeile umgekehrt) und transponieren es mit dem Füllwert @. Wenn Sie das resultierende Array verehren und erneut transponieren, erhalten Sie bei der Anwendung Gdie folgenden Ergebnisse .

9 2 4 5 3 2 2
@ 1 6 9 8 5 4
@ @ 7 5 7 3 9
@ @ @ 2 2 0 2
@ @ @ @ 4 2 2
@ @ @ @ @ 6 4
@ @ @ @ @ @ 0

Um die gewünschte Dreiecksform zu erhalten, müssen wir nur den Füllwert entfernen.

Wie es funktioniert

Ṛ+2\Ṗп%⁵z”@ṚZGḟ”@  Main link. Argument: A (list of integers)

Ṛ                   Reverse A.
    Ṗп             While there's more than one element:
 +2\                  Compute the pairwise sum.
                    Collect all intermediate results in a list.
       %⁵           Take all resulting integers modulo 10.
         z”@        Transpose with fill value '@'.
            Ṛ       Reverse the order of the rows.
             Z      Transpose.
              G     Grid.
               ḟ”@  Filter; remove the fill value.

Pyth - 18 Bytes

j.e+*dkjdbP.ueM+Vt

Test Suite .

j                                       Join by newlines
 .e                                     Loop over seq in var b and index in var k
  +                                     Concatenate
   *dk                                  Space repeated k times
    jdb                                 Join b by spaces
  P                                     [:-1] to get rid of empty line
   .u             (Q implicit)          Cumulative fixed point over input (var G)
    eM                                  Mod 10 mapped over list
     +V                                 Vectorized addition
      t(G implict)                      G[1:]
      (G implict)                       Vectorize cuts this off to G[:-1]

Python 3.5, 74 72 71 Bytes

f=lambda L,*S:f([sum(x)%10for x in zip(L,L[1:print(*S,*L)]or 1)],'',*S)

Die Eingabe ist eine Liste von ganzen Zahlen (z. B. f([1,2,3,5,8])), die Ausgabe erfolgt nach STDOUT. Das %10und die Tatsache, dass mapein mapObjekt in Python 3 zurückgegeben wird, ist ein bisschen ärgerlich, was bedeutet, dass wir es nicht können map(lambda*x:sum(x)%10,L,L[1:])oder ähnliches.

Die Funktion ist fehlerfrei, aber bis dahin wäre die Ausgabe abgeschlossen. Vielen Dank an @xsot für -1 Byte print.

05AB1E , 20 19 17 Bytes

Code:

DvNð×?T%Ððý,¦‚ø€O

Erläuterung:

D                     # Duplicate the input.
 v                    # Map over it, running the following len(input) times.
  Nð×                 # Multiply the iteration number with a space.
     ?                # Pop and print without a newline.
      T%              # Take all integers modulo 10.
        Ð             # Triplicate the array.
         ðý,          # Join by spaces and print with a newline.
            ¦         # Remove the first element of the array.
             ‚        # Wrap it up, (pop a, b push [a, b]).
              ø       # Zip.
               €O     # Sum up each element.

Verwendet die CP-1252- Codierung. Probieren Sie es online! .

MATL, 32 30 29 28 27 26 25 24 Bytes

t"X@qZ"y1X9&VhDTTH&Y+10\

1 Byte gespart dank @Luis

Probieren Sie es online!

Geänderte Version für alle Testfälle

Erläuterung

        % Implicitly grab input
t       % Duplicate the input
"       % For each element of the input (really just a shortcut to loop numel(input) times)
  X@q   % Determine the current loop index and subtract 1
  Z"    % Create an array of blanks this size (these are the padding to the left)
  y     % Copy the current array of numbers from the stack
  1X9   % Get the pre-defined output format of %.15g from the clipboard
  &V    % Convert the input to it's character representation with single spacing
  h     % Horizontally concatenate the left padding and the numbers
  D     % Display the result (consumes the string)
  TT    % Create a two-element vector of 1's ([1 1])
  H&Y+  % Convolve [1 1] with the array (computes the pair-wise sum)
  10\   % Mod 10 the result
        % Implicitly close for loop

Eigentlich 43 Bytes

;l;D+#"{:^%d}"%╗W;' j1╟╜f.;pXZ`i+9u@%`MdXWX

Probieren Sie es online!

Dieses Programm gibt nach der Ausgabe eine einzelne nachgestellte Zeile aus.

Erläuterung:

;l;D+#"{:^%d}"%╗W;' j1╟╜f.;pXZ`i+9u@%`MdXWX
;l;D+                                        calculate the width of the field (2L-1 where L = len(input))
     #"{:^%d}"%╗                             push to a list, make a Python new-style format string for centering text, save in reg0
                W;' j1╟╜f.;pXZ`i+9u@%`MdXW   while the top of the stack is truthy:
                 ;' j1╟                        duplicate list, join with spaces, push string to a list
                       ╜f.                     center string and print  
                          ;pXZ                 zip list with itself shifted forward by 1 (zip(a,a[1:]))
                              `i+9u@%`M        map: add each pair and mod by 10
                                       dX      discard the last value (which was not added with anything)
                                          X  discard the now-empty list after the loop to avoid printing it

Mathematica, 67 Bytes

MatrixForm@NestList[Mod[Total/@Partition[#,2,1],10]&,#,Length@#-1]&

Beispiel:

CJam, 25 Bytes

q~{_2ew::+Af%}h;]eeSff*N*

Probieren Sie es online!

Erläuterung

Dies verwendet einen ziemlich ordentlichen Trick, um das Dreieckslayout zu erzeugen.

q~      e# Read and evaluate input.
{       e# While the list of digits is non-empty...
  _2ew  e#   Duplicate and get all sublists of length 2.
  ::+   e#   Sum each pair.
  Af%   e#   Take each result modulo 10.
}h
;]      e# Discard the final empty list and wrap the others in an array.
ee      e# Enumerate the array. E.g. for input `[7 5 0 9]` we now get this:
        e# [[0 [7 5 0 9]]
        e#  [1 [2 5 9]]
        e#  [2 [7 4]]
        e#  [3 [1]]]
Sff*    e# Perform S* on each element at depth two. For the integers from the
        e# enumeration this gives a string of that many spaces, i.e. the correct
        e# indentation. For the lists of digits this inserts a space character
        e# between every two digits, thereby spacing out the digits as necessary.
N*      e# Put linefeeds between the pairs of indentation and digit list.

JavaScript (ES6) 147 Byte

a=>{o=0;e=(c=>console.log(' '.repeat(o++)+c.join` `));l=1;while(l){p=0,d=[],e(a),a.map(b=>{p?d.push((v+b)%10):0;p=1,v=b});d.length<2?l=0:a=d};e(d)}

Julia, 60 59 Bytes

\(x,s="")=x==[]?"":s*join(x," ")"
"*(diag(x'.+x,1)%10\" "s)

Basierend auf der Antwort von @ Sp3000 . Die Funktion \akzeptiert ein Array als Eingabe und gibt eine Zeichenfolge zurück.

Probieren Sie es online!

Pyke, 21 Bytes

lVDm}R$],FsT%)od*pKDP

Probieren Sie es hier aus!

Ich würde gerne denken, dass diese Methode ein bisschen anders ist.

[1, 2, 3, 5, 8] - take the input
[2, 4, 6, 10, 16] - double it
[1, 2, 3, 5, 8] - take the input again
[1, 1, 2, 3] - get the deltas
[[2,1], [4,1], [6,2], [10,3]] - transpose them together
[3, 5, 8, 13] - apply addition
[3, 5, 8, 3] - mod 10

Perl 6 ,  65 63 62  61 Bytes

{put ' 'x my$++,$_ for @_,{.rotor(2=>-1).map(*.sum%10).list}...1}
{put ' 'x my$++,$_ for @_,{@(.rotor(2=>-1).map(*.sum%10))}...1}
{put ' 'x my$++,$_ for @_,{@(map *.sum%10,.rotor(2=>-1))}...1}
{put ' 'x my$++,$_ for @_,{[map *.sum%10,.rotor(2=>-1)]}...1}

Erläuterung:

{ # anonymous block that takes the list as input (@_)

  put # print with trailing newline

    ' ' x ( my $ )++, # pad with one more space than previous iteration
    $_                   # the list to print for this iteration
    # The ｢.Str｣ method on a List puts spaces between elements
    # which is what ｢put｣ calls on anything that isn't a Str

  for # do that for every list produced from the following

    @_, # the input list

    { # anonymous block that takes the previous list as input ($_)

      [ # turn the following from a Seq into an Array

        map
          *.sum % 10, # sum the values and modulus 10 of the following:

          # take the previous list 2 at a time, backing up one
          $_.rotor( 2 => -1 )

      ]

    }

    ... # repeatedly call that block until:

    1   # the result is only one element long
}

Beispiel:

my &digital-triangle-sum = {put ' 'x my$++,$_ for @_,{[map *.sum%10,.rotor(2=>-1)]}...1}

for [7,5,0,9], [0,1,0], [1,0,0,0], [9,2,4,5,3,2,2] -> \List {
   digital-triangle-sum List

   put '';
}

7 5 0 9
 2 5 9
  7 4
   1

0 1 0
 1 1
  2

1 0 0 0
 1 0 0
  1 0
   1

9 2 4 5 3 2 2
 1 6 9 8 5 4
  7 5 7 3 9
   2 2 0 2
    4 2 2
     6 4
      0

TSQL, 198, 194 191 Bytes

Durch die Verwendung von GOTO anstelle von WHILE konnte ich 3 Charaktere spielen

Golf gespielt

DECLARE @ varchar(100)= '1 2 3 4 5 6 7'

DECLARE @j INT=1,@i INT=LEN(@)a:
PRINT @
WHILE @i>@j
SELECT
@=STUFF(@,@i-1,2,RIGHT(SUBSTRING(@,@i-2,1)+SUBSTRING(@,@i,1)*1,1)+' '),@i-=2SELECT
@=STUFF(@,@j,1,' '),@j+=1,@i=LEN(@)IF @i>0GOTO a

Probieren Sie es online aus (mit altem Skript mit 2 * WHILE)

Java 7, 230 215 213 Bytes

int c=0;void m(int[]a){int l=a.length,j=-1,i=-1;if(l<1)return;int[]x=new int[l-1];while(++j<c)p(" ");for(;++i<l;p(a[i]+" "))if(i<l&i>0)x[i-1]=(a[i-1]+a[i])%10;p("\n");c++;m(x);}<T>void p(T s){System.out.print(s);}

Dies endete ein bisschen länger als ich dachte. Vielleicht kann es ein bisschen mehr golfen werden, da ich ein bisschen durcheinander bin, denke ich.

Einige Bytes gespeichert dank @GiacomoGarabello gespeichert .

Ungolfed & Testcode:

Probieren Sie es hier aus.

class Main{
  static int c = 0;

  static void m(int[] a){
    int l = a.length,
        j = -1,
        i = -1;
    if(l < 1){
      return;
    }
    int[] x = new int[l-1];
    while(++j < c){
      p(" ");
    }
    for(; ++i < l; p(a[i] + " ")){
      if(i < l & i > 0){
        x[i - 1] = (a[i - 1] + a[i]) % 10;
      }
    }
    p("\n");
    c++;
    m(x);
  }

  static <T> void p(T s){
    System.out.print(s);
  }

  static void printAndReset(int[] a){
    m(a);
    c = 0;
    System.out.println();
  }

  public static void main(String[] a){
    printAndReset(new int[]{ 7, 5, 0, 9 });
    printAndReset(new int[]{ 0 });
    printAndReset(new int[]{ 1, 2 });
    printAndReset(new int[]{ 8, 7 });
    printAndReset(new int[]{ 0, 0 });
    printAndReset(new int[]{ 1, 4, 2 });
    printAndReset(new int[]{ 0, 1, 0 });
    printAndReset(new int[]{ 1, 0, 0, 0 });
    printAndReset(new int[]{ 1, 2, 3, 4 });
    printAndReset(new int[]{ 1, 2, 3, 5, 8 });
    printAndReset(new int[]{ 9, 2, 4, 5, 3, 2, 2 });
  }
}

Ausgabe:

7 5 0 9 
 2 5 9 
  7 4 
   1 

0 

1 2 
 3 

8 7 
 5 

0 0 
 0 

1 4 2 
 5 6 
  1 

0 1 0 
 1 1 
  2 

1 0 0 0 
 1 0 0 
  1 0 
   1 

1 2 3 4 
 3 5 7 
  8 2 
   0 

1 2 3 5 8 
 3 5 8 3 
  8 3 1 
   1 4 
    5 

9 2 4 5 3 2 2 
 1 6 9 8 5 4 
  7 5 7 3 9 
   2 2 0 2 
    4 2 2 
     6 4 
      0 

C # 6, 125 + 31 125 + 18 = 143 Bytes

string f(int[] n,string s="")=>s+string.Join(" ",n)+"\n"+(n.Length>1?f(n.Zip(n.Skip(1),(a,b)=>(a+b)%10).ToArray(),s+" "):"");

Die +18 ist für using System.Linq;

Vielen Dank an @TheLethalCoder für die Einsparung von 13 Bytes, indem auf eine unnötige using-Anweisung hingewiesen wird

JavaScript (ES6), 77 Byte

a=a.map((_,i)=>(b=a,a=[a.map((e,j)=>j>i?(e+a[j-1])%10:''),b.join` `)).join`
`

C 138 Bytes

Golf gespielt

c,d;main(int a,char**b){b++;while(c++,d=0,--a)while(d<a)printf("%*c%c",!d?c:1,*b[d],(d+2>a)*10),++d<a?*b[d-1]=(*b[d-1]+*b[d]-96)%10+48:0;}

Ungolfed

c,d;
main(int a,char**b){
b++;
while(c++,d=0,--a)
    while(d<a)
        printf("%*c%c",
          !d?c:1,      //number of blanks in front of digit
          *b[d],       //digit
          (d+2>a)*10), //returns 10(new line) only for d+1 == a
        ++d<a
          ? *b[d-1]=(*b[d-1]+*b[d]-96)%10+48 //update digit 
          :  0;
}

C #, 167 Bytes

Ich bin eigentlich ziemlich stolz auf diese Lösung, Lambda-Ausdrücke machen so viel Spaß, wenn man sie erst einmal verstanden hat

void f(List<int> a){int x=a.Count;for(int s=0;s<x;s++){Console.WriteLine(new String(' ',s)+string.Join(" ",a));a=a.Take(x-s-1).Select((v,i)=>(a[i+1]+v)%10).ToList();}}

Hier ungolfed für weitere Verbesserungen:

void f(List<int> a)
{
int x = a.Count;
for (int s = 0; s<x ;s++)
{
    Console.WriteLine(new String(' ',s)+string.Join(" ",a));
    a=a.Take(x-s-1).Select((v,i)=>(a[i+1]+v)%10).ToList();
}
}

Probieren Sie es hier aus

Haskell, 139 Bytes

f=mapM(\(r,s)->putStrLn$r++(s>>=(++" ").show)).zip(iterate(' ':)"").takeWhile(/=[]).iterate g where g(_:[])=[];g(y:p:ys)=mod(y+p)10:g(p:ys)

Nimmt Eingaben als Argument und gibt sie an STDOUT aus.

Ungolfed-Version:

f = mapM (\(r, s) -> putStrLn $ r ++ (s >>= (++ " ") . show))
    . zip (iterate (' ' :) "")
    . takeWhile (/= [])
    . iterate sumTerms
    where sumTerms (_:[]) = []
          sumTerms (y:p:ys) = mod (y+p) 10 : sumTerms (p:ys)

Python 3, 97 Bytes

def f(x):print(*x);x[-1]==''or f(['']+[(x[i]+x[i+1])%10if''!=x[i]else''for i in range(len(x)-1)])

Gibt eine einzelne nachgestellte Zeile aus.

Wie es funktioniert

def f(x):                            function with input of list of numbers
print(*x)                            print the old line of the triangle
x[-1]==''or...                       if no more numbers, stop...
(x[i]+x[i+1])%10if''!=x[i]else''...  ...else compute the next entry in the new line if
                                     possible...
...for i in range(len(x)-1)          ...for all relevant digit pairs...
['']+...                             ...concatenate with empty string to force new leading
                                     space...
f(...)                               ...and pass to function

Probieren Sie es auf Ideone

J, 44 Bytes

(#\.-#)|."_1#\.(":@{."_1)2(10|+/)\^:(]i.@#)]

Basierend auf dieser Lösung .

Javascript (mit externer Bibliothek) (198 Bytes)

n=>{a=_.From(n);b=a.Write(" ");c=1;while(++c){a=a.BatchAccumulate(2).Where(y=>y.Count()==2).Select(z=>z.Sum()%10);if(a.Count()==0){break;}b+="\r\n"+_.Range(0,c).Write(" ",x=>"")+a.Write(" ")}return b}

Link zu lib: https://github.com/mvegh1/Enumerable/

Code Erklärung: Dies war einfach mit der Bibliothek! Gewinnt nicht in Bytes, aber der Code ist nicht zu ausführlich und leicht zu lesen. Die Eingabe "n" ist also ein Array von Ganzzahlen. Laden Sie sie in die Bibliothek, gespeichert in der Variablen "a". "B" ist die Rückgabezeichenfolge. Speichern Sie die verknüpfte Zeichenfolge mit "" als Trennzeichen in b. C ist die Aktuelle Iteration: Verwenden Sie diese Option, um die Anzahl der einzufügenden Leerzeichen zu bestimmen. HINWEIS: Dies scheint nur dann gut zu funktionieren, wenn die Eingabe von 0 bis 9 erfolgt. Wiederholen Sie dann, während true, einen bestimmten Satz von Code Mengen der aktuellen Aufzählung "a", dh wenn wir [1,2,3,4,5,6] haben, erhalten wir [1,2], [2,3], [3,4], ... [ 6] ... dann filtern wir das so, dass wir nur die Chargen der Größe 2 haben. Dann ordnen wir das einer Sammlung der Summen der Chargen% 10 zu. Wenn a leer ist, sind wir fertig, Ansonsten fügen wir die neue Zeile unserer Rückkehr hinzu. Endlich zurück ...

Bild kommt in ein paar min.