[Question]
  [
Well, sum it down really.
Write a program or function that takes in a nonempty list of decimal integers (0-9) and outputs a downward pointing "triangle" of digits with the input list at the top where every digit after the first line is the sum of the two digits above it modulo 10.
For example, the input `[7, 5, 0, 9]` has output
```
7 5 0 9
 2 5 9
  7 4
   1
```
because `2` is `(7 + 5) mod 10`, `5` is `(5 + 0) mod 10`, `9` is `(0 + 9) mod 10`, etc. all the way to `1` being `(7 + 4) mod 10`.
If the list has only one item, then the output matches the input; e.g. an input of `[4]` will yield
```
4
```
Here are some additional examples:
```
[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
```
Note that in the output:
* The first line does not have leading spaces.
* Each subsequent line has one more leading space than the line previous.
* Digits are separated by a single space.
* Each line is allowed to have up to one trailing space.
* There may be a single optional trailing newline.
* You must use the characters for normal decimal digits (0 through 9).
**The shortest code in bytes wins. Tiebreaker is earlier answer.**
  
[Answer]
# BrainF\*\*k, ~~396~~ 391 bytes
```
>+>>++++[-<++++++++>]->,----------[++++++++++.>>++++++++[-<++++<------>>]<.,----------]-<+[-<+]->>+[-<<<<<++++++++++.[-]>[-<+>>.<]<[->+<]>+>>>[[->+]->>+<<<+[-<+]->]>+[-<->[[->+]->+>>+<<<<+[-<+]->]<+>->+[->+]->>[->+<]>+>++++++++++>>-<<[-<-[>>]<]<->>>+[-<<<+>>>[-<->]<+++++++++>>>+]++++++++[-<++++<++++++>>]<<<[-<<<<+[-<+]-<+>>+[->+]->>>>+<]>.>.[-]<[-]<<<[->+<]<<+[-<+]>+]>>[-]<<<-<+[-<+]->>+]
```
I couldn't resist the temptation to do this one. At least the triangle is pointy-side down.
Input comes in as a string of numeric characters followed by a single newline.
Output will contain a single trailing space on every line.
Examples:
```
$ 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 
```
## Explanation
Since it's rather difficult to explain the code from a functional perspective, we can instead look at it from the perspective of the state of the tape at various times. The core idea here is that the triangle we output is initialized as a tightly-packed (for BF, anyway) array that shrinks in size by 1 every iteration of a loop. Another important thought is that we use `255` to indicate a "placeholder" that we can search for on the tape.
### Initialization
This is the easiest step. At the start of the program, we execute the following:
```
>+>>++++[-<++++++++>]->
```
This forces the tape into the following state (where `>N<` indicates the location of the pointer on the tape)
```
[ 0 1 32 255 >0< 0 0 ...]
```
The first number here is a "buffer" location. We're not going to use it on a long-term basis, but it's useful to make little operations simpler and for copying data around.  
The second number is the number of spaces that we'll be outputting at the start of each line, starting *after* the first line. The first line will have no leading spaces.  
The third number is the space character we output.  
The fourth number is a placeholder 255, so that we can get back to this position relatively easily. 
### Input
From this position, we will read in all of the characters. At the end of this step, we hope to be in the following situation:
```
[ 0 1 32 255 a b c d e f ... >255< 0 0 ... ]
```
Where `a b c d e f ...` indicates the string of numeric characters that was input (not the newline).
We accomplish this with the following:
```
,----------[++++++++++.>>++++++++[-<++++<------>>]<.,----------]-
```
There are some nuances to this. First of all, we will output each character as we get them, and then output a space after it. Secondly, we don't want to copy the ASCII value to the tape, we want to copy the actual numeric digit. Third, we want to stop when we hit a newline and leave ourselves in a good place at that time.  
Say our input is `6723`. Then, upon reading the first `6`, our tape looks like this:
```
[ 0 1 32 255 >54< 0 0 ...]
```
We check that this value is not equal to `10` (an ASCII newline) with `,----------[++++++++++`. We then print out the value and continue by simultaneously subtracting 48 from the input value and adding 32 to the value next to it (`>>++++++++[-<++++<------>>]<`), leaving us here:
```
[ 0 1 32 255 6 >32< 0 ...]
```
Notice how throughout this process we can assume that all digits to the right of our input are 0--this means that we're not in danger of ruining any previous state if we use values to the right to calculate `6 * 8` and `4 * 8`.  
Now we output the space character we just generated, and take in a new input, deleting the space we calculated there. Eventually, the input will be terminated by a new line and the loop will exit, leaving a `255` where the newline would have been (`,----------]-`). This is the second placeholder character we will use to navigate the tape. At this point in our scenario, our tape is exactly this:
```
[ 0 1 32 255 6 7 2 3 >255< 0 0 ... ]
```
### Calculation
The way this works is that the list of digits between our `255` placeholders is going to shrink by one every iteration of the loop. When it only has 1 digit left in it, we're done and should halt immediately (Note that, at this point, every digit in that list has already been output, so we don't have to worry about outputting it again).
We now use this trick to navigate to the first `255` placeholder: `<+[-<+]-`. This effectively searches the tape to the left for a `255`, changing nothing in between. Now that we've moved the pointer, we can check our exit condition: if there's only one digit in the list, then the cell two spaces to the right will hold `255`. Thus, we check against that and start a loop: `>>+[-<<`
The first step in our loop is to output a newline. So we move to the first cell (our buffer cell), add 10 to it and output. The next step is to output all leading space characters. After outputting them, we increment our count for number of leading spaces. These steps are accomplished by the following:
```
-<<<<<++++++++++.[-]>[-<+>>.<]<[->+<]>+>>>
```
Which leaves us in this state:
```
[ 0 2 32 255 >6< 7 2 3 255 0 0 0 0 0 0 ]
```
Our next step is to copy the first value in the list over, past the second placeholder `255`:
```
[[->+]->>+<<<+[-<+]->]
```
We essentially do this by hopping back and forth between our placeholder `255`s, leaving us here:
```
[ 0 2 32 255 >0< 7 2 3 255 0 6 0 0 ... ]
```
We now start a loop, iterating through the rest of the list, stopping when we hit `255` : `>+[-<`
At this point, the digit to our immediate left is always 0. So, because we love them, we pop a placeholder `255` in there so that we can come back to our place in the list. The next step is to move the second place in the list to locations surrounding where we moved the first place to, past the second placeholder `255`. These steps are accomplished by the following:
```
->
[[->+]->+>>+<<<<+[-<+]->]
```
Leaving us here: `[ 0 2 32 255 255 >0< 2 3 255 7 6 7 0 ]`
Now, both the `6` and `7` have been moved to a location where the calculation can occur. We need two copies of the `7` because the next number in the list will need it as well. The `7` immediately after the `255` serves this purpose, whereas the other `7` will be consumed by the calculation.
First, we add the two digits: 
```
<+>->+[->+]->>
[->+<]>
```
Leaving us here:
```
[ 0 2 32 255 0 255 2 3 255 7 0 >13< 0 ]
```
The next combination of steps is the most complicated. We need to see if the number we're pointing to is larger than 10, and if it is, we subtract `10`. In reality, what we do is we subtract 10 from it and see if it hits `0` at any point in the subtraction. If it does, we add `10` back on later. At the end of this, we should have the sum modulo 10.
```
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
>>+[-<<<+>>>[-<->]<+++++++++>>>+]
```
At this point, we've accomplished the goal. We have the sum modulo 10!
Also, whether or not the number was greater than 10, we'll end up here:
```
[ 0 2 32 255 0 255 2 3 255 7 0 3 0 0 >0< ]
```
Our next goals are to output this new sum, follow it with a space, and inject it back into our list. We do this all with our previous techniques of `255`-hopping and adding `48` to our sum, so I won't cover it in detail.
```
++++++++[-<++++<++++++>>]
<<<[-<<<<+[-<+]-<+>>+[->+]->>>>+<]
>.>.
```
And we're here: `[ 0 2 32 255 3 255 2 3 255 7 0 0 51 >32< ]`
Notice how we put an additional `255` placeholder after our newly-injected `3` so that we don't lose place in the list. At this point, we have output our sum and its space, so we need to clean up and revert to a state where the next iteration of this loop is going to work. We need to clear out our `51` and `32` cells, move the `7` once to the right, and navigate to our list placeholder so that we can start over.
```
[-]<[-]<<<[->+<]<<+[-<+]
```
Now, we're here: `[ 0 2 32 255 3 >0< 2 3 255 0 7 0 ... ]`  
Which is exactly where we want to be for our next iteration. So check for 255 and move on! (`>+]`)
When we get dropped off from the loop, we're going to have a whole new list--made up of the sums from the previous list. The first time, it'll look like this:
```
 [ 0 2 32 255 3 9 5 0 >0< ]
```
Now we want to repeat that whole process on our new list, so we plop a `255` down to the left and start all over! We need to do a little bit of cleanup with `>>[-]<<`, and then drop our placeholder with `<-`. After that, we're in exactly the same place as we were after input, so we can get away with doing the same checks: `<+[-<+]->>+`, and boom! We've got our full loop! All we need is the closing bracket, and when it ends we've already output everything, so we're done: `]`.
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), ~~20~~ ~~19~~ 18 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
Ṛ+2\ṖÐ¿%⁵z”@ṚZGḟ”@
```
[Try it online!](http://jelly.tryitonline.net/#code=4bmaKzJc4bmWw5DCvyXigbV64oCdQOG5mlpH4bif4oCdQA&input=&args=WzksIDIsIDQsIDUsIDMsIDIsIDJd)
### Background
Generating the numbers is straightforward in Jelly. The output is a bit more complicated.
Jelly has a built-in grid atom (`G`) that displays a 2D list with newlines between rows and spaces between columns. We take the 2D array of numbers (generated with each row reversed), and transpose it with fill value `@`. After revering the resulting array and transposing again, applying `G` yield the following.
```
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
```
To obtain the desired triangular shape, all we have to do is remove the fill value.
### How it works
```
Ṛ+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.
```
[Answer]
# Pyth - 18 bytes
```
j.e+*dkjdbP.ueM+Vt
```
[Test Suite](http://pyth.herokuapp.com/?code=j.e%2B%2adkjdbP.ueM%2BVt&test_suite=1&test_suite_input=%5B7%2C+5%2C+0%2C+9%5D%0A%5B4%5D%0A%5B0%5D%0A%5B1%2C+2%5D%0A%5B8%2C+7%5D%0A%5B0%2C+0%5D%0A%5B1%2C+4%2C+2%5D%0A%5B0%2C+1%2C+0%5D%0A%5B1%2C+0%2C+0%2C+0%5D%0A%5B1%2C+2%2C+3%2C+4%5D%0A%5B1%2C+2%2C+3%2C+5%2C+8%5D%0A%5B9%2C+2%2C+4%2C+5%2C+3%2C+2%2C+2%5D&debug=0).
```
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]
```
[Answer]
## 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)
```
Input is a list of integers (e.g. `f([1,2,3,5,8])`), output is to STDOUT. The `%10` and the fact that `map` returns a `map` object in Python 3 is a bit annoying, meaning we can't do `map(lambda*x:sum(x)%10,L,L[1:])` or similar.
The function errors out, but by then the output would have completed. Thanks to @xsot for -1 byte by finding a good place to stick the `print`.
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), ~~20~~ ~~19~~ 17 bytes
Code:
```
DvNð×?T%Ððý,¦‚ø€O
```
Explanation:
```
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.
```
Uses the **CP-1252** encoding. [Try it online!](http://05ab1e.tryitonline.net/#code=RHZOw7DDlz9UJcOQw7DDvSzCpuKAmsO44oKsTw&input=WzksIDIsIDQsIDUsIDMsIDIsIDJd).
[Answer]
# MATL, ~~32~~ ~~30~~ ~~29~~ ~~28~~ ~~27~~ ~~26~~ ~~25~~ 24 bytes
```
t"X@qZ"y1X9&VhDTTH&Y+10\
```
*1 Byte saved thanks to @Luis*
[**Try it Online!**](http://matl.tryitonline.net/#code=dCJYQHFaInkxWDkmVmhEVFRIJlkrMTBc&input=WzksIDIsIDQsIDUsIDMsIDIsIDJd)
[Modified version for all test cases](http://matl.tryitonline.net/#code=YGl0IlhAcVoieTFYOSZWaERUVEgmWSsxMFxdJyAnRFQ&input=WzBdClsxLCAyXQpbOCwgN10KWzAsIDBdClsxLCA0LCAyXQpbMCwgMSwgMF0KWzEsIDAsIDAsIDBdClsxLCAyLCAzLCA0XQpbMSwgMiwgMywgNSwgOF0KWzksIDIsIDQsIDUsIDMsIDIsIDJd)
**Explanation**
```
        % 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
```
[Answer]
## Actually, 43 bytes
```
;l;D+#"{:^%d}"%╗W;' j1╟╜f.;pXZ`i+9u@%`MdXWX
```
[Try it online!](http://actually.tryitonline.net/#code=O2w7RCsjIns6XiVkfSIl4pWXVzsnIGox4pWf4pWcZi47cFhaYGkrOXVAJWBNZFhXWA&input=Nyw1LDAsOQ)
This program prints a single trailing newline after the output.
Explanation:
```
;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
```
[Answer]
# Mathematica, 67 Bytes
```
MatrixForm@NestList[Mod[Total/@Partition[#,2,1],10]&,#,Length@#-1]&
```
Example:[![enter image description here](https://i.stack.imgur.com/IR3sg.png)](https://i.stack.imgur.com/IR3sg.png)
[Answer]
## CJam, 25 bytes
```
q~{_2ew::+Af%}h;]eeSff*N*
```
[Try it online!](http://cjam.tryitonline.net/#code=cX57XzJldzo6K0FmJX1oO11lZVNmZipOKg&input=WzcgNSAwIDld)
### Explanation
This uses a fairly neat trick to generate the triangle layout.
```
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.
```
[Answer]
# [Haskell](https://www.haskell.org/), 88 bytes
```
f=mapM putStrLn.(""%)
s%x@(_:y)=(s++(x>>=(:" ").last.show)):(' ':s)%zipWith(+)x y
_%_=[]
```
[Try it online!](https://tio.run/##BcHBCsIgGADg@57iR5D9P4p0iUhw9AB16tBhDPHQUHKbpJHr5e37vMuvZ4ytzWZx6QbpU@7lfV0VMsapy7xe0OqdDGYhsA6DQc2AkYouF5X99iXS2EOvM/FfSI9QPAqqsHeWWzNObXFhBQMzjCd5lAd5ntof "Haskell – Try It Online")
I chose the same I/O format and counted `f=` to compete fairly with the other Haskell answer.
Replacing the first line by just `(""%)` would give a 72-byte answer that returns a list of lines.
Instead of writing `show.(`mod`10)` or `[mod(a+b)10|(a,b)<-zip x y]`, it turns out to be shorter to use `last` on the result of `show`, which is kinda cute.
[Answer]
# JavaScript (ES6) 147 bytes
```
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)}
```
[Answer]
# Julia, ~~60~~ 59 bytes
```
\(x,s="")=x==[]?"":s*join(x," ")"
"*(diag(x'.+x,1)%10\" "s)
```
Based on [@Sp3000's answer](https://codegolf.stackexchange.com/a/82533). The function `\` accepts an array as input and returns a string.
[Try it online!](http://julia.tryitonline.net/#code=XCh4LHM9IiIpPXg9PVtdPyIiOnMqam9pbih4LCIgIikiCiIqKGRpYWcoeCcuK3gsMSklMTBcIiAicykKCnByaW50KFwoWzksIDIsIDQsIDUsIDMsIDIsIDJdKSk&input=)
[Answer]
## JavaScript (ES6), 77 bytes
```
a=a.map((_,i)=>(b=a,a=[a.map((e,j)=>j>i?(e+a[j-1])%10:''),b.join` `)).join`
`
```
[Answer]
## Pyke, 21 bytes
```
lVDm}R$],FsT%)od*pKDP
```
[Try it here!](http://pyke.catbus.co.uk/?code=lVDm%7DR%24%5D%2CFsT%25%29od%2apKDP&input=%5B1%2C+2%2C+3%2C+5%2C+8%5D)
I'd like to think this method's a little bit different.
```
[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
```
[Answer]
# [Perl 6](http://perl6.org), ~~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}
```
### Explanation:
```
{ # 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
}
```
### Example:
```
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
```
[Answer]
# TSQL, ~~198~~ ~~194~~ 191 bytes
By using GOTO instead of one of the WHILE, I was able to golf 3 characters
Golfed
```
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
```
[Try it online](https://data.stackexchange.com/stackoverflow/query/499842/sum-it-up-with-a-digital-triangle)(using old script with 2\*WHILE)
[Answer]
# 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);}
```
This ended up being a bit longer than I thought.. Maybe it can be golfed a bit more though, since I kinda messed up I think..
Some bytes saved thanks to *@GiacomoGarabello*.
**Ungolfed & test code:**
[Try it here.](https://ideone.com/saafcs)
```
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 });
  }
}
```
**Output:**
```
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 
```
[Answer]
# 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+" "):"");
```
The +18 is for `using System.Linq;`
*Thanks to @TheLethalCoder for saving 13 bytes, by pointing out a unnecessary using statement*
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 11 bytes
A translation of [Adnan's answer](https://codegolf.stackexchange.com/a/82531/64121) to modern 05AB1E.
```
vT%DðýNú,ü+
```
[Try it online!](https://tio.run/##yy9OTMpM/f@/LETV5fCGw3v9Du/SObxH@///aHMdBVMdBQMdBctYAA "05AB1E – Try It Online")
`ú` pads a string with a given number of spaces and `ü` applies a binary function between pairs of adjacent items.
[Answer]
# [PowerShell Core](https://github.com/PowerShell/PowerShell), ~~99~~ 69 bytes
```
($a=$args)|%{"$s$a"
$a=$a|%{($p+$_)%10;$p=$_}|select -skip 1
$s+=" "}
```
[Try it online!](https://tio.run/##NYpBCoMwFAX3OcUnPItihGrtopRAz9ALSJDYSgMJ@YILzdnTInQ3M0zwq438ts41o482Y9JbLmE0THxxtRebBMNIcaSflgg1hqpoz3cEjSHtbJ0dF2r4MwdqBbjWkmTKSQhMc@Tl6VfSdFPUKeoVXRVdDu7ECRM9/k/@Ag "PowerShell Core – Try It Online")
*-99 bytes thanks to [@mazzy](https://codegolf.stackexchange.com/users/80745/mazzy) !*
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 14 bytes
```
SƝƬ%⁵µ⁶oṚżK€ṖY
```
[Try it online!](https://tio.run/##ATIAzf9qZWxsef//U8adxqwl4oG1wrXigbZv4bmaxbxL4oKs4bmWWf///1s3LCA1LCAwLCA5XQ "Jelly – Try It Online")
Full program which prints the result
## How it works
```
SƝƬ%⁵µ⁶oṚżK€ṖY - Main link. Takes a list L on the left
  Ƭ            - Until reaching a fixed point:
S              -   Take the sum of:
 Ɲ             -     All overlapping pairs
   %⁵          - Mod each by 10
     µ         - Begin a new link with the list of steps as the argument:
      ⁶o       - Replace all elements with spaces
        Ṛ      - Reverse
          K€   - Join each list with spaces
         ż     - Zip together
            Ṗ  - Remove the last line of spaces
             Y - Join on newlines
```
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal) `C`, 10 bytes
```
λḢ+Ṫ₀%;↔vṄ
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=C&code=%CE%BB%E1%B8%A2%2B%E1%B9%AA%E2%82%80%25%3B%E2%86%94v%E1%B9%84&inputs=%5B9%2C%202%2C%204%2C%205%2C%203%2C%202%2C%202%5D&header=&footer=)
```
λ     ;    # Push a lambda
 Ḣ         # Remove first  item
  +        # Vectorised addition to original
   Ṫ       # Remove last item
    ₀%     # For each item, modulo 10
       ↔   # Repeat on input while output is truthy
        vṄ # Foreach, join by spaces
           # (C flag) Center and join by newlines.
```
-6 thanks to Aaron Miller.
Old version, 16 bytes:
```
L(ðn*₴DṄ,0p+vtḢṪ
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=L%28%C3%B0n*%E2%82%B4D%E1%B9%84%2C0p%2Bvt%E1%B8%A2%E1%B9%AA&inputs=%5B9%2C%202%2C%204%2C%205%2C%203%2C%202%2C%202%5D&header=&footer=)
```
L(               # Length times
  ðn*            # (iteration number) spaces
     ₴           # Output without a newline
      D          # Triple current array
       Ṅ,        # Output first joined by spaces
         0p      # Prepend a 0 to the second
           +     # Vectorised addition
            vt   # Foreach, get last digit
              ḢṪ # And get rid of first + last items
```
[Answer]
## C, 138 bytes
Golfed
```
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;
}
```
[Answer]
## C#, 167 bytes
Im actually pretty proud of this solution, lambda expressions are so fun once you get the hang of them
```
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();}}
```
here ungolfed for further improvements:
```
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();
}
}
```
[try it out here](http://rextester.com/XJM57878)
[Answer]
# 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)
```
Takes input as an argument, outputs to STDOUT.
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)
```
[Answer]
# 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)])
```
Prints a single trailing newline.
**How it works**
```
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
```
[Try it on Ideone](https://ideone.com/Uk230L)
[Answer]
# J, 44 bytes
```
(#\.-#)|."_1#\.(":@{."_1)2(10|+/)\^:(]i.@#)]
```
Based on this [solution](https://codegolf.stackexchange.com/a/85758/6710).
[Answer]
## Javascript (using external library) (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 to lib: <https://github.com/mvegh1/Enumerable/>
Code explanation: This was easy using the library! Doesn't win in bytes, but the code isn't too verbose and easy to read. So, the input "n' is an array of integers. Load it up into the library, stored in variable "a". "b" is the return string, store the joined string with " " as delimiter into b. c is the current iteration, use this to determine the number of spaces to insert. NOTE: This only seems to work nicely when the input is from 0-9. Then, while true, repeat a certain set of code. That code is to create adjacent batch sets of the current enumerable "a", i.e if we have [1,2,3,4,5,6] we get [1,2],[2,3],[3,4],...[6] ... then filter that so we only have the batches of size 2. Then we map that to a collection of the sums of the batches % 10. If a is empty, we are done, else we add the new line to our return. Finally return...
Picture coming in a few min.
[![enter image description here](https://i.stack.imgur.com/xCdSp.png)](https://i.stack.imgur.com/xCdSp.png)
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-R`](https://codegolf.meta.stackexchange.com/a/14339/), 16 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
_ä+ muA}hUÊN m¸û
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVI&code=X%2bQrIG11QX1oVcpOIG24%2bw&input=WzcsIDUsIDAsIDld)
```
_ä+ m%A}hNUÊ m¸û     :Implicit input of array U
_                    :Function taking an array as input
 ä                   :  Consecutive pairs
  +                  :  Reduced by addition
    m                :  Map
     %A              :    Mod 10
       }             :End function
        h            :Run that function
         N           :  Taking the last element of the array of all inputs, and pushing the results to it
          UÊ         :  Until it's length matches the length of U
             m       :Map the final N
              ¸      :   Join with spaces
               û     :Centre pad each with spaces to the length of the longest
                     :Implicit out put joined with newlines
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 14 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
üε↕Φ¬ⁿ╣VU6Co'm
```
[Run and debug it](https://staxlang.xyz/#p=81ee12e8aafcb9565536436f276d&i=%5B7,+5,+0,+9%5D&m=2)
]