글쎄요, 정말로 요약하십시오.

비어 있지 않은 십진 정수 (0-9) 목록을 가져 와서 맨 아래에있는 입력 목록과 함께 아래로 향하는 "삼각형"을 출력하는 프로그램 또는 함수를 작성하십시오. 그 위에 모듈로 10.

예를 들어, 입력 [7, 5, 0, 9]에 출력이 있습니다

7 5 0 9
 2 5 9
  7 4
   1

때문에이 2있다 (7 + 5) mod 10, 5있다 (5 + 0) mod 10, 9있다 (0 + 9) mod 10등 모든 방법 1인 (7 + 4) mod 10.

목록에 하나의 항목 만있는 경우 출력은 입력과 일치합니다. 예를 들어, 입력의 [4]의지 수율

4

몇 가지 추가 예는 다음과 같습니다.

[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

출력에서 다음을 참고하십시오.

• 첫 번째 줄에는 선행 공백이 없습니다.
• 각 후속 줄에는 이전 줄보다 선행 공간이 하나 더 있습니다.
• 숫자는 단일 공백으로 구분됩니다.
• 각 줄은 최대 하나의 후행 공간을 가질 수 있습니다.
• 하나의 선택적 후행 줄 바꿈이있을 수 있습니다.
• 일반 10 진수 (0-9)의 문자를 사용해야합니다.

바이트 단위의 가장 짧은 코드가 이깁니다. Tiebreaker가 이전 답변입니다.

BrainF ** k, 396 391 바이트

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

나는 이것에 대한 유혹에 저항 할 수 없었다. 최소한 삼각형이 뾰족한 쪽을 향합니다.

입력은 하나의 줄 바꿈 뒤에 숫자 문자열로 제공됩니다.

출력은 모든 줄에 단일 후행 공백을 포함합니다.

예 :

$ 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 

설명

기능적인 관점에서 코드를 설명하기는 어렵 기 때문에 대신 테이프 상태의 관점에서 코드를 여러 번 볼 수 있습니다. 여기서 핵심 아이디어는 우리가 출력하는 삼각형이 루프가 반복 될 때마다 크기가 1 씩 줄어드는 꽉 채워진 (BF, 어쨌든) 배열로 초기화된다는 것입니다. 또 다른 중요한 생각은 255테이프에서 검색 할 수있는 "자리 표시 자"를 나타내는 데 사용 한다는 것입니다.

초기화

가장 쉬운 단계입니다. 프로그램 시작시 다음을 실행합니다.

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

이렇게하면 테이프가 다음 상태가됩니다 ( >N<테이프에서 포인터의 위치를 ​​나타냄).

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

여기서 첫 번째 숫자는 "버퍼"위치입니다. 우리는 장기간 사용하지는 않지만 적은 작업을 단순화하고 데이터를 복사하는 데 유용합니다.
두 번째 숫자는 우리가 시작, 각 라인의 시작에서 출력 될 거라고 공간의 개수 후 첫 줄. 첫 번째 줄에는 선행 공백이 없습니다.
세 번째 숫자는 우리가 출력하는 공백 문자입니다.
네 번째 숫자는 자리 표시 자 255이므로 상대적으로 쉽게이 위치로 돌아갈 수 있습니다.

입력

이 위치에서 모든 문자를 읽습니다. 이 단계가 끝나면 다음과 같은 상황에 처하기를 바랍니다.

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

여기서 a b c d e f ..., 줄 바꿈이 아닌 입력 된 숫자 문자열을 나타냅니다.

우리는 이것을 다음과 같이 달성합니다.

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

이것에는 약간의 뉘앙스가 있습니다. 우선, 각 문자를 가져올 때 각 문자를 출력 한 다음 그 뒤에 공백을 출력합니다. 둘째, ASCII 값을 테이프에 복사하지 않고 실제 숫자를 복사하려고합니다. 셋째, 우리는 개행을 멈출 때 멈추고 그 당시 좋은 곳으로 떠나고 싶습니다.
우리의 입력을 받았다고 6723. 그런 다음 첫 번째를 읽으면 6테이프가 다음과 같이 보입니다.

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

이 값이 10(ASCII 줄 바꿈)과 같지 않은지 확인합니다 ,----------[++++++++++. 그런 다음 값을 인쇄하고 입력 값에서 48을 빼고 그 옆 값에 32를 더하여 ( >>++++++++[-<++++<------>>]<) 계속해서 여기에 남겨 둡니다.

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

공지 사항이 과정에서 우리가 생각하는 방법을 우리의 입력의 오른쪽에있는 모든 숫자가 0임을 - 우리가 계산에 대한 권리에 값을 사용하는 경우 우리가 이전 상태를 망치고의 위험하지 않은 것으로이 의미 6 * 8하고 4 * 8.
이제 방금 생성 한 공백 문자를 출력하고 새로운 입력을 받아 계산 된 공백을 삭제합니다. 결국 입력은 255줄 바꾸기 로 끝나고 루프는 종료 되어 줄 바꿈 위치는 ( ,----------]-)로 남습니다 . 테이프를 탐색하는 데 사용할 두 번째 자리 표시 자 문자입니다. 시나리오의 현재 시점에서 테이프는 정확히 다음과 같습니다.

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

계산

이것이 작동하는 방식은 자리 255표시 자 사이의 숫자 목록 이 루프가 반복 될 때마다 하나씩 줄어드는 것입니다. 여기에 1 자리 만 남았 으면 완료되었으며 즉시 중지해야합니다 (이 시점에서 해당 목록의 모든 숫자가 이미 출력되었으므로 다시 출력 할까 걱정할 필요가 없습니다).

이제이 트릭을 사용하여 첫 번째 255자리 표시 자로 이동합니다 <+[-<+]-. 이렇게하면 왼쪽에서 테이프를 효과적으로 검색하여 255사이에 아무것도 변경되지 않습니다. 포인터를 움직 였으므로 종료 조건을 확인할 수 있습니다. 목록에 한 자리 만 있으면 오른쪽에있는 두 칸의 셀이 유지 255됩니다. 따라서 우리는 그것을 확인하고 루프를 시작합니다.>>+[-<<

루프의 첫 번째 단계는 개행을 출력하는 것입니다. 그래서 우리는 첫 번째 셀 (버퍼 셀)로 이동하여 10을 더하고 출력합니다. 다음 단계는 모든 선행 공백 문자를 출력하는 것입니다. 그것들을 출력 한 후, 우리는 선행 공간 수에 대한 카운트를 증가시킵니다. 이 단계는 다음에 의해 수행됩니다.

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

이 상태에서 우리를 떠난다 :

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

다음 단계는 두 번째 자리 표시자를지나 목록의 첫 번째 값을 복사하는 것입니다 255.

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

우리는 본질적으로 자리 표시 자 사이를 앞뒤로 움직여서 255여기에 남겨 둡니다.

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

우리는 이제 루프를 시작하고 나머지리스트를 반복하면서 우리가 쳤을 때 멈 춥니 다 255.>+[-<

이 시점에서 가장 왼쪽에있는 숫자는 항상 0입니다. 그래서 우리는 그것들을 사랑하기 때문에 자리 표시자를 열어서 255목록에서 우리 자리로 돌아올 수 있습니다. 다음 단계는 목록에서 두 번째 자리를 두 번째 자리 표시자를 지나서 첫 번째 자리를 이동 한 주변 위치로 이동하는 것 255입니다. 이 단계는 다음에 의해 수행됩니다.

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

우리를 여기로 남겨주세요 : [ 0 2 32 255 255 >0< 2 3 255 7 6 7 0 ] 이제 6와와 둘 다 7계산이 일어날 수있는 위치로 옮겨졌습니다. 7목록의 다음 번호에서도 필요하므로 두 개의 사본 이 필요합니다. 7바로 후에 255나머지가있는 반면,이 목적을 제공 7계산에 의해 소비 될 것이다.

먼저 두 자리를 추가합니다 :

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

여기 우리를 떠나 :

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

다음 단계 조합은 가장 복잡합니다. 우리가 가리키는 숫자가 10보다 큰지 확인해야하며, 그렇다면 숫자를 뺍니다 10. 실제로, 우리가하는 일은 10을 빼서 빼기의 0어느 시점에서나 치르는 지 확인하는 것 입니다. 그렇다면 10나중에 다시 추가 합니다. 이것의 끝에 합계 모듈로 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
>>+[-<<<+>>>[-<->]<+++++++++>>>+]

이 시점에서 목표를 달성했습니다. 우리는 합 모듈로 10을 가지고 있습니다! 또한 숫자가 10보다 큰지 여부는 다음과 같습니다.

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

다음 목표는이 새로운 합계를 출력하고 공백으로 따라 가서 목록에 다시 주입하는 것입니다. 우리는이 모든 것을 이전에 255도약하고 48합계에 추가 하는 기술로 수행 하므로 자세히 다루지 않습니다.

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

그리고 우리는 여기에 있습니다 : 새로 주입 한 후에 [ 0 2 32 255 3 255 2 3 255 7 0 0 51 >32< ] 추가 255자리 표시자를 추가 3하여 목록에서 자리를 잃지 않도록하십시오. 이 시점에서 합계와 그 공간을 출력 했으므로 다음 루프 반복이 작동 할 상태로 정리하고 되돌려 야합니다. 다시 시작하려면 셀 51과 32셀 을 지우고 7한 번 오른쪽으로 이동 한 다음 목록 자리 표시 자로 이동해야합니다.

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

이제 우리는 여기 있습니다 : [ 0 2 32 255 3 >0< 2 3 255 0 7 0 ... ]
다음 반복을 위해 정확히 원하는 곳입니다. 255를 확인하고 계속 진행하십시오! ( >+])

루프에서 빠져 나오면 이전 목록의 합계로 구성된 완전히 새로운 목록이 생깁니다. 처음에는 다음과 같습니다.

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

이제 우리는 새로운 목록에서 전체 프로세스를 반복하고 싶기 때문에 255왼쪽 으로 내려 가서 다시 시작합니다! 로 약간의 정리를 수행 한 >>[-]<<다음 자리 표시자를로 삭제해야 <-합니다. 그 후, 우리는 입력 후와 정확히 같은 위치에 있으므로 동일한 검사를 수행하지 않아도됩니다 <+[-<+]->>+. 우리는 우리의 전체 루프를 가지고있다! 필요한 것은 닫는 괄호이며, 끝날 때 이미 모든 것을 출력 했으므로 완료되었습니다 ].

젤리 , 20 19 18 바이트

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

온라인으로 사용해보십시오!

배경

숫자를 생성하는 것은 Jelly에서 간단합니다. 출력이 조금 더 복잡합니다.

젤리는 빌트인 그리드 아톰 ( G)을 가지고 있으며, 행 사이에 개행과 열 사이에 공백이있는 2D 목록을 표시합니다. 우리는 2D 숫자 배열 (각 행을 반대로하여 생성)을 가져 와서 그것을 fill value로 바꿉니다 @. 결과 배열을 수정하고 다시 바꾼 후 G다음을 적용하십시오 .

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

원하는 삼각형 모양을 얻으려면 채우기 값을 제거하기 만하면됩니다.

작동 원리

Ṛ+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 바이트

j.e+*dkjdbP.ueM+Vt

테스트 스위트 .

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]

파이썬 3.5, 74 72 71 바이트

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

입력은 정수 목록입니다 (예 f([1,2,3,5,8]):). 출력은 STDOUT입니다. %10하고 있다는 사실 map반환 map파이썬 3의 목적은 우리가 할 수없는 의미, 약간 성가신 map(lambda*x:sum(x)%10,L,L[1:])또는 이와 유사한.

함수는 에러가 나지만 출력은 완료되었을 것입니다. -1 바이트에 대한 @xsot 덕분에를 붙일 수있는 좋은 장소를 찾았습니다 print.

05AB1E , 20 19 17 바이트

암호:

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

설명:

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.

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오! .

MATL, 32 30 29 28 27 26 25 24 바이트

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

@Luis 덕분에 1 바이트 절약

온라인으로 사용해보십시오!

모든 테스트 사례에 대한 수정 된 버전

설명

        % 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

실제로 43 바이트

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

온라인으로 사용해보십시오!

이 프로그램은 출력 후 하나의 후행 줄 바꿈을 인쇄합니다.

설명:

;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

매스 매 티카, 67 바이트

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

예:

CJam, 25 바이트

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

온라인으로 사용해보십시오!

설명

이것은 상당히 깔끔한 트릭을 사용하여 삼각형 레이아웃을 생성합니다.

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.

자바 스크립트 (ES6) 147 바이트

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

줄리아, 60 59 바이트

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

에 기초 @ Sp3000의 답변을 합니다. 이 함수 \는 배열을 입력으로 받아들이고 문자열을 반환합니다.

온라인으로 사용해보십시오!

파이크, 21 바이트

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

여기 사용해보십시오!

이 방법이 조금 다르다고 생각합니다.

[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

펄 6 ,  65 63 62  61 바이트

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

설명:

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

예:

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 바이트

WHILE 중 하나 대신 GOTO를 사용하여 3 자 골프를 할 수있었습니다

골프

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

온라인으로 사용해보십시오 (2 * WHILE의 이전 스크립트 사용)

자바 7 230 215 213 바이트

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

이것은 내가 생각했던 것보다 조금 더 길어졌다. 어쩌면 내가 좀 엉망으로 생각하기 때문에 아마 골프를 조금 더 할 수있다 ..

@GiacomoGarabello 덕분에 일부 바이트가 절약 되었습니다 .

언 골프 및 테스트 코드 :

여기에서 시도하십시오.

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

산출:

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 + 31125 + 18 = 143 바이트

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은 using System.Linq;

불필요한 using 문을 지적하여 13 바이트를 절약 한 @TheLethalCoder 덕분에

자바 스크립트 (ES6), 77 바이트

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

C, 138 바이트

골프

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

언 골프

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 바이트

실제로이 솔루션을 매우 자랑스럽게 생각합니다. 람다 식은 일단 익히면 너무 재미 있습니다.

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

추가 개선을 위해 여기에 ungolfed :

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

여기서 사용해보십시오

하스켈, 139 바이트

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)

입력을 인수로 취해 STDOUT에 출력합니다.

언 골프 버전 :

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)

파이썬 3, 97 바이트

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

하나의 후행 줄 바꿈을 인쇄합니다.

작동 원리

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

Ideone에서 사용해보십시오

J, 44 바이트

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

이 솔루션을 기반으로합니다 .

자바 스크립트 (외부 라이브러리 사용) (198 바이트)

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}

lib에 링크 : https://github.com/mvegh1/Enumerable/

코드 설명 : 라이브러리를 사용하는 것이 쉬웠습니다! 바이트 단위로이기는 것은 아니지만 코드가 너무 간결하고 읽기 쉽지 않습니다. 따라서 입력 "n '은 정수 배열입니다. 변수"a "에 저장된 라이브러리에로드합니다."b "는 반환 문자열이고" "를 사용하여 조인 된 문자열을 b로 구분 기호로 저장합니다. c는 현재 반복에서는 삽입 할 공백의 수를 결정하기 위해 이것을 사용하십시오 참고 : 이것은 입력이 0-9에서 시작될 때만 잘 작동하는 것 같습니다. 그런 다음, 특정 코드 세트를 반복하십시오. 현재 열거 가능한 "a"세트, 즉 [1,2,3,4,5,6]을 가진 경우 [1,2], [2,3], [3,4], ... [ 6] ... 그런 다음 필터링하여 크기가 2 인 배치 만 갖도록합니다. 그런 다음이를 배치의 합 합계 % 10에 매핑합니다. 10. a가 비어 있으면 완료됩니다. 그렇지 않으면 우리는 새로운 줄을 반환에 추가합니다. 마지막으로 돌아갑니다 ...

몇 분 안에 사진이 나옵니다.