¡El profesor de matemáticas chiflado quiere codificar toda su investigación usando un sistema que seguramente engañará incluso al más astuto de sus competidores!

Con este fin, el profesor ha decidido cambiar la base no solo del número que está escribiendo, sino de cada dígito en ese número, según el lugar en el que se encuentra el dígito (contando desde la derecha, comenzando con 1). Por ejemplo:

El número 0 tiene un dígito, por lo que se representa en la base 1: 0

El número 1 tendría un dígito en base diez, pero en el sistema de nuestro profesor eso no es válido. ¡El primer lugar está reservado solo para los dígitos de base 1! Esto significa que debe ser golpeado al segundo lugar donde se permite la base 2: 10

El número 2 requiere que se escriba al menos la base 3: 100

Pero ahora el número 3 se puede escribir cambiando el dígito en segundo lugar: 110

y 4 como tal: 200

Aquí hay algunos ejemplos más para ayudarlo a tener la idea:

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

Usando este sistema, las notas del profesor no tendrán sentido para nadie más que para ellos, ¡y finalmente podrán conquistar el mundo! Duerme bien por la noche.

Por supuesto, el método de codificación debe ser lo más oscuro posible.

Su tarea es escribir 10 fragmentos de código, cada uno representando uno de los 10 dígitos base

0 1 2 3 4 5 6 7 8 9

que cuando se combina en el orden del número a convertir producirá un número escrito en el sistema de numeración diabólica del profesor (el método de salida puede ser de su elección, pero debe ser un número legible por humanos usando solo los dígitos 0-9)

Por ejemplo, si mis fragmentos son:

0 = MONO 1 = EJEMPLO, 2 = CÓDIGO, 3 = GOLF y 9 = PRUEBA

luego

19 = EJEMPLO DE PRUEBA -> 3010

20 = CODEMONKEY -> 3100

21 = CÓDIGO EJEMPLO -> 3110

22 = CÓDIGO DE CÓDIGO -> 3200

23 = CODEGOLF -> 3210

No es necesario tener en cuenta números de entrada con más de 10 dígitos o números negativos, aunque si desea escribir el código para dígitos adicionales obtendrá felicitaciones adicionales. Este es el código de golf, por lo que la respuesta más corta (usando el total de bytes combinados de todos los fragmentos) gana y no se permiten las lagunas estándar.

ANEXO: Antes de que alguien comience a determinar si 0 es la representación correcta de 0 en la base 1, me gustaría recordarle que este profesor está loco. Vive con ello.

Mathematica (entorno REPL), 858 bytes totales

Aquí está el fragmento de código de 86 bytes para el dígito 9:

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

Los fragmentos de código para los dígitos del 1 al 8 son idénticos, excepto que el 9 se reemplaza por el dígito apropiado. El fragmento de código para el dígito 0 es idéntico, excepto que +9simplemente se elimina.

a~IntegerDigits~MixedRadix@Range[b,1,-1]calcula la lista de los dígitos del sistema de números factoriales de a, siempre que bsea ​​al menos tan grande como el número de dígitos; FromDigitsConvierte esa lista de dígitos en un entero regular de base 10 para fines de salida. (Si alguno de los elementos de la lista excede de 9, sucede algo gracioso).

En el entorno REPL de Mathematica, los cálculos pueden terminarse con punto y coma para suprimir la salida; entonces solo se mostrará la última salida en una cadena separada por punto y coma. Definimos recursivamente el número entero adesignado por los fragmentos, y también un límite ben el número de dígitos del sistema factorial necesarios. El comando ValueQ@a||(a=0;b=3)inicializa estas variables si no se han inicializado (es decir, en el primer fragmento) y, de lo contrario, las deja solas; luego a=10a+9;b++realiza la recursividad. Finalmente, la inicial 1;es para pegar los fragmentos juntos: multiplica los cálculos intermedios por 1 (que nunca vemos de todos modos).

Goruby, 790 810 980

Aquí hay un segundo intento, basado en el hecho de que, básicamente en cualquier shell, imprimir un retorno de carro ("\ r") sin una nueva línea ("\ n") sobrescribirá la línea impresa previamente, asegurando en última instancia que solo se imprima el último bit (es decir, el resultado final) se muestra.

Esto debe ejecutarse en un shell, por ejemplo ruby name_of_file.rb.

Funciona para números positivos de longitud sin restricciones.

El código contiene diez copias del fragmento a continuación, con X(en la parte superior) reemplazado con los dígitos del 0 al 9, uno por fragmento.

->*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}

Es decir, el fragmento que representa (por ejemplo) 8 se vería así:

->*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}

El desafío establece que los fragmentos deben "combinarse" para crear un número de varios dígitos, por lo tanto, para agregar un dígito a un número, simplemente colóquelo entre corchetes al final del número. Por lo tanto, el número 103 (en decimal) sería:

->*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}[]]]