Défi:

Entrée: trois entiers: longueur du bord inférieur; quantité de départ de grains de sable; indice

Sortie: affiche l'état de la partie inférieure d'un sablier à l'indice donné, en fonction de la longueur du bord inférieur donné et de la quantité de grains de sable.

Règles du défi:

• Nous simulons les grains de sable avec les chiffres 1-9
• Nous plaçons la quantité restante de grains de sable en haut au milieu, suivie d'un seul caractère de votre choix (à l'exclusion des chiffres, des espaces blancs et des nouvelles lignes; c'est-à-dire -) sur la ligne en dessous
• Lorsque le sablier est rempli, nous le remplissons par ligne, un chiffre à la fois
• Lorsque le sable peut aller à gauche ou à droite, nous allons TOUJOURS à droite (il en va de même pour équilibrer la quantité restante de grains de sable au-dessus du sablier)
• Quand nous avons atteint 9, il est rempli, et nous ne pouvons plus mettre de sable à cet endroit précis dans le sablier
• La quantité de grains de sable restant est également toujours correctement alignée
• Une fois que la moitié inférieure du sablier est complètement remplie, ou que la quantité de grains de sable reste à 0, nous ne pouvons pas aller plus loin, et ce serait la sortie pour tous les index au-delà de ce point
• Les deux index 0 ou 1 sont autorisés, et veuillez spécifier ce que vous avez utilisé dans votre réponse.
• Les espaces de fin et de début et une seule nouvelle ligne de fin ou de début sont facultatifs
• Vous pouvez utiliser n'importe quel autre caractère au lieu d'un zéro pour remplir les espaces vides de la partie inférieure du sablier (à l'exception des chiffres, des nouvelles lignes ou du caractère que vous avez utilisé comme manche), si vous choisissez de les afficher.
• La longueur du bord inférieur sera toujours impaire
• La longueur du bord inférieur sera >= 3; et les quantités de grains de sable>= 0
• Si vous le souhaitez, vous êtes également autorisé à imprimer tous les états jusqu'à et y compris l'index donné
• Vous pouvez supposer que l'index (indexé à 0) ne sera jamais supérieur à la quantité totale de grains de sable (donc quand il y a 100 grains de sable, l'index 100 est l'entrée d'index valide maximale).
• Le premier indice (0 pour l'index 0; 1 pour l'index 1) produira un sablier vide avec la quantité de grains de sable au-dessus.

Exemple: les images (ou ascii-art) en disent plus que mille mots, voici donc un exemple:

Entrer la longueur du bord inférieur: 5
Entrer la quantité de grains de sable: 100
Au lieu d'un index actuel, j'affiche toutes les étapes ici:

Sortie pour tous les index possibles avec la longueur du bord inférieur 5et la quantité de grains de sable 100:

 100
  -
  0
 000
00000

  99
  -
  0
 000
00100

  98
  -
  0
 000
00110

  97
  -
  0
 000
01110

  96
  -
  0
 000
01111

  95
  -
  0
 000
11111

  94
  -
  0
 000
11211

  93
  -
  0
 000
11221

  92
  -
  0
 000
12221

  91
  -
  0
 000
12222

  90
  -
  0
 000
22222

  89
  -
  0
 000
22322

  88
  -
  0
 000
22332

  87
  -
  0
 000
23332

  86
  -
  0
 000
23333

  85
  -
  0
 000
33333

  84
  -
  0
 000
33433

  83
  -
  0
 000
33443

  82
  -
  0
 000
34443

  81
  -
  0
 000
34444

  80
  -
  0
 000
44444

  79
  -
  0
 000
44544

  78
  -
  0
 000
44554

  77
  -
  0
 000
45554

  76
  -
  0
 000
45555

  75
  -
  0
 000
55555

  74
  -
  0
 000
55655

  73
  -
  0
 000
55665

  72
  -
  0
 000
56665

  71
  -
  0
 000
56666

  70
  -
  0
 000
66666

  69
  -
  0
 000
66766

  68
  -
  0
 000
66776

  67
  -
  0
 000
67776

  66
  -
  0
 000
67777

  65
  -
  0
 000
77777

  64
  -
  0
 000
77877

  63
  -
  0
 000
77887

  62
  -
  0
 000
78887

  61
  -
  0
 000
78888

  60
  -
  0
 000
88888

  59
  -
  0
 000
88988

  58
  -
  0
 000
88998

  57
  -
  0
 000
89998

  56
  -
  0
 000
89999

  55
  -
  0
 000
99999

  54
  -
  0
 010
99999

  53
  -
  0
 011
99999

  52
  -
  0
 111
99999

  51
  -
  0
 121
99999

  50
  -
  0
 122
99999

  49
  0
 222
99999

  48
  -
  0
 232
99999

  47
  -
  0
 233
99999

  46
  -
  0
 333
99999

  45
  -
  0
 343
99999

  44
  -
  0
 344
99999

  43
  -
  0
 444
99999

  42
  -
  0
 454
99999

  41
  -
  0
 455
99999

  40
  -
  0
 555
99999

  39
  -
  0
 565
99999

  38
  -
  0
 566
99999

  37
  -
  0
 666
99999

  36
  -
  0
 676
99999

  35
  -
  0
 677
99999

  34
  -
  0
 777
99999

  33
  -
  0
 787
99999

  32
  -
  0
 788
99999

  31
  -
  0
 888
99999

  30
  -
  0
 898
99999

  29
  -
  0
 899
99999

  28
  -
  0
 999
99999

  27
  -
  1
 999
99999

  26
  -
  2
 999
99999

  25
  -
  3
 999
99999

  24
  -
  4
 999
99999

  23
  -
  5
 999
99999

  22
  -
  6
 999
99999

  21
  -
  7
 999
99999

  20
  -
  8
 999
99999

  19
  -
  9
 999
99999

Alors comme exemple:

inputs: 5,100,1
output:
  99
  -
  0
 000
00100

Same example with another valid output format:
  99
  ~
  . 
 ...
..1..

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues non-golfeur de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés, des programmes complets. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Veuillez également ajouter une explication si nécessaire.

Cas de test:

INPUTS: bottom-edge length, amount of grains of sand, index (0-indexed)

inputs: 5,100,1
output:
  99
  -
  0
 000
00100

inputs: 5,100,24
output:
  76
  -
  0
 000
45555

inputs: 5,100,100
output:
  19
  -
  9
 999
99999

inputs: 5,10,15
output:
  0
  -
  0
 000
22222

inputs: 3,30,20
output:
 10
 -
 0
677

inputs: 3,3,0
 3
 -
 0
000

inputs: 9,250,100
   150
    -
    0
   000
  00000
 2333332
999999999

inputs: 9,225,220
    5
    -
    4
   999
  99999
 9999999
999999999

inputs: 13,1234567890,250
  1234567640
      -
      0
     000
    00000
   0000000
  344444443
 99999999999
9999999999999

inputs: 25,25,25
             0
             -
             0
            000
           00000
          0000000
         000000000
        00000000000
       0000000000000
      000000000000000
     00000000000000000
    0000000000000000000
   000000000000000000000
  00000000000000000000000
 1111111111111111111111111

05AB1E , 68 63 59 57 56 octets

IÅÉÅ9[DOO²Q#ćD_Piˆëć<¸«¸ì]ćā<ΣÉ}2äćR¸ì˜è¸ì¯ìJDSOIα'-‚ì.C

Essayez-le en ligne!

Explication

IÅÉÅ9
Nous initialisons la pile avec une liste de liste de 9.
Chaque liste représente une ligne, la longueur de chaque liste est donc impaire et la longueur de la dernière liste est égale à la première entrée.
Une entrée de 5 entraînerait[[9], [9, 9, 9], [9, 9, 9, 9, 9]]

[DOO²Q#ćD_Piˆëć<¸«¸ì]
Nous parcourons ensuite ces listes en décrémentant les éléments d'une liste jusqu'à ce que la liste ne soit composée que de zéros, puis en passant à la suivante. Nous nous arrêtons lorsque la somme totale est égale à la deuxième entrée.

[     #              ]   # loop until
 DOO                     # the sum of the list of lists
    ²Q                   # equals the second input
        ć                # extract the first list
         D_Pi            # if the product of the logical negation of all elements is true
             ˆ           # add the list to the global list
              ë          # else
               ć<        # extract the head and decrement it
                 ¸«      # append it to the list
                   ¸ì    # and prepend the list to the list of lists

Maintenant, nous devons trier la liste finale simulant la suppression d'éléments des côtés alternés au lieu de gauche à droite comme nous l'avons fait.

ć                   # extract the row we need to sort
 ā<                 # push a list of indices of the elements [0 ... len(list)-1]
   ΣÉ}              # sort it by even-ness
      2äćR¸ì˜       # reverse the run of even numbers
                    # the resulting list will have 0 in the middle,
                      odd number increasing to the right and
                      even numbers increasing to the left
             è      # index into our final row with this
              ¸ì¯ì  # reattach all the rows to eachother

Maintenant, nous formaterons correctement la sortie

J              # join list of lists to list of strings
 DSOIα         # calculate the absolute difference of sum of our triangle and the 3rd input
      '-‚ì     # pair it with the string "-" and append to the list of rows
          .C   # join by newlines and center each row

Nettoyer , 305 289 octets

import StdEnv
@[h:t]|all((==)9)h|t>[]=[h: @t]=[h]
#s=length h/2
#m=hd(sort h)+1
=[updateAt(hd[e\\e<-flatten[[s+i,s-i]\\i<-[0..s]]|h!!e<m])m h:t]
$a b c=flatlines(map(cjustify(a+1))[fromString(fromInt(b-c)),['-']:reverse(map(map(toChar o(+)48))((iterate@[repeatn(a-r)0\\r<-[0,2..a]])!!c))])

Essayez-le en ligne!

Perl 5 , 301 octets

($x,$t,$u)=<>;$s=$x;$t-=$g=$t>$u?$u:$t;while($s>0){@{$a[++$i]}=((0)x$s,($")x($x-$s));$a[$i][$_%$s]++for 0..($f=$g<$s*9?$g:$s*9)-1;$g-=$f;$s-=2}say$"x(($x-length($g+=$t))/2+.5),$g,$/,$"x($x/2),'-';while(@b=@{pop@a}){for($i=1;$i<@b;$i+=2){print$b[-$i]}print$b[0];for($i=1;$i<@b;$i+=2){print$b[$i]}say''}

Essayez-le en ligne!

Charbon de bois , 68 63 62 octets

ＮθＮηＮζＦ⊘⊕θＦ⁹Ｆ⁻θ⊗ι«Ｊ⊘⎇﹪λ²⊕λ±λ±ι≔¬¬ζλ↑Ｉ⁺λＩＫＫ≧⁻λη≧⁻λζ»↑-Ｍ⊘⊖ＬＩη←Ｉη

Essayez-le en ligne! Le lien est vers la version détaillée du code. Modifier: 5 octets enregistrés en supprimant la vérification de la plage d'index désormais inutile. Explication:

ＮθＮηＮζ

Entrez la longueur dans q, le nombre de grains de sable dans het l'indice dans z.

Ｆ⊘⊕θＦ⁹Ｆ⁻θ⊗ι«

Faites une boucle sur les (q+1)/2lignes (de bas en haut), puis 9 grains dans chaque cellule de la ligne, puis bouclez sur les chiffres de la ligne.

Ｊ⊘⎇﹪λ²⊕λ±λ±ι

Passez au chiffre.

≔¬¬ζλ↑Ｉ⁺λＩＫＫ≧⁻λη≧⁻λζ»

Si possible, répartissez un grain de sable sur ce chiffre, en décrémentant la quantité de sable et l'index restant. Si nous avons réussi l'index, cela convertit toujours les espaces en zéros, remplissant le sablier. Le chiffre est imprimé vers le haut car cela signifie que le curseur sera sur le cou après le dernier chiffre.

↑-

Imprimez le cou.

Ｍ⊘⊖ＬＩη←Ｉη

Centrez et imprimez la quantité de sable restante.