Conto alla rovescia

Il tuo obiettivo per questa sfida di code-golf è il conto alla rovescia e nel frattempo riciclare i numeri. Lasciatemi spiegare.

Prima l'applicazione legge un numero, come argomento del programma o usando stdin. Successivamente dovrai semplicemente fare il conto alla rovescia in questo modo: 10 9 8 7 6(in ordine decrescente )

Ma aspetta, c'è di più!

Raccolta differenziata

Ci sono situazioni in cui possiamo stampare ogni numero, ma non elencare ogni numero, possiamo fare il riciclaggio! Lasciami fare un rapido esempio:

Input: 110

Output:   11091081071061051041031021010099... etc
Recycled:  10                        1

Ora abbiamo ancora elencato tutti i numeri, 110, 109, 108, ma abbiamo riciclato uno 0 e un 1 .

Un altro esempio:

Input: 9900

Output:   9900989989897989698959894... etc
Recycled:        9 98  

Sfida di code-golf

• Leggi un numero (argomento o stdin)
• Stampa il conto alla rovescia in ordine decrescente mentre ricicla tutti i numeri possibili (su stdout o file)
• Fermati quando raggiungi 1 O nel momento in cui hai riciclato da 0 a 9 (qualunque cosa accada per prima)

Esempio semplice (fino a 1 raggiunto):

Input: 15
Output: 15141312110987654321

(Notice the 110 instead of 1110)

Esempio più avanzato (tutto riciclato):

Input: 110
Output:   110910810710610510410310210100998979695949392919089887868584838281807978776757473727170696867665646362616059585756554535251504948474645443424140393837363534332313029282726252423221
Recycled:  10                            9                    8                    7                    6                    5                    4                    3                    2

(We've recycled all 0-9)

T-SQL - 291 277 267 217 199 191 166 158 153 145 142 128 117

Dopo essermi avvicinato a questo in un modo nuovo, sono riuscito a scendere a 145 (142 dopo un paio di piccole modifiche), non troppo malandato. Ciò significa che potrei essere in grado di competere per argento o bronzo. ^^

DECLARE @ INT=100;WITH N AS(SELECT 1A UNION ALL SELECT A+1FROM N WHERE A<@)SELECT LEFT(A,LEN(A)-1+A%11)FROM N ORDER BY-A

Questo non stampa un elenco, seleziona i risultati. La domanda non ha mai fornito dettagli sull'output, quindi dovrebbe andare bene. Questo ha ancora lo stesso limite di 100 sull'input, in parte perché sto abusando del fatto che ogni undicesimo termine sotto 100 perde un carattere e in parte a causa del limite di ricorsione predefinito di 100 sulle espressioni di tabella comuni.

DECLARE @ INT=100;

WITH N AS
(
    SELECT 1A
    UNION ALL
    SELECT A+1
    FROM N
    WHERE A<@
)

SELECT LEFT(A,LEN(A)-1+A%11)
FROM N
ORDER BY-A

Python 143 147

def t(n):
 p=o='';r=0 # p is previous string, o is output string, r is recycled bitmap
 while n and r<1023: # 1023 is first 10 bits set, meaning all digits have been recycled
    s=`n`;i=-1 # s is the current string representation of n
       # i is from end; negative offsets count backwards in strings
    while p.endswith(s[:i])-1:i-=1 # find common ending with prev; s[:0] is '',
       # which all strings end with
    for j in s[:i]:r|=1<<int(j) # mark off recycled bits
    o+=s[i:];p=s;n-=1 # concatenate output, prepare for next number
 print o # done

Il rientro del primo livello è lo spazio, il secondo livello è il carattere tab.

Haskell, 154 149 147 145 128 120 119 117 byte

import Data.List
(r%x)n|n>0&&r<":"=[(r\\t)%(x++(show n\\t))$n-1|t<-tails x,isPrefixOf t$show n]!!0|0<1=x
h=['0'..]%""

aggiungendo nel costo del controllo del riciclaggio molti personaggi ... sospiro

ho giocato un po 'a golf ricordando quali cifre non sono state ancora riciclate e fermandosi quando l'elenco è vuoto. poi ha giocato un po 'di più passando alla ricorsione esplicita e qualche altro trucco.

esempio di output:

*Main> h 110
"110910810710610510410310210100998979695949392919089887868584838281807978776757473727170696867665646362616059585756554535251504948474645443424140393837363534332313029282726252423221"

Python 2: 119 117

Contrassegnando questo come wiki della comunità perché è solo una versione più giocosa della risposta di Will .

n=input()
d=s,={''}
exec"t=`n`;i=len(t)\nwhile(s*i)[-i:]!=t[:i]:i-=1\ns+=t[i:];d|=set(t[:i]);n-=len(d)<11;"*n
print s

Rubino, 145 139 130 byte

n=gets.to_i
d=*?0..?9
s=''
n.times{|i|j=(t=(n-i).to_s).size;j-=1 while s[-j,j]!=u=t[0,j];d-=u.chars;s=t;$><<t[j..-1];exit if[]==d}

Approccio simile a quello di Will, tranne per il fatto che non sto usando una maschera di bit, ma un array di cifre inutilizzate. L'ingresso è tramite STDIN.

Esiste una versione alternativa whileinvece di timesma qualunque cosa io provi, il numero di byte è lo stesso:

n=gets.to_i
d=*?0..?9
s=''
(j=(t=n.to_s).size;j-=1 while s[-j,j]!=u=t[0,j];d-=u.chars;s=t;$><<t[j..-1];exit if[]==d;n-=1)while 0<n

CJam, 80 77 65 57 54 Personaggi

Probabilmente non è affatto ottimizzato, ma a Dopo molte ottimizzazioni e debug ecco la conversione diretta della mia risposta ES6 in CJam:

Mr{s:C_,{:H<M_,H->=!_CH@-@}g:T>+:MCT<_O@-+:O,A<Ci(*}h;

Provalo online qui . La funzione prende il numero come STDIN ed emette il conto alla rovescia riciclato, fermandosi nel mezzo se il riciclaggio è completo.

Proverò a golf ulteriormente.

Come funziona:

L'idea di base è che per ogni numero di conto alla rovescia C, controlla se le prime cifre H sono uguali alle ultime cifre H della stringa risultante, dove H passa dal numero di cifre in C a 0

Mr                                    "Put an empty string and input on stack";
  { ... }h;                           "Run while top element of stack is true, pop when done";
s:C                                   "Store string value of top stack element in C"
   _,                                 "Put the number of characters in C to stack";
     { ... }g                         "Run while top element of stack is true";
:H<                                   "Store the digit iteration in H and slice C";
   M                                  "M is the final output string in making";
    _,H-                              "Take length of M and reduce H from it";
        >                             "Take that many digits of M from end and..."
         =!_                          "Compare with first H digits of C, negate and copy";
            CH@                       "Put C and H on stack and bring the above result to top of stack";
               -                      "Reduce H if the matched result was false";
                @                     "Bring the matched result on top in order continue or break the loop"
             :T                       "Store top stack element in T after the loop";
               >+:M                   "Take everything but first T digits of C and add it to M and update M";
                   CT<_               "Take first T digits of C and copy them";
                       O@             "Put saved digits on stack, and rotate top three elements";
                         -            "Remove all occurence of first T digits of C from O";
                          +:O         "Add first T digits of C to O and update O";
                             ,A<      "Compare number of saved digits with 10";
                                Ci(   "Decrement integer value of C and put it on stack";
                                   *  "If number of saved digits greater than 9, break loop";

JavaScript ES6, 149 146 caratteri

Tale verboso, molti personaggi, wow.

C=n=>{s=c='';while(n>0&s.length<10){j=1;while(t=(n+'').slice(0,-j++))if(c.endsWith(t)){s+=~s.search(t)?'':t;break}c+=(n--+'').slice(1-j)}return c}

Eseguilo nell'ultima console Web di Firefox.

Dopo l'esecuzione, crea un metodo Cche è possibile utilizzare come

C(12)
12110987654321

AGGIORNAMENTO : A volte, semplicemente vecchio returnè più corto della chiusura della funzione freccia :)