cuenta regresiva

Su objetivo para este desafío de código de golf es contar y, mientras tanto, reciclar números. Dejame explicar.

Primero, su aplicación lee un número, ya sea como argumento del programa o usando stdin. A continuación, simplemente tendrá que realizar una cuenta regresiva como esta: 10 9 8 7 6(en orden descendente )

¡Pero espera, hay más!

Reciclaje

Hay situaciones en las que podemos imprimir cada número, pero no enumeramos cada número, ¡podemos reciclar! Déjame darte un ejemplo rápido:

Input: 110

Output:   11091081071061051041031021010099... etc
Recycled:  10                        1

Todavía hemos enumerado todos los números, 110, 109, 108, pero hemos reciclado un 0 y un 1 .

Otro ejemplo:

Input: 9900

Output:   9900989989897989698959894... etc
Recycled:        9 98  

Código-desafío de golf

• Leer un número (argumento o stdin)
• Imprima la cuenta regresiva en orden descendente mientras recicla todos los números posibles (para stdout o archivo)
• Deténgase cuando llegue a 1 O en el momento en que haya reciclado de 0 a 9 (pase lo que pase primero)

Ejemplo simple (hasta 1 alcanzado):

Input: 15
Output: 15141312110987654321

(Notice the 110 instead of 1110)

Ejemplo más avanzado (todo reciclado):

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

Después de abordar esto de una manera nueva, logré bajar a 145 (142 después de un par de pequeños ajustes), no muy mal. Eso significa que podría competir por plata o bronce. ^^

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

Esto no imprime una lista, selecciona los resultados. La pregunta nunca dio detalles sobre la salida, por lo que esto debería estar bien. Esto todavía tiene el mismo límite de 100 en la entrada, en parte porque estoy abusando del hecho de que cada undécimo término por debajo de 100 pierde un carácter y en parte debido al límite predeterminado de 100 recursiones en las expresiones de tabla comunes.

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

La sangría del primer nivel es espacio, el segundo nivel es char de tabulación.

Haskell, 154 149 147 145 128 120 119 117 bytes

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'..]%""

agregando en el control de reciclaje cuestan muchos personajes ... suspiro

jugué un poco al recordar qué dígitos aún no se reciclaron y al detenerse cuando la lista está vacía. luego jugué un poco más al pasar a la recursión explícita y algunos trucos más.

salida de ejemplo:

*Main> h 110
"110910810710610510410310210100998979695949392919089887868584838281807978776757473727170696867665646362616059585756554535251504948474645443424140393837363534332313029282726252423221"

Python 2: 119 117

Marcar esto como wiki comunitario porque es solo una versión más golfizada de la respuesta de 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

Ruby, 145 139 130 bytes

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}

Enfoque similar al de Will, excepto que no estoy usando una máscara de bits, sino un conjunto de dígitos no utilizados. La entrada es a través de STDIN.

Hay una versión alternativa que usa en whilelugar de timespero lo que sea que intente, el número de bytes es el mismo:

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 Personajes

Probablemente no esté optimizado, pero después de muchas optimizaciones y depuración aquí está la conversión directa de mi respuesta ES6 en CJam:

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

Pruébelo en línea aquí . La función toma el número como STDIN y genera la cuenta regresiva reciclada, deteniéndose en el medio si se completa el reciclaje.

Intentaré jugar más al golf.

Cómo funciona:

La idea básica es que para cada número C de cuenta regresiva, verifique si los primeros dígitos H son iguales a los últimos dígitos H de la cadena resultante, donde H va del número de dígitos en 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 caracteres

Tal detallado, muchos personajes, 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}

Ejecútelo en la última consola web de Firefox.

Después de ejecutarse, crea un método Cque puede usar como

C(12)
12110987654321

ACTUALIZACIÓN : a veces, el viejo plano returnes más corto que el cierre de la función de flecha :)