Contagem regressiva

Seu objetivo para este desafio do código-golfe é contagem regressiva e, enquanto isso, reciclar números. Deixe-me explicar.

Primeiro, seu aplicativo lê um número, como argumento do programa ou usando stdin. Em seguida, basta contagem regressiva assim: 10 9 8 7 6(em ordem decrescente )

Mas espere, tem mais!

Reciclando

Há situações em que podemos imprimir todos os números, mas não listar todos os números, podemos fazer reciclagem! Deixe-me dar um exemplo rápido:

Input: 110

Output:   11091081071061051041031021010099... etc
Recycled:  10                        1

Agora, ainda listamos todos os números, 110, 109, 108, mas reciclamos um 0 e um 1 .

Outro exemplo:

Input: 9900

Output:   9900989989897989698959894... etc
Recycled:        9 98  

Desafio do código-golfe

• Leia um número (argumento ou stdin)
• Produza a contagem regressiva em ordem decrescente enquanto recicla todos os números possíveis (para stdout ou arquivo)
• Pare quando atingir 1 OU no momento em que reciclar de 0 a 9 (aconteça o que acontecer primeiro)

Exemplo simples (até 1 atingido):

Input: 15
Output: 15141312110987654321

(Notice the 110 instead of 1110)

Exemplo mais avançado (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

Depois de abordar isso de uma nova maneira, consegui chegar a 145 (142 após alguns pequenos ajustes), não muito surrados. Isso significa que eu posso competir por prata ou bronze. ^^

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

Isso não imprime uma lista, seleciona os resultados. A questão nunca forneceu detalhes sobre a saída, portanto isso deve ser bom. Isso ainda tem o mesmo limite de 100 na entrada, em parte porque estou abusando do fato de que todo 11º termo abaixo de 100 perde um caractere e em parte devido ao limite de 100 recursões padrão em expressões comuns de tabela.

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

O recuo do primeiro nível é o espaço, o segundo nível é o caractere de tabulação.

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

adicionando na verificação de reciclagem custa muitos caracteres ... suspiro

golfou um pouco lembrando quais dígitos ainda não haviam sido reciclados e parando quando a lista está vazia. depois jogou um pouco mais, passando para recursão explícita e mais alguns truques.

saída de exemplo:

*Main> h 110
"110910810710610510410310210100998979695949392919089887868584838281807978776757473727170696867665646362616059585756554535251504948474645443424140393837363534332313029282726252423221"

Python 2: 119 117

Marcando isso como wiki da comunidade, porque é apenas uma versão mais eficiente da resposta 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}

Abordagem semelhante à de Will, exceto que eu não estou usando uma máscara de bits, mas uma matriz de dígitos não utilizados. A entrada é via STDIN.

Existe uma versão alternativa usando em whilevez de, timesmas o que eu tentar, o número de bytes é o mesmo:

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 Personagens

Provavelmente nem um pouco otimizado, mas depois de muitas otimizações e depuração aqui está a conversão direta da minha resposta ES6 no CJam:

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

Experimente online aqui . A função pega o número como STDIN e gera a contagem regressiva reciclada, parando no meio se a reciclagem estiver concluída.

Vou tentar jogar mais.

Como funciona:

A idéia básica é que, para cada número de contagem regressiva C, verifique se os primeiros dígitos H são iguais aos últimos dígitos H da sequência resultante, onde H passa do número de dígitos em C para 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

Tais verbos, muitos personagens, uau.

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}

Execute-o no console mais recente do Firefox.

Após a execução, ele cria um método Cque você pode usar como

C(12)
12110987654321

ATUALIZAÇÃO : Às vezes, o velho simples returné mais curto que o fechamento da função de seta :)