Le professeur de mathématiques fou veut coder toutes leurs recherches en utilisant un système qui ne manquera pas de renvoyer même les plus sages de leurs concurrents!

À cette fin, le professeur a décidé de changer la base non seulement du nombre qu'ils écrivent, mais de chaque chiffre de ce nombre, selon l'endroit où le chiffre se trouve (en comptant à partir de la droite, en commençant par 1). Par exemple:

Le nombre 0 a un chiffre, il est donc représenté en base 1: 0

Le chiffre 1 aurait un chiffre en base dix, mais dans le système de notre professeur ce n'est pas valide. La première place est réservée aux chiffres de base 1 uniquement! Cela signifie qu'il doit être ramené à la deuxième place où la base 2 est autorisée: 10

Le nombre 2 nécessite au moins la base 3 pour être écrit: 100

Mais maintenant, le nombre 3 peut être écrit en changeant le chiffre à la deuxième place: 110

et 4 ainsi: 200

Voici quelques exemples supplémentaires pour vous aider à vous faire une idée:

5: 210

6: 1000

7: 1010

8: 1100

9: 1110

10: 1200

11: 1210

12: 2000

13: 2010

14: 2100

15: 2110

16: 2200

17: 2210

18: 3000

En utilisant ce système, les notes du professeur n'auront de sens que pour eux et ils pourront enfin conquérir le monde !!!! dormez bien la nuit.

Bien sûr, la méthode de codage doit être aussi obscure que possible.

Votre tâche consiste à écrire 10 extraits de code, chacun représentant l'un des 10 chiffres de base

0 1 2 3 4 5 6 7 8 9

qui, lorsqu'il est combiné dans l'ordre du nombre à convertir, produira un nombre écrit dans le système de numérotation diabolique du professeur (la méthode de sortie peut être de votre choix mais doit être un nombre lisible par l'homme en utilisant uniquement les chiffres 0-9)

Par exemple, si mes extraits sont:

0 = SINGE 1 = EXEMPLE, 2 = CODE, 3 = GOLF et 9 = TEST

ensuite

19 = EXEMPLE -> 3010

20 = CODEMONKEY -> 3100

21 = CODEEXAMPLE -> 3110

22 = CODECODE -> 3200

23 = CODEGOLF -> 3210

Aucun numéro d'entrée avec plus de 10 chiffres ou nombres négatifs ne doit être pris en compte, mais si vous souhaitez écrire le code pour des chiffres supplémentaires, vous obtiendrez des félicitations supplémentaires. C'est le golf de code, donc la réponse la plus courte (en utilisant les totaux d'octets combinés de tous les extraits) gagne et les échappatoires standard ne sont pas autorisées.

ADDENDA: Avant que quiconque ne commence à savoir si 0 est la représentation correcte de 0 dans la base 1, je voudrais vous rappeler que ce professeur est fou. Vivre avec.

Mathematica (environnement REPL), 858 octets au total

Voici l'extrait de code de 86 octets pour le chiffre 9:

1;ValueQ@a||(a=0;b=3);a=10a+9;b++;FromDigits[a~IntegerDigits~MixedRadix@Range[b,1,-1]]

Les extraits de code pour les chiffres 1 à 8 sont identiques, sauf que le 9 est remplacé par le chiffre approprié. L'extrait de code pour le chiffre 0 est identique, sauf qu'il +9est simplement supprimé.

a~IntegerDigits~MixedRadix@Range[b,1,-1]calcule la liste des chiffres du système de nombres factoriels de a, tant qu'il best au moins aussi grand que le nombre de chiffres; FromDigitsconvertit cette liste de chiffres en un entier de base 10 normal pour les besoins de la sortie. (Si l'un des éléments de la liste dépasse 9, quelque chose de drôle se produit.)

Dans l'environnement REPL de Mathematica, les calculs peuvent être terminés par des points-virgules pour supprimer la sortie; Ainsi, seule la dernière sortie d'une chaîne séparée par des points-virgules sera affichée. Nous définissons récursivement l'entier adésigné par les extraits de code, ainsi qu'une limite bsur le nombre de chiffres du système factoriel nécessaires. La commande ValueQ@a||(a=0;b=3)initialise ces variables si elles ne sont pas initialisées (c'est-à-dire dans le premier extrait) et les laisse telles quelles dans le cas contraire; puis a=10a+9;b++effectue la récursion. Enfin, l'initiale 1;sert à coller les extraits ensemble: elle multiplie les calculs intermédiaires par 1 (ce que nous ne voyons jamais de toute façon).

Goruby, 790 810 980

Voici une deuxième tentative, reposant sur le fait que, dans pratiquement n'importe quel shell, l'impression d'un retour chariot ("\ r") sans nouvelle ligne ("\ n") écrasera la ligne précédemment imprimée, garantissant finalement que seul le dernier bit imprimé (c'est-à-dire le résultat final) est affiché.

Cela doit être exécuté dans un shell, par exemple ruby name_of_file.rb.

Cela fonctionne pour des nombres positifs de longueur illimitée.

Le code est composé de dix copies de l'extrait ci-dessous, avec X(en haut) remplacé par les chiffres de 0 à 9, un par extrait.

->*t{n,d,o="X#{t}".toi,0,''
dw{n,r=n.dm d+=1;o.pr r.ts;n>0}
$>.fu
pr"\r",o
o}

Autrement dit, l'extrait représentant (par exemple) 8 ressemblerait à:

->*t{n,d,o="8#{t}".toi,0,''
dw{n,r=n.dm d+=1;o.pr r.ts;n>0}
$>.fu
pr"\r",o
o}

Le défi indique que les extraits doivent être «combinés» pour créer un nombre à plusieurs chiffres, donc, pour ajouter un chiffre à un nombre, placez-le simplement entre crochets à la fin du numéro. Ainsi, le nombre 103 (en décimal) serait:

->*t{n,d,o="1#{t}".toi,0,''
dw{n,r=n.dm d+=1;o.pr r.ts;n>0}
$>.fu
pr"\r",o
o}[->*t{n,d,o="0#{t}".toi,0,''
dw{n,r=n.dm d+=1;o.pr r.ts;n>0}
$>.fu
pr"\r",o
o}[->*t{n,d,o="8#{t}".toi,0,''
dw{n,r=n.dm d+=1;o.pr r.ts;n>0}
$>.fu
pr"\r",o
o}[]]]