Desafío:

Entrada: tres enteros: longitud del borde inferior; cantidad inicial de granos de arena; índice

Salida: muestra el estado de la parte inferior de un reloj de arena en el índice dado, en función de la longitud del borde inferior y la cantidad de granos de arena.

Reglas de desafío:

Simulamos los granos de arena con los dígitos 1-9
Ponemos la cantidad restante de granos de arena en la parte superior en el medio, seguido de un solo carácter de su elección (excluyendo dígitos, espacios en blanco y nuevas líneas; es decir -) en la línea debajo de él.
Cuando se llena el reloj de arena, lo llenamos por fila, un dígito a la vez
Cuando la arena puede ir hacia la izquierda o hacia la derecha, SIEMPRE vamos hacia la derecha (lo mismo se aplica al equilibrio de la cantidad restante de granos de arena por encima del reloj de arena)
Cuando llegamos a 9 está lleno, y no podemos colocar más arena en ese lugar específico del reloj de arena.
La cantidad de granos de arena que quedan también siempre está alineada correctamente
Una vez que la mitad inferior del reloj de arena está completamente llena, o las cantidades de granos de arena restantes llegan a 0, no podemos ir más allá, y esta sería la salida para todos los índices más allá de este punto
Se permite tanto el índice 0 como el índice 1, y especifique lo que ha utilizado en su respuesta.
Los espacios finales y principales y una nueva línea principal o final son opcionales
Se le permite usar cualquier otro carácter en lugar de un cero para llenar los espacios vacíos de la parte inferior del reloj de arena (excluyendo dígitos, líneas nuevas o el carácter que ha utilizado como cuello), si elige mostrarlos.
La longitud del borde inferior siempre será impar
La longitud del borde inferior será >= 3; y las cantidades de granos de arena>= 0
Si lo desea, también puede imprimir todos los estados hasta el índice dado, incluido
Puede suponer que el índice (indexado a 0) nunca será mayor que la cantidad total de granos de arena (por lo tanto, cuando hay 100 granos de arena, el índice 100 es la entrada de índice válida máxima).
El primer índice (0 para 0 indexado; 1 para 1 indexado) generará un reloj de arena vacío con la cantidad de granos de arena por encima.

Ejemplo: las imágenes (o ascii-art) dicen más de mil palabras, así que aquí hay un ejemplo:

Ingrese la longitud del borde inferior: 5
ingrese la cantidad de granos de arena: en 100
lugar de un índice actual, muestro todos los pasos aquí:

Salida para todos los índices posibles con longitud de borde inferior 5y cantidad de granos de arena 100:

Entonces como ejemplo:

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

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

Reglas generales:

Este es el código de golf , por lo que la respuesta más corta en bytes gana.
No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de código. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
Se aplican reglas estándar para su respuesta, por lo que puede utilizar STDIN / STDOUT, funciones / método con los parámetros adecuados, programas completos. Tu llamada.
Las lagunas predeterminadas están prohibidas.
Si es posible, agregue un enlace con una prueba para su código.
Además, agregue una explicación si es necesario.

Casos de prueba:

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

— Kevin Cruijssen
fuente

1

5,100,10000¿ Por qué lo hace 20+9+9+9+9+9+9+9+9+9 = 101?

— Neil

@Neil Cambiaré un poco las reglas para que el índice nunca pueda ir más allá de la suma total. Probablemente mejor para entender.

— Kevin Cruijssen

3

Relacionado

— Laikoni

¿Es la primera entrada siempre un número impar?

— Brian H.

@BrianH. " La longitud del borde inferior siempre será extraña " Me doy cuenta de que tengo demasiadas reglas en este desafío, así que puedo entender que hayas leído más allá. :)

— Kevin Cruijssen

3

05AB1E , 68 63 59 57 56 bytes

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

Pruébalo en línea!

Explicación

IÅÉÅ9
Inicializamos la pila con una lista de la lista de 9.
Cada lista representa una fila, por lo que la longitud de cada lista es impar y la longitud de la última lista es igual a la primera entrada.
Una entrada de 5 daría como resultado[[9], [9, 9, 9], [9, 9, 9, 9, 9]]

[DOO²Q#ćD_Piˆëć<¸«¸ì]
Luego iteramos sobre estas listas decrementando elementos en una lista hasta que la lista consta solo de ceros, y luego pasamos a la siguiente. Nos detenemos cuando la suma total es igual a la segunda entrada.

[     #              ]   # 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

Ahora tenemos que ordenar la lista final simulando la eliminación de elementos de lados alternos en lugar de izquierda a derecha como lo hemos estado haciendo.

ć                   # 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

Ahora formateamos la salida correctamente

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

— Emigna
fuente

De Verdad? ¿Fue así de complicado?

— Urna de pulpo mágico

@MagicOctopusUrn: Eres bienvenido a superarme :) Algunas cosas sobre este método se volvieron un poco desordenadas debido a las peculiaridades del lenguaje que no he encontrado una mejor manera de evitar. Tal vez hay una mejor manera por completo? ¿Quizás algo más matemático?

— Emigna

Estaba pensando en usar números binarios de alguna manera ... no lo pensé completamente, no tuve una hora libre.

— Urna mágica del pulpo

Ha pasado un tiempo desde que intenté superar a una de sus soluciones de más de 20 bytes. Me da un poco de vergüenza admitirlo, pero cuando veo tus respuestas, generalmente ya no pierdo el tiempo tratando de encontrar mejoras; porque generalmente no puedo encontrar ningún ja!

— Urna mágica de pulpo

@MagicOctopusUrn: Lástima. Usualmente logras encontrar alternativas interesantes (y / o mejoras) a mis soluciones. Los programas grandes en idiomas de golf son ciertamente más difíciles de tomarse el tiempo para trabajar con seguridad.

— Emigna

5

Limpio , 305 289 bytes

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

Pruébalo en línea!

— Οurous
fuente

1

@KevinCruijssen Corregido.

— Precioso

1

Perl 5 , 301 bytes

($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''}

Pruébalo en línea!

— Xcali
fuente

1

Carbón , 68 63 62 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Editar: guardado 5 bytes eliminando la comprobación de rango de índice ahora innecesario. Explicación:

ＮθＮηＮζ

Ingrese la longitud q, el número de granos de arena hy el índice z.

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

Pase sobre las (q+1)/2filas (de abajo hacia arriba), luego 9 granos en cada celda de la fila, luego pase sobre los dígitos de la fila.

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

Salta al dígito.

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

Si es posible, distribuya un grano de arena a este dígito, disminuyendo la cantidad de arena e índice restante. Si hemos pasado el índice, esto todavía convierte los espacios en ceros, llenando el reloj de arena. El dígito se imprime hacia arriba porque esto significa que el cursor estará en el cuello después del último dígito.

↑-

Imprime el cuello.

Ｍ⊘⊖ＬＩη←Ｉη

Centre e imprima la cantidad de arena restante.

— Neil
fuente

Parte inferior del reloj de arena

Desafío:

Reglas de desafío:

Reglas generales:

Casos de prueba:

05AB1E , 68 63 59 57 56 bytes

Limpio , 305 289 bytes

Perl 5 , 301 bytes

Carbón , 68 63 62 bytes