Eh bien, résumez vraiment.

Écrivez un programme ou une fonction qui prend une liste non vide d'entiers décimaux (0-9) et sort un "triangle" de chiffres pointant vers le bas avec la liste d'entrée en haut où chaque chiffre après la première ligne est la somme des deux chiffres au-dessus, modulo 10.

Par exemple, l'entrée [7, 5, 0, 9]a une sortie

7 5 0 9
 2 5 9
  7 4
   1

parce que 2est (7 + 5) mod 10, 5est (5 + 0) mod 10, 9est (0 + 9) mod 10, etc. jusqu'à 1être (7 + 4) mod 10.

Si la liste ne contient qu'un seul élément, la sortie correspond à l'entrée; par exemple, une entrée de [4]donnera

4

Voici quelques exemples supplémentaires:

[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

Notez que dans la sortie:

• La première ligne n'a pas d'espaces de début.
• Chaque ligne suivante a un espace de tête de plus que la ligne précédente.
• Les chiffres sont séparés par un seul espace.
• Chaque ligne peut avoir jusqu'à un espace de fin.
• Il peut y avoir une seule nouvelle ligne de fin facultative.
• Vous devez utiliser les caractères pour les chiffres décimaux normaux (0 à 9).

Le code le plus court en octets gagne. Tiebreaker est une réponse antérieure.

BrainF ** k, 396 391 octets

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

Je n'ai pas pu résister à la tentation de faire celle-ci. Au moins, le triangle est pointu vers le bas.

L'entrée se présente sous la forme d'une chaîne de caractères numériques suivie d'une seule nouvelle ligne.

La sortie contiendra un seul espace de fin sur chaque ligne.

Exemples:

$ 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 

Explication

Comme il est assez difficile d'expliquer le code d'un point de vue fonctionnel, nous pouvons plutôt le regarder du point de vue de l'état de la bande à différents moments. L'idée centrale ici est que le triangle que nous générons est initialisé comme un tableau compact (pour BF, de toute façon) qui diminue de taille de 1 à chaque itération d'une boucle. Une autre pensée importante est que nous utilisons 255pour indiquer un "espace réservé" que nous pouvons rechercher sur la bande.

Initialisation

C'est l'étape la plus simple. Au début du programme, nous exécutons ce qui suit:

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

Cela force la bande dans l'état suivant (où >N<indique l'emplacement du pointeur sur la bande)

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

Le premier numéro ici est un emplacement "tampon". Nous n'allons pas l'utiliser à long terme, mais il est utile de simplifier les petites opérations et de copier les données.
Le deuxième nombre est le nombre d'espaces que nous afficherons au début de chaque ligne, en commençant après la première ligne. La première ligne n'aura pas d'espaces de tête.
Le troisième nombre est le caractère d'espace que nous générons.
Le quatrième nombre est un espace réservé 255, afin que nous puissions revenir à cette position relativement facilement.

Contribution

De cette position, nous lirons tous les caractères. Au terme de cette étape, nous espérons être dans la situation suivante:

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

Où a b c d e f ...indique la chaîne de caractères numériques qui a été entrée (pas la nouvelle ligne).

Nous accomplissons cela avec les éléments suivants:

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

Il y a quelques nuances à cela. Tout d'abord, nous afficherons chaque caractère au fur et à mesure que nous les obtiendrons, puis afficherons un espace après. Deuxièmement, nous ne voulons pas copier la valeur ASCII sur la bande, nous voulons copier le chiffre numérique réel. Troisièmement, nous voulons arrêter lorsque nous atteignons une nouvelle ligne et nous laisser à la bonne place à ce moment-là.
Disons que notre contribution est 6723. Ensuite, à la lecture du premier 6, notre bande ressemble à ceci:

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

Nous vérifions que cette valeur n'est pas égale à 10(une nouvelle ligne ASCII) avec ,----------[++++++++++. Nous imprimons ensuite la valeur et continuons en soustrayant simultanément 48 de la valeur d'entrée et en ajoutant 32 à la valeur à côté ( >>++++++++[-<++++<------>>]<), nous laissant ici:

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

Remarquez comment tout au long de ce processus, nous pouvons supposer que tous les chiffres à droite de notre entrée sont 0 - cela signifie que nous ne risquons pas de ruiner un état précédent si nous utilisons des valeurs à droite pour calculer 6 * 8et 4 * 8.
Maintenant, nous sortons le caractère d'espace que nous venons de générer et prenons une nouvelle entrée, supprimant l'espace que nous avons calculé là-bas. Finalement, l'entrée sera terminée par une nouvelle ligne et la boucle se terminera, laissant un 255où la nouvelle ligne aurait été ( ,----------]-). Il s'agit du deuxième caractère d'espace réservé que nous utiliserons pour parcourir la bande. À ce stade de notre scénario, notre bande est exactement la suivante:

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

Calcul

La façon dont cela fonctionne est que la liste des chiffres entre nos 255espaces réservés va se réduire d'une unité à chaque itération de la boucle. Quand il ne reste plus qu'un chiffre, nous avons terminé et nous devons nous arrêter immédiatement (notez qu'à ce stade, chaque chiffre de cette liste a déjà été sorti, nous n'avons donc pas à nous soucier de le sortir à nouveau).

Nous utilisons maintenant cette astuce pour naviguer vers le premier 255espace réservé: <+[-<+]-. Cela recherche efficacement une bande sur la gauche pour 255ne rien changer entre les deux. Maintenant que nous avons déplacé le pointeur, nous pouvons vérifier notre condition de sortie: s'il n'y a qu'un seul chiffre dans la liste, alors la cellule deux espaces à droite tiendra 255. Ainsi, nous vérifions cela et commençons une boucle:>>+[-<<

La première étape de notre boucle consiste à sortir une nouvelle ligne. Nous passons donc à la première cellule (notre cellule tampon), y ajoutons 10 et sortons. L'étape suivante consiste à sortir tous les premiers caractères de l'espace. Après leur sortie, nous incrémentons notre comptage pour le nombre d'espaces de tête. Ces étapes sont accomplies comme suit:

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

Ce qui nous laisse dans cet état:

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

Notre prochaine étape consiste à copier la première valeur de la liste, au-delà du deuxième espace réservé 255:

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

Nous le faisons essentiellement en faisant des allers-retours entre nos espaces réservés 255, nous laissant ici:

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

Nous commençons maintenant une boucle, itérant dans le reste de la liste, s'arrêtant lorsque nous frappons 255:>+[-<

À ce stade, le chiffre à notre gauche immédiate est toujours 0. Donc, parce que nous les aimons, nous y ajoutons un espace réservé 255afin de pouvoir revenir à notre place dans la liste. L'étape suivante consiste à déplacer la deuxième place de la liste vers des emplacements autour desquels nous avons déplacé la première place, après le deuxième espace réservé 255. Ces étapes sont accomplies comme suit:

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

Nous laissant ici: [ 0 2 32 255 255 >0< 2 3 255 7 6 7 0 ] Maintenant, les deux 6et 7ont été déplacés vers un emplacement où le calcul peut avoir lieu. Nous avons besoin de deux copies du 7car le prochain numéro de la liste en aura également besoin. Le 7immédiatement après le 255sert à cet effet, tandis que l'autre 7sera consommé par le calcul.

Tout d'abord, nous ajoutons les deux chiffres:

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

Nous laissant ici:

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

La prochaine combinaison d'étapes est la plus compliquée. Nous devons voir si le nombre que nous pointons est supérieur à 10, et si c'est le cas, nous soustrayons 10. En réalité, ce que nous faisons, c'est que nous en soustrayons 10 et voyons s'il frappe 0à un moment quelconque de la soustraction. Si c'est le cas, nous ajoutons10 plus tard. À la fin de cela, nous devrions avoir la somme 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
>>+[-<<<+>>>[-<->]<+++++++++>>>+]

À ce stade, nous avons atteint l'objectif. Nous avons la somme modulo 10! Aussi, que le nombre soit supérieur ou non à 10, nous nous retrouverons ici:

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

Nos prochains objectifs sont de produire cette nouvelle somme, de la suivre avec un espace et de la réinjecter dans notre liste. Nous faisons tout cela avec nos techniques précédentes de 255sauts et d'ajout 48à notre somme, donc je ne le couvrirai pas en détail.

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

Et nous y sommes: [ 0 2 32 255 3 255 2 3 255 7 0 0 51 >32< ] remarquez comment nous mettons un 255espace réservé supplémentaire après notre nouvelle injection 3afin de ne pas perdre de place dans la liste. À ce stade, nous avons sorti notre somme et son espace, nous devons donc nettoyer et revenir à un état où la prochaine itération de cette boucle va fonctionner. Nous devons effacer nos cellules 51et 32, déplacer 7une fois vers la droite et naviguer vers notre espace réservé de liste afin de pouvoir recommencer.

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

Maintenant, nous sommes ici: [ 0 2 32 255 3 >0< 2 3 255 0 7 0 ... ]
qui est exactement où nous voulons être pour notre prochaine itération. Alors vérifiez 255 et continuez! ( >+])

Lorsque nous serons retirés de la boucle, nous aurons une toute nouvelle liste - composée des sommes de la liste précédente. La première fois, cela ressemblera à ceci:

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

Maintenant, nous voulons répéter tout ce processus sur notre nouvelle liste, nous avons donc plop un 255vers la gauche et tout recommencer! Nous devons faire un peu de nettoyage avec >>[-]<<, puis supprimer notre espace réservé avec <-. Après cela, nous sommes exactement au même endroit que nous étions après l'entrée, nous pouvons donc nous en sortir en faisant les mêmes vérifications <+[-<+]->>+:, et boum! Nous avons notre boucle complète! Nous avons tous besoin est le support de fermeture, et quand il se termine , nous avons déjà tout sortie, donc nous avons terminé: ].

Gelée , 20 19 18 octets

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

Essayez-le en ligne!

Contexte

La génération des nombres est simple dans Jelly. La sortie est un peu plus compliquée.

Jelly possède un atome de grille intégré ( G) qui affiche une liste 2D avec des nouvelles lignes entre les lignes et des espaces entre les colonnes. Nous prenons le tableau 2D de nombres (généré avec chaque ligne inversée) et le transposons avec la valeur de remplissage @. Après avoir vénéré le tableau résultant et transposé à nouveau, appliquer Gce qui suit.

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

Pour obtenir la forme triangulaire souhaitée, il suffit de supprimer la valeur de remplissage.

Comment ça marche

Ṛ+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 octets

j.e+*dkjdbP.ueM+Vt

Suite de tests .

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 octets

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

L'entrée est une liste d'entiers (par exemple f([1,2,3,5,8])), la sortie est vers STDOUT. Le %10et le fait que maprenvoie un mapobjet en Python 3 est un peu ennuyeux, ce qui signifie que nous ne pouvons pas fairemap(lambda*x:sum(x)%10,L,L[1:]) ou similaire.

La fonction fait une erreur, mais la sortie serait alors terminée. Merci à @xsot pour -1 octet en trouvant un bon endroit pour coller le print.

05AB1E , 20 19 17 octets

Code:

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

Explication:

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.

Utilise l' encodage CP-1252 . Essayez-le en ligne! .

MATL, 32 30 29 28 27 26 25 24 octets

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

1 octet sauvé grâce à @Luis

Essayez-le en ligne!

Version modifiée pour tous les cas de test

Explication

        % 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

En fait, 43 octets

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

Essayez-le en ligne!

Ce programme imprime une seule nouvelle ligne de fin après la sortie.

Explication:

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

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

Exemple:

CJam, 25 octets

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

Essayez-le en ligne!

Explication

Cela utilise une astuce assez soignée pour générer la disposition du triangle.

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 octets

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 octets

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

Basé sur la réponse de @ Sp3000 . La fonction \accepte un tableau en entrée et renvoie une chaîne.

Essayez-le en ligne!

Pyke, 21 octets

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

Essayez-le ici!

J'aimerais penser que cette méthode est un peu différente.

[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 octets

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

Explication:

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

Exemple:

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 octets

En utilisant GOTO au lieu de l'un des WHILE, j'ai pu jouer au golf à 3 personnages

Golfé

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

Essayez-le en ligne (en utilisant l'ancien script avec 2 * PENDANT)

Java 7, 230 215 213 octets

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

Cela a fini par être un peu plus long que je ne le pensais.

Quelques octets enregistrés grâce à @GiacomoGarabello .

Code non testé et testé:

Essayez-le ici.

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

Sortie:

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 octets

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

Le +18 est pour using System.Linq;

Merci à @TheLethalCoder pour avoir économisé 13 octets, en signalant une instruction using inutile

JavaScript (ES6), 77 octets

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

C, 138 octets

Golfé

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

Non golfé

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 octets

Je suis en fait assez fier de cette solution, les expressions lambda sont si amusantes une fois que vous les maîtrisez

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

ici non golfé pour de nouvelles améliorations:

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

essayez-le ici

Haskell, 139 octets

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)

Prend l'entrée comme argument, sort vers STDOUT.

Version non golfée:

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 octets

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

Imprime une seule nouvelle ligne de fin.

Comment ça marche

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

Essayez-le sur Ideone

J, 44 octets

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

Basé sur cette solution .

Javascript (en utilisant une bibliothèque externe) (198 octets)

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}

Lien vers la bibliothèque: https://github.com/mvegh1/Enumerable/

Explication du code: Cela a été facile à utiliser la bibliothèque! Ne gagne pas en octets, mais le code n'est pas trop verbeux et facile à lire. Ainsi, l'entrée "n 'est un tableau d'entiers. Chargez-la dans la bibliothèque, stockée dans la variable" a "." B "est la chaîne de retour, stockez la chaîne jointe avec" "comme délimiteur dans b. C est le itération en cours, utilisez-la pour déterminer le nombre d'espaces à insérer. REMARQUE: cela ne semble fonctionner correctement que lorsque l'entrée est comprise entre 0 et 9. Ensuite, bien que vrai, répétez un certain ensemble de code. Ce code sert à créer un lot adjacent ensembles de l'énumérable courant "a", c'est-à-dire que si nous avons [1,2,3,4,5,6] nous obtenons [1,2], [2,3], [3,4], ... [ 6] ... puis filtrez-le afin que nous ayons seulement les lots de taille 2. Ensuite, nous mappons cela à une collection des sommes des lots% 10. Si a est vide, nous avons terminé, sinon nous ajoutons la nouvelle ligne à notre retour. Enfin revenez ...

Image à venir dans quelques minutes.