Sfida:

Ingresso: Tre numeri interi: lunghezza del bordo inferiore; quantità iniziale di granelli di sabbia; indice

Produzione: genera lo stato della parte inferiore di una clessidra in corrispondenza dell'indice dato, in base alla lunghezza del bordo inferiore e alla quantità di granelli di sabbia indicati.

Regole della sfida:

Simuliamo i granelli di sabbia con le cifre 1-9
Mettiamo la quantità attualmente rimasta di granelli di sabbia nella parte superiore nel mezzo, seguita da un singolo carattere di tua scelta (esclusi cifre, spazi bianchi e nuove linee; cioè - ) sulla riga sottostante
Quando la clessidra viene riempita, la riempiamo per riga, una cifra alla volta
Quando la sabbia può andare a sinistra oa destra, andiamo SEMPRE a destra (lo stesso vale per bilanciare la quantità rimanente di granelli di sabbia sopra la clessidra)
Quando abbiamo raggiunto il 9 è pieno e non possiamo più inserire sabbia in quel punto specifico nella clessidra
Anche la quantità di granelli di sabbia rimasta è sempre correttamente allineata
Una volta che la metà inferiore della clessidra è completamente riempita, o la quantità di granelli di sabbia rimasta raggiunge 0, non possiamo andare oltre, e questo sarebbe l'output per tutti gli indici oltre questo punto
Sono consentiti sia l'indicizzazione 0 sia l'indicizzazione 1 e si prega di specificare ciò che è stato utilizzato nella risposta.
Gli spazi finali e iniziali e una singola riga finale finale o iniziale sono facoltativi
Puoi utilizzare qualsiasi altro carattere anziché uno zero per riempire gli spazi vuoti della parte inferiore della clessidra (esclusi cifre, nuove righe o il carattere che hai usato come collo), se scegli di visualizzarli.
La lunghezza del bordo inferiore sarà sempre dispari
La lunghezza del bordo inferiore sarà >= 3; e la quantità di granelli di sabbia>= 0
Se lo desideri, puoi anche stampare tutti gli stati fino all'indice dato incluso
Puoi presumere che l'indice (0-indicizzato) non sarà mai maggiore della quantità totale di granelli di sabbia (quindi quando ci sono 100 granelli di sabbia, l'indice 100 è il massimo indice di input valido).
Il primo indice (0 per 0-indicizzato; 1 per 1-indicizzato) produrrà una clessidra vuota con la quantità di granelli di sabbia sopra di esso.

Esempio: immagini (o ascii-art) dicono più di mille parole, quindi ecco un esempio:

Inserisci la lunghezza del bordo inferiore: 5
inserisci la quantità di granelli di sabbia: 100
invece di un indice corrente, visualizzo tutti i passaggi qui:

Output per tutti gli indici possibili con lunghezza del bordo inferiore 5e quantità di granelli di sabbia 100:

Quindi come esempio:

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

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

Regole generali:

Questo è code-golf , quindi vince la risposta più breve in byte.
Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti, programmi completi. La tua chiamata.
Le scappatoie predefinite sono vietate.
Se possibile, aggiungi un link con un test per il tuo codice.
Inoltre, si prega di aggiungere una spiegazione, se necessario.

Casi 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

— Kevin Cruijssen
fonte

1

Per 5,100,10000il motivo per cui lo fa 20+9+9+9+9+9+9+9+9+9 = 101?

— Neil,

@Neil cambierò un po 'le regole in modo che l'indice non possa mai andare oltre la somma totale. Probabilmente meglio da capire.

— Kevin Cruijssen,

3

Correlati

— Laikoni

il primo input è sempre un numero dispari?

— Brian H.

@BrianH. " La lunghezza del bordo inferiore sarà sempre strana " Mi rendo conto di avere un po 'troppe regole in questa sfida, quindi posso capire che hai letto oltre. :)

— Kevin Cruijssen il

3

05AB1E , 68 63 59 57 56 byte

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

Provalo online!

Spiegazione

IÅÉÅ9
Inizializziamo lo stack con un elenco di un elenco di 9.
Ogni elenco rappresenta una riga, quindi la lunghezza di ciascun elenco è dispari e la lunghezza dell'ultimo elenco è uguale al primo input.
Un input di 5 comporterebbe[[9], [9, 9, 9], [9, 9, 9, 9, 9]]

[DOO²Q#ćD_Piˆëć<¸«¸ì]
Quindi passiamo in rassegna questi elenchi diminuendo gli elementi in un elenco fino a quando l'elenco è composto solo da zero, per poi passare al successivo. Ci fermiamo quando la somma totale è uguale al secondo input.

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

Ora dobbiamo annullare l'ordine dell'elenco finale simulando la rimozione di elementi dai lati alternati anziché da sinistra a destra, come abbiamo fatto.

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

Ora formattiamo correttamente l'output

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
fonte

Veramente? È stato così complicato?

— Magic Octopus Urn

@MagicOctopusUrn: sei il benvenuto a superarmi :) Alcune cose su questo metodo sono diventate un po 'confuse a causa di stranezze linguistiche che non ho trovato un modo migliore per aggirare. Forse c'è un modo migliore del tutto? Forse qualcosa di più matematico?

— Emigna,

Stavo pensando di usare i numeri binari in qualche modo ... non l'ho pensato completamente, non avevo un'ora libera.

— Magic Octopus Urn

È passato un po 'di tempo da quando ho provato a superare una delle tue soluzioni di oltre 20 byte. Mi vergogno un po 'ad ammetterlo, ma quando vedo le tue risposte di solito non perdo tempo a cercare miglioramenti; perché di solito non riesco a trovare nessun ah!

— Magic Octopus Urn

@MagicOctopusUrn: Peccato. Di solito riesci a trovare interessanti alternative (e / o miglioramenti) alle mie soluzioni. I programmi di grandi dimensioni nelle lingue del golf sono sicuramente più difficili da impiegare con certezza.

— Emigna,

5

Pulito , 305 289 byte

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

Provalo online!

— Οurous
fonte

1

@KevinCruijssen Risolto.

— Οuroso

1

Perl 5 , 301 byte

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

Provalo online!

— Xcali
fonte

1

Carbone di legna , 68 63 62 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Modifica: 5 byte salvati rimuovendo il controllo dell'intervallo dell'indice ora non necessario. Spiegazione:

ＮθＮηＮζ

Inserisci la lunghezza in q, il numero di granelli di sabbia he l'indice in z.

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

Passa sopra le (q+1)/2righe (dal basso verso l'alto), quindi 9 grani in ogni cella della riga, quindi passa sopra le cifre della riga.

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

Passa alla cifra.

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

Se possibile, distribuire un granello di sabbia su questa cifra, diminuendo la quantità di sabbia e l'indice rimasti. Se abbiamo superato l'indice, ciò converte comunque gli spazi in zeri, riempiendo la clessidra. La cifra viene stampata verso l'alto perché ciò significa che il cursore si troverà sul collo dopo l'ultima cifra.

↑-

Stampa il collo.

Ｍ⊘⊖ＬＩη←Ｉη

Centra e stampa la quantità di sabbia rimasta.

— Neil
fonte

Parte inferiore della clessidra

Sfida:

Regole della sfida:

Regole generali:

Casi test:

05AB1E , 68 63 59 57 56 byte

Pulito , 305 289 byte

Perl 5 , 301 byte

Carbone di legna , 68 63 62 byte