O professor de matemática maluco quer codificar todas as suas pesquisas usando um sistema que certamente irá surpreender até os mais espertos de seus concorrentes!

Para esse fim, o professor decidiu alterar a base não apenas do número que está escrevendo, mas de todos os dígitos desse número, de acordo com o local em que o dígito se encontra (contando da direita, começando com 1). Por exemplo:

O número 0 tem um dígito, portanto, é representado na base 1: 0

O número 1 teria um dígito na base dez, mas no sistema de nosso professor isso não é válido. O primeiro lugar é reservado apenas para os dígitos da base 1! Isso significa que deve ser colidido com o segundo lugar em que a base 2 é permitida: 10

O número 2 requer que pelo menos a base 3 seja escrita: 100

Mas agora o número 3 pode ser escrito alterando o dígito em segundo lugar: 110

e 4: 200

Aqui estão mais alguns exemplos para ajudar você a ter uma idéia:

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 esse sistema, as anotações do professor não farão sentido para ninguém além delas, e elas poderão finalmente dominar o mundo !!!! durma bem à noite.

Obviamente, o método de codificação deve ser o mais obscuro possível.

Sua tarefa é escrever 10 trechos de código, cada um representando um dos 10 dígitos básicos

0 1 2 3 4 5 6 7 8 9

que, quando combinados na ordem do número a ser convertido, produzirá um número escrito no sistema de numeração diabólica do professor (o método de saída pode ser de sua escolha, mas deve ser um número legível por humanos usando apenas os dígitos de 0 a 9)

Por exemplo, se meus snippets forem:

0 = MACACO 1 = EXEMPLO, 2 = CÓDIGO, 3 = GOLFE e 9 = TESTE

então

19 = EXEMPLO EXEMPLO -> 3010

20 = CODEMONKEY -> 3100

21 = CODEEXAMPLE -> 3110

22 = CODECODE -> 3200

23 = CODEGOLF -> 3210

Nenhum número de entrada com mais de 10 dígitos ou números negativos precisa ser considerado; no entanto, se você quiser escrever o código para dígitos adicionais, receberá elogios extras. Isso é código de golfe, então a resposta mais curta (usando o total combinado de bytes de todos os snippets) vence e as brechas padrão não são permitidas.

ADENDO: Antes que alguém inicie se 0 é a representação correta de 0 na base 1, gostaria de lembrá-lo de que esse professor é maluco. Vive com isso.

Mathematica (ambiente REPL), 858 bytes no total

Aqui está o trecho de código de 86 bytes para o dígito 9:

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

Os trechos de código para os dígitos de 1 a 8 são idênticos, exceto que o 9 é substituído pelo dígito apropriado. O trecho de código para o dígito 0 é idêntico, exceto que ele +9é simplesmente excluído.

a~IntegerDigits~MixedRadix@Range[b,1,-1]calcula a lista dos dígitos do sistema de número fatorial a, desde que bseja pelo menos tão grande quanto o número de dígitos; FromDigitsconverte essa lista de dígitos em um inteiro base-10 regular para fins de saída. (Se algum dos elementos da lista exceder 9, algo engraçado acontece.)

No ambiente REPL do Mathematica, os cálculos podem ser finalizados com ponto e vírgula para suprimir a saída; portanto, apenas a última saída em uma cadeia separada por ponto e vírgula será exibida. Definimos recursivamente o número inteiro adesignado pelos trechos e também um limite bpara o número de dígitos do sistema fatorial necessários. O comando ValueQ@a||(a=0;b=3)inicializa essas variáveis ​​se elas não forem inicializadas (ou seja, no primeiro trecho) e as deixa em paz; depois a=10a+9;b++realiza a recursão. Finalmente, a inicial 1;é para colar os trechos: multiplica os cálculos intermediários por 1 (que nunca vemos de qualquer maneira).

Goruby, 790 810 980

Aqui está uma segunda tentativa, contando com o fato de que, basicamente, em qualquer shell, imprimir um retorno de carro ("\ r") sem uma nova linha ("\ n") substituirá a linha impressa anteriormente, garantindo, finalmente, que apenas o último bit seja impresso (ou seja, o resultado final) é mostrado.

Isso deve ser executado em um shell, por exemplo ruby name_of_file.rb.

Funciona para números positivos de comprimento irrestrito.

O código contém dez cópias do trecho abaixo, com X(na parte superior) substituídas pelos dígitos de 0 a 9, um por trecho.

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

Ou seja, o trecho que representa (por exemplo) 8 seria semelhante a:

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

O desafio afirma que os trechos precisam ser "combinados" para criar representam um número de vários dígitos; portanto, para anexar um dígito a um número, basta colocá-lo entre colchetes no final do número. Assim, o número 103 (em decimal) seria:

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