Como identificá-los

Tome um número inteiro positivo k. Encontre seus divisores . Encontre os fatores primos distintos de cada divisor . Soma todos esses fatores juntos. Se esse número (soma) for um divisor de k ( se a soma dividir k ), esse número k será um número BIU

Exemplos

Vamos pegar o número 54
Encontre todos os divisores: [1, 2, 3, 6, 9, 18, 27, 54]
Encontre os fatores primos distintos de cada divisor
NOTA: Para o caso 1, tomamos como fator primo distinto1

1  -> 1  
2  -> 2  
3  -> 3  
6  -> 2,3  
9  -> 3  
18 -> 2,3  
27 -> 3  
54 -> 2,3 

Agora, tomamos a soma de todos esses fatores primos e
1+2+3+2+3+3+2+3+3+2+3=27
27divide 54 (não deixa resto).
Portanto, 54 é um número BIU .

Outro exemplo (rápido) para k=55
divisores: [1,5,11,55]
soma de fatores primos distintos: NÃO1+5+11+5+11=33
33 é um divisor de 55, é por isso que NÃO é um número da BIU .55

Números BIU

Aqui estão os 20 primeiros:

1,21,54,290,735,1428,1485,1652,2262,2376,2580,2838,2862,3003,3875,4221,4745, 5525,6750,7050 ...

mas essa lista continua e há muitos números da BIU que estão esperando para serem descobertos por você!

O desafio

Dado um número inteiro n>0como entrada , de saída do número BIU enésimo

Casos de teste

Entrada-> Saída

1->1  
2->21   
42->23595  
100->118300    
200->415777    
300->800175    

Este é o codegolf . A resposta mais curta em bytes vence!

Geléia , 16 15 bytes

ÆDÆfQ€SS‘ḍ
1Ç#Ṫ

Experimente online!

Woohoo para builtins (mas eles misteriosamente se escondem de mim às vezes com -1 byte graças a @HyperNeutrino )

Como funciona

ÆDÆfQ€SS‘ḍ - define helper function: is input a BIU number?
ÆD             - divisors
  Æf           - list of prime factors
    Q€         - now distinct prime factors
      SS       - sum, then sum again ('' counts as 0)
        ‘      - add one (to account for '')
         ḍ     - does this divide the input?

1Ç#Ṫ - main link, input n
  #     - starting at 
1          - 1
        - get the first n integers which meet:
 Ç         - helper link
   Ṫ    - tail

05AB1E , 9 bytes

µNNÑfOO>Ö

Usa a codificação 05AB1E . Experimente online!

Mathematica, 85 bytes

If[#<2,1,n=#0[#-1];While[Count[(d=Divisors)@++n,1+Tr@Cases[d/@d@n,_?PrimeQ,2]]<1];n]&

Casca , 13 bytes

!fṠ¦ö→ΣṁoupḊN

Experimente online!

Explantaion

  Ṡ¦ö→ΣṁoupḊ    Predicate: returns 1 if BIU, else 0.
           Ḋ    List of divisors
       ṁ        Map and then concatenate
        oup     unique prime factors
      Σ         Sum
    ö→          Add one
  Ṡ¦            Is the argument divisible by this result
 f          N   Filter the natural numbers by that predicate
!               Index

Na verdade , 16 bytes

u⌠;÷♂y♂iΣu@%Y⌡╓N

Experimente online!

Explicação:

u⌠;÷♂y♂iΣu@%Y⌡╓N
u⌠;÷♂y♂iΣu@%Y⌡╓   first n+1 numbers x starting with x=0 where
   ÷                divisors
    ♂y              prime factors of divisors
      ♂iΣu          sum of prime factors of divisors, plus 1
  ;       @%        x mod sum
            Y       is 0
               N  last number in list

Pitão , 22 bytes

e.f|qZ1!%Zhssm{Pd*M{yP

Experimente aqui!

Esta é minha primeira solução Pyth, comecei a aprendê-la graças às recomendações de alguns usuários muito gentis no bate-papo: -) ... Demorei cerca de uma hora para resolver.

Explicação

ef | qZ1!% Zhssm {Pd * M {yP - Programa inteiro. Q = entrada.

 .f - Primeiros Q inteiros com resultados verdadeiros, usando uma variável Z.
     qZ1 - Z é igual a 1?
   | - OR lógico.
                   {yP - Fatores primos, conjunto de potência, deduplicação.
                 * M - Adquira o produto de cada um. Este chunck e ^ são para divisores.
              m} Pd - Obtenha os fatores primos exclusivos de cada um.
           ss - Achatar e somar.
          h - Incremento (para lidar com esse 1, bah)
       % Z - Modulo o inteiro atual pela soma acima.
      ! Negação lógica. 0 -> Verdadeiro,> 0 -> Falso.
e - último elemento.

Haskell , 115 bytes

Todas as compreensões da lista aqui provavelmente podem ser reduzidas, mas não sei como. Sugestões de golfe são bem-vindas! Experimente online!

x!y=rem x y<1
b n=[a|a<-[1..],a!(1+sum[sum[z|z<-[2..m],m!z,and[not$z!x|x<-[2..z-1]]]|m<-[x|x<-[2..a],a!x]])]!!(n-1)

Ungolfing

Esta resposta é na verdade três funções reunidas.

divisors a = [x | x <- [2..a], rem a x == 0]
sumPrimeDivs m = sum [z | z <- [2..m], rem m z == 0, and [rem z x /= 0 | x <- [2..z-1]]]
biu n = [a | a <- [1..], rem a (1 + sum [sumPrimeDivs m | m <- divisors a]) == 0] !! (n-1)

Japonês , 22 21 bytes

@¥(J±XvXâ ®k âÃxx Ä}a

Teste-o

Eu sinto que o gmétodo de função deve levar a uma solução mais curta, mas não consigo descobrir como ele funciona!

Explicação

Entrada implícita de número inteiro U.

@                  }a

A partir de 0, retorne o primeiro número que retorna true quando passado pela função a seguir, Xsendo o número atual.

Xâ ®   Ã

Obtenha os divisores ( â) de Xe passe cada um por uma função.

k â

Obtenha os fatores ( k) do elemento atual e remova as duplicatas ( â).

xx

Reduza a matriz adicionando depois de fazer o mesmo com cada sub-matriz.

Ä

Adicione 1ao resultado.

Xv

Teste se Xé divisível por esse número.

J±

Incremento J(inicialmente -1) pelo resultado desse teste.

¥

Verifique a igualdade com U.