Compte à rebours

Votre objectif pour ce défi de code-golf est de décompter et de recycler les nombres. Laissez-moi expliquer.

Votre application lit d'abord un nombre, soit comme argument de programme, soit en utilisant stdin. Ensuite, vous devrez simplement décompter comme ceci: 10 9 8 7 6( par ordre décroissant )

Mais attendez, il y a plus!

Recyclage

Il y a des situations où nous pouvons imprimer chaque numéro, mais ne pas énumérer tous les numéros, nous pouvons recycler! Permettez-moi de donner un exemple rapide:

Input: 110

Output:   11091081071061051041031021010099... etc
Recycled:  10                        1

Nous avons maintenant répertorié tous les nombres, 110, 109, 108, mais nous avons recyclé un 0 et un 1 .

Un autre exemple:

Input: 9900

Output:   9900989989897989698959894... etc
Recycled:        9 98  

Défi de golf de code

• Lire un nombre (argument ou stdin)
• Afficher le compte à rebours dans l' ordre décroissant tout en recyclant tous les nombres possibles (vers stdout ou file)
• Arrêtez-vous lorsque vous atteignez 1 OU au moment où vous avez recyclé 0 à 9 (quoi qu'il arrive en premier)

Exemple simple (jusqu'à 1 atteint):

Input: 15
Output: 15141312110987654321

(Notice the 110 instead of 1110)

Exemple plus avancé (tous recyclés):

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 166 158 153 145 142 128 117

Après avoir abordé cela d'une manière nouvelle, j'ai réussi à descendre à 145 (142 après quelques ajustements mineurs), pas trop minable. Cela signifie que je pourrai peut-être concourir pour l'argent ou le 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

Cela n'imprime pas une liste, il sélectionne les résultats. La question n'a jamais donné de détails sur la sortie, donc ça devrait aller. Cela a toujours la même limite de 100 sur l'entrée, en partie parce que j'abuse du fait que chaque 11ème terme sous 100 perd un caractère et en partie à cause de la limite de récursivité par défaut de 100 sur les expressions de table communes.

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

Le retrait de premier niveau est l'espace, le deuxième niveau est le caractère de tabulation.

Haskell, 154 149 147 145 128 120 119 117 octets

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

l'ajout de la vérification du recyclage coûte beaucoup de caractères ... soupir

golfé un peu en se rappelant quels chiffres n'étaient pas encore recyclés et en s'arrêtant lorsque la liste est vide. puis joué un peu plus au golf en passant à la récursivité explicite et à quelques autres tours.

exemple de sortie:

*Main> h 110
"110910810710610510410310210100998979695949392919089887868584838281807978776757473727170696867665646362616059585756554535251504948474645443424140393837363534332313029282726252423221"

Python 2: 119 117

Marquer cela comme un wiki communautaire parce que c'est juste une version plus golfée de la réponse 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

Rubis, 145 139 130 octets

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}

Approche similaire à celle de Will, sauf que je n'utilise pas un masque de bits, mais un tableau de chiffres inutilisés à la place. L'entrée se fait via STDIN.

Il existe une version alternative à la whileplace de timesmais quoi que j'essaye, le nombre d'octets est le même:

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 Caractères

Probablement pas du tout optimisé, mais après beaucoup d'optimisations et de débogage, voici la conversion directe de ma réponse ES6 dans CJam:

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

Essayez-le en ligne ici . La fonction prend le nombre comme STDIN et sort le compte à rebours recyclé, s'arrêtant entre les deux si le recyclage est terminé.

Je vais essayer de jouer au golf plus loin.

Comment ça fonctionne:

L'idée de base est que pour chaque numéro de compte à rebours C, vérifiez si les premiers chiffres H sont égaux aux derniers chiffres H de la chaîne résultante, où H va du nombre de chiffres de C à 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 caractères

Ces personnages verbeux, beaucoup, 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}

Exécutez-le dans la dernière console Web de Firefox.

Après l'exécution, il crée une méthode Cque vous pouvez utiliser comme

C(12)
12110987654321

MISE À JOUR : Parfois, l'ancien simple returnest plus court que la fermeture de la fonction flèche :)