Dado um número inteiro N, imprima o Nnúmero positivo th Kcom a seguinte propriedade na base decimal:

Para cada dígito Ina posição Pde K, o número formado Kremovendo o Pdígito (ie I) é divisível por I.

Exemplo e observações

324 é esse número:

• 3 divide 24
• 2 divide 34
• 4 divide 32

Nota 1: assumimos que o número vazio é divisível por qualquer coisa, como 0. Portanto 1, 2, 3, 4, 5, 6, 7, 8e 9são válidos.

Nota 2: K não pode conter o dígito 0, pois você não pode dividir por 0.

Entradas e saídas

• Você pode considerar a entrada como argumento de função, até STDINetc.
• Você pode retornar a saída de uma função, através de STDOUTetc.
• Você pode indexar esses números começando em 0(nesse caso N >= 0) ou em 1(nesse caso N > 0), o que mais lhe convier.

Casos de teste

Esses exemplos são indexados de 0, portanto, se você indexou de 1, adicione 1os números na Ncoluna.

N    Output
0    1
4    5
8    9
15   77
16   88
23   155
42   742
47   1113
121  4244
144  6888
164  9999

Pontuação

Isso é código-golfe , então a resposta mais curta em bytes vence.

Geléia , 21 19 bytes

DLR©œ^€®ịDḌḍ@DPȧµ#Ṫ

A entrada é indexada em 1. Experimente online!

Como funciona

DLR©œ^€®ịDḌḍ@DPȧµ#Ṫ  Main link. No arguments.

                µ    Convert the chain to the left into a link.
                 #   Read n from STDIN and execute the link to the left for
                     k = 0, 1, 2, ... until n value return a truthy value.
D                      Convert D to base 10 (digit array).
 LR                    Construct the range from 1 to the length of the digit array.
   ©                   Copy the range to the register.
       ®               Yield the value of the register.
    œ^€                Take the multiset difference of each element of the range
                       and the range itself.
        ịD             Index into the digit array.
          Ḍ            Convert each list of digits to integer.
                       This yields all numbers with one suppressed digit.
           ḍ@D         Test each of these numbers for divisibility by the
                       suppressed digit from the digit array.
              P        Take the product of the resulting Booleans.
               ȧ       Logical AND with k (k would return 1).
                  Ṫ  Tail; extract the last (nth) element.

Pyth, 20

e.f!s.e.x%s.D`Zksb1`

Experimente aqui ou execute o Test Suite

N é 1 indexado para esta resposta.

Usa basicamente a mesma lógica do meu script python. Diferenças notáveis ​​estão sendo usadas .Dpara excluir o dígito da sequência durante o teste e usando o tratamento de exceções para lidar com zero dígitos.

Pitão, 26 bytes

e.f&!/J`Z\0!s%VsM.DLJUJjZT

Suíte de teste.

e.f&!/J`Z\0!s%VsM.DLJUJjZT
e.f                          The n-th number (Z) where:
    !/J`Z\0                      Z does not contain "0"
   &                             and
           !s                    the following does not contain zero:
               sM.DLJUJ              generate the set of the digits removed
                       jZT           all the digits
             %V                      modulus in parallel
                                     if Z is 324,
                                     the first set would be [24,34,32]
                                     the second set would be [3,2,4]
                                     the third set would be [24%3, 34%2, 32%4]

Python 2, 93 bytes

n=input();r=0
while n:r+=1;k=t=1;exec't&=(r/k/10*k+r%k)%(r/k%10or r)<1;k*=10;'*r;n-=t
print r

Muito ineficiente. A entrada é indexada em 1. Teste em Ideone .

Versão alternativa, 100 bytes

O código acima realiza aproximadamente 10 ^x testes de divisibilidade, onde apenas x é necessário. À custa de apenas sete bytes extra , a eficiência pode ser melhorada drasticamente, quer por substituição *rcom *len(`r`)ou por refatorando o código como se segue.

n=input();r=0
while n:
 r+=1;k=t=1
 for _ in`r`:t&=(r/k/10*k+r%k)%(r/k%10or r)<1;k*=10
 n-=t
print r

Isso lida com todos os casos de teste com facilidade, mesmo no Ideone .

JavaScript (ES6), 82 78 76 bytes

f=(n,k=0)=>n?f(n-!eval(/0/.test(++k)+`${k}`.replace(/./g,"|'$`$''%$&")),k):k

A entrada é indexada em 1. Funciona construindo uma sequência do formuláriofalse|'24'%3|'34'%2|'32'%4 e avaliando-o. As strings são usadas porque ainda são sintaticamente válidas no caso de um dígito.

A recursão limita isso a cerca de n = 119. Versão iterativa para 88 84 82 bytes:

n=>{for(k=0;n;n-=!eval(/0/.test(++k)+`${k}`.replace(/./g,"|'$`$''%$&")));return l}

Editar: salvou 2 bytes graças a @ Dennis ♦.

Ruby, 90

f=->n,s=?0{0while s.next![?0]||s[1]&&/t/=~s.gsub(/\d/){eval"#$`#$'%#$&>0"};n<1?s:f[n-1,s]}

Abordagem semelhante à resposta Javascript de Neil, mas significativamente mais longa devido à falta de conversão implícita de tipo (exceto que os booleanos são convertidos em strings por gsub, o que é bom).

Ruby, 109 bytes

->n{i=s=1;n.times{s=?0;s="#{i+=1}"while s[?0]||(0...x=s.size).any?{|i|(s[0,i]+s[i+1,x]).to_i%s[i].to_i>0}};s}

Hoon , 246 bytes

=+
x=0
|=
n/@
=+
k=<x>
=+
%+
levy
%+
turn
(gulf 0 (dec (lent k)))
|=
a/@
=+
(trim +(a) k)
=+
(rash (snag a p) dit)
?:
=(- 0)
|
=(0 (mod (fall (rust (weld (scag a p) q) dem) x) -))
(curr test &)
?:
=(- &)
?:
=(0 n)
x
$(n (dec n), x +(x))
$(x +(x))

Ungolfed:

=+  x=0
|=  n/@
=+  k=<x>
=+  %+  levy
  %+  turn  (gulf 0 (dec (lent k)))
  |=  a/@
  =+  (trim +(a) k)
  =+  (rash (snag a p) dit)
  ?:  =(- 0)
    |
  =(0 (mod (fall (rust (weld (scag a p) q) dem) x) -))
(curr test &)
?:  =(- &)
  ?:  =(0 n)
    x
  $(n (dec n), x +(x))
$(x +(x))

Isso ... é realmente terrível. Sinto-me sujo por postar isso.

Defina kpara a forma de sequência do número atual, mapeie a lista [0...(length k)-1]dividindo a sequência nesse índice ( a). Pegue o apersonagem, analise-o em um número e, se for, 0retorne não. Obtenha o prefixo de ae solde-o na outra metade da divisão, analise um número, verifique se o índice o divide uniformemente.

++levyretorna yes se chamar a função em todos os elementos da lista também for yes. Nesse caso, a função foi ++testrespondida com yes, portanto, verifica se todos os caracteres estão kfuncionando.

Se estivermos no 0º valor, retornamos o número atual, ou então recorremos com n decrementado (e incrementado x)