Cóż, podsumuj to naprawdę.

Napisz program lub funkcję, która pobierze niepustą listę liczb całkowitych dziesiętnych (0–9) i wyświetli skierowany w dół „trójkąt” cyfr z listą wprowadzania na górze, gdzie każda cyfra po pierwszym wierszu jest sumą dwóch cyfr powyżej to modulo 10.

Na przykład wejście [7, 5, 0, 9]ma dane wyjściowe

7 5 0 9
 2 5 9
  7 4
   1

ponieważ 2jest (7 + 5) mod 10, 5jest (5 + 0) mod 10, 9jest (0 + 9) mod 10itd. przez całą drogę do 1istnienia (7 + 4) mod 10.

Jeśli lista zawiera tylko jeden element, wówczas dane wyjściowe są zgodne z danymi wejściowymi; np. wkład [4]woli da

4

Oto kilka dodatkowych przykładów:

[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

Zauważ, że na wyjściu:

• Pierwszy wiersz nie ma spacji wiodących.
• Każda kolejna linia ma jeszcze jedną spację wiodącą niż poprzednia linia.
• Cyfry są oddzielone pojedynczym odstępem.
• Każda linia może mieć maksymalnie jedno końcowe miejsce.
• Może występować pojedynczy opcjonalny znak nowej linii.
• Musisz używać znaków dla normalnych cyfr dziesiętnych (od 0 do 9).

Najkrótszy kod w bajtach wygrywa. Tiebreaker to wcześniejsza odpowiedź.

BrainF ** k, 396 391 bajtów

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

Nie mogłem oprzeć się pokusie zrobienia tego. Przynajmniej trójkąt jest spiczasty bokiem.

Wprowadzane dane są ciągiem znaków numerycznych, po których następuje pojedynczy znak nowej linii.

Dane wyjściowe będą zawierać pojedyncze końcowe miejsce w każdym wierszu.

Przykłady:

$ 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 

Wyjaśnienie

Ponieważ trudno jest wyjaśnić kod z perspektywy funkcjonalnej, możemy zamiast tego spojrzeć na niego z perspektywy stanu taśmy w różnych momentach. Podstawową ideą jest to, że trójkąt, który wysyłamy, jest inicjalizowany jako ciasno upakowana (w każdym razie BF) tablica, która zmniejsza się o 1 przy każdej iteracji pętli. Inną ważną myślą jest to, że używamy 255do wskazania „symbolu zastępczego”, który możemy wyszukać na taśmie.

Inicjalizacja

To najłatwiejszy krok. Na początku programu wykonujemy następujące czynności:

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

Wymusza to przejście taśmy w następujący stan (gdzie >N<wskazuje położenie wskaźnika na taśmie)

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

Pierwszą liczbą tutaj jest lokalizacja „buforowa”. Nie będziemy go używać długoterminowo, ale przydatne jest uproszczenie niewielkich operacji i kopiowanie danych.
Druga liczba to liczba spacji, które będziemy wypisywać na początku każdej linii, zaczynając od pierwszej linii. Pierwsza linia nie będzie miała spacji wiodących.
Trzecia liczba to znak spacji, który wypisujemy.
Czwarta liczba to symbol zastępczy 255, dzięki czemu możemy stosunkowo łatwo wrócić do tej pozycji.

Wkład

Z tej pozycji będziemy czytać wszystkie postacie. Pod koniec tego kroku mamy nadzieję, że znajdziemy się w następującej sytuacji:

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

Gdzie a b c d e f ...wskazuje ciąg znaków numerycznych, który został wprowadzony (nie nowy wiersz).

Osiągamy to poprzez:

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

Są w tym pewne niuanse. Po pierwsze, wypisujemy każdy znak, gdy go otrzymamy, a następnie wypisujemy po nim spację. Po drugie, nie chcemy kopiować wartości ASCII na taśmę, chcemy skopiować rzeczywistą cyfrę. Po trzecie, chcemy przestać, kiedy trafimy na nową linię i pozostawimy się w tym miejscu w dobrym miejscu.
Powiedz, że nasz wkład to 6723. Następnie, po przeczytaniu pierwszego 6, nasza taśma wygląda następująco:

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

Sprawdzamy, czy ta wartość nie jest równa 10(nowa linia ASCII) z ,----------[++++++++++. Następnie drukujemy wartość i kontynuujemy odejmując jednocześnie 48 od wartości wejściowej i dodając 32 do wartości obok niej ( >>++++++++[-<++++<------>>]<), pozostawiając nas tutaj:

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

Zauważ, jak w tym procesie możemy założyć, że wszystkie cyfry po prawej stronie naszych danych wejściowych są równe 0 - oznacza to, że nie grozi nam zniszczenie jakiegokolwiek poprzedniego stanu, jeśli użyjemy wartości po prawej stronie do obliczenia 6 * 8i 4 * 8.
Teraz wypisujemy wygenerowany właśnie znak spacji i przyjmujemy nowe dane wejściowe, usuwając obliczone tam miejsce. Ostatecznie wejście zostanie zakończone nową linią i pętla wyjdzie, pozostawiając miejsce, w 255którym byłaby nowa linia ( ,----------]-). Jest to drugi znak zastępczy, którego użyjemy do nawigacji na taśmie. W tym momencie naszego scenariusza nasza taśma jest dokładnie taka:

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

Obliczenie

Działa to w ten sposób, że lista cyfr między naszymi 255symbolami zastępczymi będzie się zmniejszać o jedną iterację pętli. Gdy pozostanie w nim tylko 1 cyfra, jesteśmy skończeni i powinniśmy natychmiast się zatrzymać (zwróć uwagę, że w tym momencie każda cyfra z tej listy została już wydrukowana, więc nie musimy się martwić o jej ponowne wysłanie).

Mamy teraz skorzystać z tej sztuczki, aby przejść do pierwszego 255zastępczy: <+[-<+]-. To skutecznie przeszukuje taśmę po lewej stronie w poszukiwaniu 255, nie zmieniając niczego pomiędzy. Teraz, gdy przesunęliśmy wskaźnik, możemy sprawdzić nasz warunek wyjścia: jeśli na liście jest tylko jedna cyfra, to komórka pomieści dwie spacje po prawej stronie 255. Sprawdzamy więc to i uruchamiamy pętlę:>>+[-<<

Pierwszym krokiem w naszej pętli jest wygenerowanie nowego wiersza. Przechodzimy więc do pierwszej komórki (naszej komórki buforowej), dodajemy do niej 10 i wyprowadzamy. Następnym krokiem jest wyprowadzenie wszystkich wiodących znaków spacji. Po ich wyliczeniu zwiększamy naszą liczbę o liczbę wiodących spacji. Kroki te są realizowane przez:

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

Co pozostawia nas w tym stanie:

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

Naszym następnym krokiem jest skopiowanie pierwszej wartości z listy obok drugiego symbolu zastępczego 255:

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

Zasadniczo robimy to, przeskakując tam iz powrotem między naszymi symbolami zastępczymi 255, pozostawiając nas tutaj:

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

Rozpoczynamy teraz pętlę, iterując resztę listy, zatrzymując się po trafieniu 255:>+[-<

W tym momencie cyfra po naszej lewej stronie wynosi zawsze 0. Tak więc, ponieważ je kochamy, wstawiamy 255tam symbol zastępczy , abyśmy mogli wrócić do naszego miejsca na liście. Następnym krokiem jest przeniesienie drugiego miejsca na liście do lokalizacji, w których przenieśliśmy pierwsze miejsce, obok drugiego symbolu zastępczego 255. Kroki te są realizowane przez:

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

Zostawiając nas tutaj: [ 0 2 32 255 255 >0< 2 3 255 7 6 7 0 ] Teraz zarówno 6i , jak i 7zostały przeniesione do miejsca, w którym mogą wystąpić obliczenia. Potrzebujemy dwóch kopii, 7ponieważ następny numer na liście również będzie go potrzebował. 7Natychmiast po 255służy temu celowi, podczas gdy inne 7będą spożywane przez obliczeniach.

Najpierw dodajemy dwie cyfry:

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

Zostawiając nas tutaj:

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

Kolejna kombinacja kroków jest najbardziej skomplikowana. Musimy sprawdzić, czy wskazana liczba jest większa niż 10, a jeśli tak, to odejmujemy 10. W rzeczywistości odejmujemy od niego 10 i sprawdzamy, czy trafi 0w którymkolwiek punkcie odejmowania. Jeśli tak, dodajemy 10później. Na koniec powinniśmy mieć 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
>>+[-<<<+>>>[-<->]<+++++++++>>>+]

W tym momencie osiągnęliśmy cel. Mamy sumę modulo 10! Ponadto, niezależnie od tego, czy liczba była większa niż 10, skończymy tutaj:

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

Naszym kolejnym celem jest wyprowadzenie tej nowej sumy, dodanie jej spacji i wprowadzenie jej z powrotem na naszą listę. Robimy to wszystko za pomocą naszych poprzednich technik 255kupowania i dodawania 48do naszej sumy, więc nie będę tego szczegółowo omawiać.

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

I jesteśmy tutaj: [ 0 2 32 255 3 255 2 3 255 7 0 0 51 >32< ] zauważ, jak 255wstawiamy dodatkowy symbol zastępczy po naszym nowym wstrzyknięciu, 3aby nie stracić miejsca na liście. W tym momencie wyprowadziliśmy naszą sumę i jej przestrzeń, więc musimy wyczyścić i powrócić do stanu, w którym zadziała kolejna iteracja tej pętli. Musimy wyczyścić nasze 51i 32komórki, przesunąć 7raz w prawo i przejść do naszego symbolu zastępczego listy, abyśmy mogli zacząć od nowa.

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

Teraz jesteśmy tutaj: [ 0 2 32 255 3 >0< 2 3 255 0 7 0 ... ]
właśnie tam chcemy być na następnej iteracji. Więc sprawdź 255 i idź dalej! ( >+])

Kiedy zostaniemy wysadzeni z pętli, będziemy mieli zupełnie nową listę - złożoną z sum z poprzedniej listy. Za pierwszym razem będzie to wyglądać tak:

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

Teraz chcemy powtórzyć cały proces na naszej nowej liście, więc przeskoczymy w 255dół i zaczniemy od nowa! Musimy zrobić trochę czyszczenia >>[-]<<, a następnie upuścić nasz symbol zastępczy <-. Potem jesteśmy dokładnie w tym samym miejscu, w którym byliśmy po wejściu, więc możemy uniknąć tych samych kontroli: <+[-<+]->>+i bum! Mamy pełną pętlę! Wszystko, czego potrzebujemy jest nawias zamykający, a kiedy kończy mamy już wyjścia wszystko, więc skończymy: ].

Galaretka , 20 19 18 bajtów

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

Wypróbuj online!

tło

Generowanie liczb jest proste w Jelly. Wynik jest nieco bardziej skomplikowany.

Galaretka ma wbudowaną siatkę atom ( G), która wyświetla listę 2D z nowymi liniami między wierszami i spacjami między kolumnami. Bierzemy tablicę liczb 2D (generowaną przy odwróceniu każdego wiersza) i transponujemy ją z wartością wypełnienia @. Po odwróceniu wynikowej tablicy i ponownej transpozycji, zastosowanie Gdaje następujące.

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

Aby uzyskać pożądany kształt trójkąta, wystarczy usunąć wartość wypełnienia.

Jak to działa

Ṛ+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 bajtów

j.e+*dkjdbP.ueM+Vt

Pakiet testowy .

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 bajtów

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

Wejście to lista liczb całkowitych (np. f([1,2,3,5,8])), Wyjście to STDOUT. %10Oraz fakt, że mapzwraca mapobiekt w Pythonie 3 jest nieco irytujące, co oznacza, że nie możemy zrobić, map(lambda*x:sum(x)%10,L,L[1:])lub podobny.

Funkcja wyskakuje, ale do tego czasu dane wyjściowe zostałyby zakończone. Dzięki @xsot za -1 bajt, znajdując dobre miejsce do przyklejenia print.

05AB1E , 20 19 17 bajtów

Kod:

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

Wyjaśnienie:

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.

Wykorzystuje kodowanie CP-1252 . Wypróbuj online! .

MATL, 32 30 29 28 27 26 25 24 bajtów

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

1 bajt zapisany dzięki @Luis

Wypróbuj online!

Zmodyfikowana wersja dla wszystkich przypadków testowych

Wyjaśnienie

        % 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

Właściwie 43 bajty

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

Wypróbuj online!

Ten program wypisuje pojedynczy znak nowej linii po wyjściu.

Wyjaśnienie:

;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 bajtów

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

Przykład:

CJam, 25 bajtów

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

Wypróbuj online!

Wyjaśnienie

Wykorzystuje to dość zgrabną sztuczkę do wygenerowania układu trójkąta.

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 bajtów

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 bajtów

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

Na podstawie odpowiedzi @ Sp3000 . Funkcja \przyjmuje tablicę jako dane wejściowe i zwraca ciąg znaków.

Wypróbuj online!

Pyke, 21 bajtów

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

Wypróbuj tutaj!

Chciałbym myśleć, że ta metoda jest nieco inna.

[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 bajtów

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

Wyjaśnienie:

{ # 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
}

Przykład:

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 bajtów

Używając GOTO zamiast jednego z WHILE, mogłem zagrać w golfa 3 postaci

Grał w golfa

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

Wypróbuj online (używając starego skryptu z 2 * WHILE)

Java 7, 230 215 213 bajtów

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

Skończyło się to trochę dłużej, niż myślałem ... Może to może być trochę bardziej golfa, ponieważ myślę, że trochę pomieszałem, myślę ...

Niektóre bajty zapisane dzięki @GiacomoGarabello .

Kod niepoznany i testowy:

Wypróbuj tutaj.

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

Wydajność:

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 bajtów

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+" "):"");

+18 jest dla using System.Linq;

Dzięki @TheLethalCoder za zapisanie 13 bajtów, poprzez wskazanie niepotrzebnej instrukcji using

JavaScript (ES6), 77 bajtów

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

C, 138 bajtów

Grał w golfa

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

Nie golfił

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 bajtów

Jestem naprawdę dumny z tego rozwiązania, wyrażenia lambda są tak zabawne, jak tylko się zorientujesz

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

tutaj niepolecany do dalszych ulepszeń:

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

wypróbuj to tutaj

Haskell, 139 bajtów

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)

Pobiera dane wejściowe jako argument, wysyła dane do STDOUT.

Wersja bez golfa:

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 bajtów

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

Drukuje pojedynczy znak nowej linii.

Jak to działa

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

Wypróbuj na Ideone

J, 44 bajty

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

Na podstawie tego rozwiązania .

JavaScript (przy użyciu zewnętrznej biblioteki) (198 bajtów)

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 do lib: https://github.com/mvegh1/Enumerable/

Wyjaśnienie kodu: Korzystanie z biblioteki było łatwe! Nie wygrywa w bajtach, ale kod nie jest zbyt szczegółowy i łatwy do odczytania. Tak więc, wejście „n” jest tablicą liczb całkowitych. Załaduj go do biblioteki, zapisany w zmiennej „a”. „B” to ciąg zwracany, przechowuj połączony ciąg z „” jako separator w b. C to bieżąca iteracja, użyj tego, aby określić liczbę spacji do wstawienia. UWAGA: Wydaje się, że działa to dobrze tylko wtedy, gdy dane wejściowe pochodzą z 0-9. zestawy obecnego wyliczalnego „a”, tzn. jeśli mamy [1,2,3,4,5,6], otrzymujemy [1,2], [2,3], [3,4], ... [ 6] ... następnie odfiltruj to, abyśmy mieli tylko partie wielkości 2. Następnie mapujemy to na zbiór sum partii% 10. Jeśli a jest puste, to skończymy, w przeciwnym razie dodamy nową linię do naszego zwrotu. Wreszcie wróć ...

Zdjęcie pojawi się za kilka minut.