Come individuarli

Prendi un numero intero positivo k. Trova i suoi divisori . Trova i fattori primi distinti di ciascun divisore . Somma tutti questi fattori insieme. Se questo numero (somma) è un divisore di k ( se la somma divide k ), allora questo numero k è un numero BIU

Esempi

Prendiamo il numero 54
Trova tutti i divisori: [1, 2, 3, 6, 9, 18, 27, 54]
Trova i fattori primi distinti di ciascun divisore
NOTA: Nel caso di 1prendiamo come fattore primo distinto1

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

Ora prendiamo la somma di tutti questi fattori primi che
1+2+3+2+3+3+2+3+3+2+3=27
27dividono 54 (non lascia residui)
Quindi, 54 è un numero BIU .

Un altro esempio (rapido) per i k=55
divisori: [1,5,11,55]
somma di fattori primi distinti: NON1+5+11+5+11=33
33 è un divisore di 55, ecco perché NON è un numero BIU .55

Numeri BIU

Ecco i primi 20:

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

ma questo elenco continua e ci sono molti numeri BIU che attendono di essere scoperti da te!

La sfida

Dato un numero intero n>0come input , genera l' ennesimo numero BIU

Casi test

Input-> Output

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

Questo è codegolf. Vince la risposta più breve in byte!

Gelatina , 16 15 byte

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

Provalo online!

Woohoo per i builtin (ma a volte si nascondono misteriosamente da me, quindi -1 byte grazie a @HyperNeutrino )

Come funziona

Æ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 byte

µNNÑfOO>Ö

Utilizza la codifica 05AB1E . Provalo online!

Mathematica, 85 byte

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

Buccia , 13 byte

!fṠ¦ö→ΣṁoupḊN

Provalo 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

In realtà , 16 byte

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

Provalo online!

Spiegazione:

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

Pyth , 22 byte

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

Provalo qui!

Questa è la mia prima soluzione Pyth in assoluto, ho iniziato ad impararla grazie ai consigli di alcuni utenti molto gentili in chat: -) ... Mi ci sono voluti circa un'ora per risolverlo.

Spiegazione

ef | qZ1!% Zhssm {Pd * M {yP - Intero programma. Q = input.

 .f - Primi numeri interi Q con risultati veritieri, usando una variabile Z.
     qZ1 - Z è uguale a 1?
   | - OR logico.
                   {yP - Fattori primi, powerset, deduplicato.
                 * M - Ottieni il prodotto di ciascuno. Questo pezzo e ^ sono per divisori.
              m} Pd - Ottieni i fattori primi unici di ciascuno.
           ss - Appiattisci e somma.
          h - Incremento (per gestire quel 1, bah)
       % Z - Modulo l'intero corrente dalla somma sopra.
      ! - Negazione logica. 0 -> Vero,> 0 -> Falso.
e - Ultimo elemento.

Haskell , 115 byte

Tutte le comprensioni dell'elenco qui possono probabilmente essere ripulite, ma non sono sicuro di come. Suggerimenti di golf benvenuti! Provalo 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

Questa risposta è in realtà tre funzioni unite.

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)

Japt , 22 21 byte

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

Provalo

Sento che il gmetodo della funzione dovrebbe portare a una soluzione più breve, ma non riesco a capire come funziona!

Spiegazione

Input implicito di numero intero U.

@                  }a

A partire da 0, restituisce il primo numero che restituisce true quando viene passato attraverso la seguente funzione, con Xil numero corrente.

Xâ ®   Ã

Ottieni i divisori ( â) di Xe passa ciascuno attraverso una funzione.

k â

Ottieni i fattori ( k) dell'elemento corrente e rimuovi i duplicati ( â).

xx

Ridurre l'array mediante l'aggiunta dopo aver fatto lo stesso per ciascun subarray.

Ä

Aggiungi 1al risultato.

Xv

Verifica se Xè divisibile per quel numero.

J±

Incrementa J(inizialmente -1) del risultato di quel test.

¥

Controlla l'uguaglianza con U.