Motivazione : a volte devi sapere dove ti trovi in ​​una stringa. Vuoi essere in grado di guardare qualsiasi parte di una stringa e sapere esattamente dove ti trovi, per quanto possibile.

Sfida : scrivere un programma per produrre una stringa di misura di nastro di una determinata lunghezza. Una stringa di misura del nastro descrive da sé la sua lunghezza il più spesso possibile lungo la sua stessa lunghezza.

Regole :

1. Il programma deve prendere un parametro intero positivo, per la lunghezza totale della stringa di misura del nastro
2. Per ogni stringa contigua di cifre nell'output, queste cifre devono riportare accuratamente la lunghezza dell'output finora incluso - inclusivo !
   1. Le lunghezze sono misurate dall'inizio della stringa alla fine di ogni numero
3. Nella stringa devono essere inclusi quanti più numeri di lunghezza possibile
4. Evita le ambiguità. Separatori / delimitatori possono essere usati per evitare che i numeri siano giustapposti, cioè 12dice dodici, non uno, due.
5. La stringa deve sempre riportare accuratamente la sua lunghezza totale alla fine, senza separatori finali
6. Potresti aver bisogno di più separatori per mantenere precise le lunghezze, ad esempio ecco un esempio di stringa di misura di nastro di lunghezza 4: 1--4

Esempi non prescrittivi / esaustivi:

• stringa di misura di nastro di lunghezza 1: 1
• stringa di misura di nastro di lunghezza 2: -2
• stringa di misura di nastro di lunghezza 3: 1-3
• stringa di misura di nastro di lunghezza 4: 1--4oppure -2-4(entrambe riportano le lunghezze il più spesso possibile, ovvero due volte, e terminano con la lunghezza totale corretta)
• stringa di misura di nastro di lunghezza 10: 1-3-5-7-10
• stringa di misura di nastro di lunghezza 11: 1-3-5-7--11oppure 1-3-5--8-11oppure 1-3--6-8-11oppure 1--4-6-8-11oppure -2-4-6-8-11(tutti hanno quanti più numeri di lunghezza possibile e terminano con la lunghezza totale della stringa)

Python, 50 48 47 46 byte

f=lambda x:x*"1"if x<2else f(x-len(`-x`))+`-x`

Spiegazione

Soluzione lambda ricorsiva piuttosto semplice

I nostri casi base sono 1 e 0, che sono coperti da "1"*xaltrimenti otteniamo la stringa di -xcon `-x`e anteponiamo il risultato della chiamata della funzione su len(`-x`)meno.

Mathematica, 67 57 byte

Grazie a Martin Ender per aver gettato via 10 byte!

""["1"][[#]]/._@__:>#0[#-1-IntegerLength@#]<>ToString@-#&

Funzione senza nome che accetta un argomento intero non negativo e restituisce una stringa. Praticamente l'algoritmo ricorsivo ovvio: assicurati che la stringa termini con il numero di input preceduto da a "-", quindi chiama nuovamente la funzione usando #0.

Ma c'è molto divertimento golfistico nell'implementazione dell'algoritmo. ""["1"][[#]]denota il #terzo argomento dell'espressione ""["1"]: il 0 ° argomento è il capo ""e il 1 ° argomento è visibilmente "1", il che fornisce i casi base della ricorsione. Se #supera 1, ""["1"][[#]]genera un messaggio di errore e rimane come una funzione non valutata. Ma poi /._@__:>è una regola che accetta qualsiasi funzione non valutata e la trasforma nell'espressione che viene dopo, che è la chiamata ricorsiva alla funzione originale.

Presentazione originale:

If[#<2,""["1"][[#]],#0[#-1-IntegerLength@#]<>"-"<>IntegerString@#]&

JavaScript (ES6), 49 byte

f=(n,s='',t=''+-n)=>n>1?f(n-t.length,t+s):n?n+s:s

<input type=number oninput=o.value=f(this.value)><br><textarea id=o></textarea>

Pyth, 23 byte

L?<b2*"1"b+y-bl+""_bs_b

Ha palesemente rubato la soluzione ricorsiva alla risposta del mago del grano . Inoltre, credo che questo non sia giocato correttamente.

Provalo qui!

Perl 6 , 43 byte

{[R~](-$_,{$_+.comb}...^*>-1).&{S/^\-1/1/}}

Spiegazione:

{                                         }  # A lambda.
                    ...                      # Generate a sequence...
      -$_                                    #   starting from the negated lambda argument,
         ,{        }                         #   continuing iteratively using the formula:
           $_+.comb                          #     Last element plus length of last element.
                        *>-1                 #   until we hit 0 or higher,
                       ^                         end-point not inclusive.
 [R~](                      )                # Reverse and concatenate the number sequence.
                             .&{         }   # Apply to this the transformation:
                                S/^\-1/1/    #   Remove the sign from a leading "-1".

Quindi, ad esempio, per l'input 10, genera la sequenza (-10, -7, -5, -3, -1)e da quella la stringa -1-3-5-7-10e da quella la stringa finale 1-3-5-7-10.

Provalo online .