Un modo per rappresentare un numero naturale è moltiplicando gli esponenti dei numeri primi. Ad esempio, 6 possono essere rappresentati da 2 ^ 1 * 3 ^ 1 e 50 possono essere rappresentati da 2 ^ 1 * 5 ^ 2 (dove ^ indica esponenzione). Il numero di numeri primi in questa rappresentazione può aiutare a determinare se è più breve usare questo metodo di rappresentazione, rispetto ad altri metodi. Ma poiché non voglio calcolarli a mano, ho bisogno di un programma per farlo per me. Tuttavia, poiché dovrò ricordare il programma fino a quando non torno a casa, deve essere il più breve possibile.

Il tuo compito:

Scrivi un programma o una funzione per determinare quanti numeri primi distinti ci sono in questa rappresentazione di un numero.

Ingresso:

Un numero intero n tale che 1 <n <10 ^ 12, preso con qualsiasi metodo normale.

Produzione:

Il numero di numeri primi distinti necessari per rappresentare l'input, come indicato nell'introduzione.

Casi test:

24      -> 2 (2^3*3^1)
126     -> 3 (2^1*3^2*7^1)
1538493 -> 4 (3^1*11^1*23^1*2027^1)
123456  -> 3 (2^6*3^1*643^1)

Questo è OEIS A001221 .

punteggio:

Questo è code-golf , il punteggio più basso in byte vince!

— Grifone
fonte

3

Tante domande importanti di recente! Lo adoro.

— Giuseppe,

2

Correlati

— Mr. Xcoder l'

3

Il motivo dietro il downvote potrebbe essere la sua banalità. Per quanto ho potuto vedere, ci sono 3 situazioni in cui si parla di lingue del golf: 1. built-in 2. catena di due built-in 3. catena di 3 built-in (personalmente ho tre risposte a 2 byte); Non so se questa sia una solida ragione per un downvote, ma è una possibile causa

— Mr. Xcoder

1

Potrebbe essere, ma apprezzerei se uno dei tre downvoters avrebbe commentato dirmi questo. Sebbene sia banale nelle lingue del golf, ci sono alcune soluzioni interessanti nelle lingue non del golf, che sono quelle che volevo vedere quando ho pubblicato questa sfida. Dopotutto, ci sono molte sfide sul sito che sono banali per i golflang, ma producono interessanti soluzioni non golflang.

— Gryphon,

1

Sarebbe utile includere un numero primo nei casi di test. Inoltre, alcune lingue / approcci sono difficili da testare per grandi numeri. Alcuni casi di test più piccoli sarebbero belli.

— Dennis,

6

MATL , 4 3 byte

-1 byte grazie a Luis Mendo

YFz

Provalo online!

YF         Exponents of prime factors
  z        Number of nonzeros

Risposta originale:

Yfun

Provalo online!

Una Yfunrisposta ver .

          (Implicit input)
Yf         Prime factorization
  u        Unique
   n       Numel
           (Implicit output)

— Giuseppe
fonte

1

Perché divertente? - ;-)

— Adám

1

Crossed 4 è ancora regolare 4

— Gryphon,

5

05AB1E , 2 byte

^{un'altra risposta piuttosto noiosa ...}

fg

Un programma completo che accetta un input numerico e stampa il risultato

Provalo online!

Come?

fg - implicitly take input
f  - get the prime factors with no duplicates
 g - get the length
   - implicit print

— Jonathan Allan
fonte

5

Mathematica, 7 byte

PrimeNu

Sì, c'è un built-in.

Mathematica, 21 byte

Length@*FactorInteger

La lunga strada da percorrere.

— Misha Lavrov
fonte

Qual è il motivo dell'asterisco? Non è Length@FactorIntegerlo stesso?

— numbermaniac,

1

Length@*FactorIntegerproduce una funzione pura: la composizione di Lengthe FactorInteger. Posso definire fun=Length@*FactorIntegere quindi chiamare fun[1001]. D'altra parte, Length@FactorIntegersignificherebbe Length[FactorInteger]e valuterebbe 0.

— Misha Lavrov,

5

Gaia , 2 byte

^{Ancora un'altra risposta piuttosto noiosa ... --- J. Allan}

ḋl

Provalo online!

ḋ- La scomposizione in fattori primi come coppie [prime, esponenti] .
l - Lunghezza

— Mr. Xcoder
fonte

4

Python 2, 56 byte

f=lambda n,p=2,k=1:n/p and[f(n,p+1),k+f(n/p,p,0)][n%p<1]

— orlp
fonte

È forse una risposta alla porta di Dennis qui ?

— Jonathan Allan,

1

@JonathanAllan Sì, modificato per contare invece fattori primi unici.

— orlp

4

Retina , 31 30 byte

&`(?!(11+)\1+$)(11+)$(?<=^\2+)

L'input è in unario.

Grazie a @MartinEnder per il golf di 1 byte!

Provalo online! (include convertitore da decimale a unario)

Come funziona

Dal momento che il programma è costituito da un unico regex con il & modificatore, Retina conta semplicemente la quantità di partite sovrapposte . Si presume che l'input sia composto da n ripetizioni di 1 e nient'altro.

Lo sguardo negativo

(?!(11+)\1+$)

corrisponde a posizioni tra 1 che non sono seguite da due o più 1 ( 11+), seguite da una o più ripetizioni della stessa quantità di 1 (( \1+), seguite dalla fine di input ( $).

Qualsiasi numero composto ab con a, b> 1 può essere scritto come b ripetizioni di una ripetizione di 1 , quindi il lookahead corrisponde solo a posizioni seguite da p ripetizioni di 1 , dove p = 1 o p è primo.

La regex

(11+)$

si assicura p> 1 richiedendo almeno due 1 (11+ ) e memorizza la coda di 1 ' nel secondo gruppo di acquisizione ( \2).

Finalmente l'aspetto positivo

(?<=^\2+)

verifica che l'intero input sia costituito da occorrenze kp ( k ≥ 1 ) di 1 , verificando che p divida l'input.

Pertanto, ogni corrispondenza corrisponde a un divisore primo unico p .

— Dennis
fonte

4

Utilità Bash + GNU, 33

1 byte salvato grazie a @Dennis

factor|grep -Po ' \d+'|uniq|wc -l

Provalo online .

Spiegazione

factor|                            # Split input into prime factors
       grep -Po ' \d+'|            # group factors onto lines
                       uniq|       # remove duplicates
                            wc -l  # count the lines

— Trauma digitale
fonte

1

grep -Po ' \d+'salva un byte sopra tr \ \\n|sed 1d.

— Dennis,

Sfortunatamente, grep -Po '( \d+)\1*'non riesce per l'ingresso 46 .

— Dennis,

@Dennis grazie - L'ho corretto usando il tuo suggerimento originale

— Digital Trauma,

3

Gelatina , 3 byte

^{una risposta piuttosto noiosa ...}

ÆFL

Un collegamento monadico che prende un numero e restituisce un numero

Provalo online!

Come?

ÆFL - Link: number, n
ÆF  - prime factorisation as a list of prime, exponent pairs
  L - length

— Jonathan Allan
fonte

1

Come ti sei perso Æv?

— mio pronome è monicareinstate l'

È stato facile: non ci ho mai avuto modo di utilizzarlo e non ho cercato nella lista sul wiki.

— Jonathan Allan,

Come si digitano i personaggi in gelatina senza l'elenco degli atomi e l'elenco dei rapidi?

— mio pronome è monicareinstate l'

1. Æè il codice alt 0198. 2. Puoi configurare una tastiera (non l'ho fatto). 3. La tabella codici.

— Jonathan Allan,

3

Ohm v2 , 2 byte

ml

Provalo online!

I due built-in si trovano uno accanto all'altro nella documentazione lol.

— totallyhuman
fonte

3

Gelatina , 2 byte

^{Ancora un'altra risposta piuttosto noiosa ... --- J. Allan}

Æv

Provalo online!

Un built-in.

— Mr. Xcoder
fonte

3

Alice , 10 byte

/o
\i@/Dcd

Provalo online!

Spiegazione

/o
\i@/...

Questo è solo il framework standard per i programmi lineari con aritmetica pesante che richiedono I / O decimali. Il programma vero e proprio è quindi solo:

Dcd

Che fa:

D    Deduplicate prime factors. Does what it sounds like: for every p^k which
     is a divisor n, this divides n by p^(k-1).
c    Push the individual prime factors of n. Since we've deduplicated them
     first, the number of factors is equal to the value we're looking for.
d    Push the stack depth, i.e. the number of unique prime factors.

— Martin Ender
fonte

3

JavaScript 45 byte

* Per la richiesta di @SEJPM una spiegazione: cosa sto facendo qui sta andando da 2 - n (che cambia, e alla fine sarà il più grande fattore primo) - ora se l'attuale divisione del numero ni vuole contarlo solo una volta (anche anche se può essere un fattore di 2 * 2 * 2 * 3 - 2 viene conteggiato una volta) - quindi la "j" viene visualizzata in figura, quando j non è specificato nella chiamata della funzione - j riceverà il valore di " undefined ", e quando n% i == 0 allora chiamo la funzione con j = 1 nella prossima chiamata) - e poi aggiungo solo 1 quando j è uguale a non definito che è! j + Funzione (n / i, i, ( j = 1 o solo 1)). non cambio in questa materia perché potrebbe essere ancora divisibile per i (2 * 2 * 3) ma j sarà uguale a 1 e non verrà considerato come un fattore. spero di averlo spiegato abbastanza bene.

P=(n,i=2,j)=>i>n?0:n%i?P(n,i+1):!j+P(n/i,i,1)

console.log(P(1538493)==4);
console.log(P(24)==2);
console.log(P(126)==3);
console.log(P(123456)==3);

Espandi frammento

se l'ultimo numero primo è molto grande di quello che avrà lo stack massimo di chiamate, se è un problema posso farne uno iterativo

— DanielIndie
fonte

Ti dispiacerebbe scrivere una spiegazione per questa risposta? Sembra usare un approccio abituale dal resto delle risposte.

— SEJPM

@SEJPM ho aggiunto alcune spiegazioni lì

— DanielIndie,

1

Cordiali saluti, possiamo assumere stack di chiamate infiniti / risorse infinite per la maggior parte delle sfide del code-golf (in pratica, a meno che la domanda non indichi diversamente).

— Jonathan Allan,

3

CJam , 7 5 byte

Grazie a Martin Ender per 2 byte di sconto!

{mF,}

Blocco anonimo (funzione) che prevede il numero di input nello stack e lo sostituisce con il numero di output.

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

{   }   e# Define block
 mF     e# List of (prime, exponent) pairs
   ,    e# Length

— Luis Mendo
fonte

3

Brachylog , 3 byte

ḋdl

Provalo online!

Spiegazione

ḋ      Prime decomposition
 d     Remove duplicates
  l    Length

— Fatalize
fonte

2

Pyth, 3 byte

l{P

Suite di test

Lunghezza ( l) dell'insieme ( {) dei fattori primi ( P) dell'input.

— isaacg
fonte

2

Buccia , 3 byte

Lup

Provalo online!

Spiegazione

  p  -- prime factors
 u   -- unique elements
L    -- length

— ბიმო
fonte

2

In realtà , 2 byte

^{Ancora un'altra risposta piuttosto noiosa ... --- J. Allan}

yl

Provalo online!

Il primo carattere può essere sostituito da w.

— Mr. Xcoder
fonte

Basta così, amico ...: P

— totalmente umano l'

@icrieverytim Prometto questo è il mio ultimo golf -Language risposta (ho solo 4: P)

— Mr. Xcoder

2

Pyke , 3 byte

P}l

Provalo qui!

— Mr. Xcoder
fonte

2

Python 3 , 68 67 byte

1 byte rimosso grazie a @ Mr.Xcoder

lambda n:sum(n%k<all(k%j for j in range(2,k))for k in range(2,n+1))

Questo è scaduto per i più grandi casi di test. Provalo online!

— Luis Mendo
fonte

67 byte

— Mr. Xcoder l'

2

Numeri R +, 30 14 byte

16 byte rimossi grazie a @Giuseppe

numbers::omega

Inoltre, ecco il Provalo online !! link per @Giuseppe.

— Joseph Wood
fonte

Si può omettere il f=function(x)e il (x)come numbers::omegaè una funzione già. Tuttavia, poiché numbersnon è standard per R, dovresti rispondere "R + numeri". Inoltre, è necessario includere un collegamento TIO . Comunque, +1, molto carino.

— Giuseppe,

@Giuseppe, sei troppo carino. Grazie per l'aiuto. A proposito, oltre ad alcune delle tue perspicaci risposte, ho dato un'occhiata ai Suggerimenti per giocare a golf a R , come mi hai suggerito. Ci sono alcune vere gemme lì. Comunque, aggiornerò la mia risposta con i tuoi consigli. Inoltre, la tua MATLsoluzione è molto bella (+1 ieri).

— Joseph Wood,

NP, sentiti libero di chiamarmi in chat o commentare una mia risposta se hai domande.

— Giuseppe,

@Giuseppe esiste un meta consenso sulla necessità di indicare esplicitamente "numeri R +"? Sembra che se dichiariamo il pacchetto aggiuntivo, dovremmo essere in grado di salvare i byte di chiamarlo esplicitamente con numbers::. Altrimenti, per me è lo stesso che usare un importin qualsiasi altra lingua.

— BLT,

(scorre verso il basso e vede un esempio di pitone di questo ...) Immagino che mi stia chiedendo un meta consenso più ampio, quindi. Mi sembra sciocco.

— BLT,

1

Convesso , 3 byte

mF,

Provalo online!

— GamrCorps
fonte

1

Pari / GP , 5 byte

Non so perché si chiama nu in Mathematica ma omega in Pari / GP.

omega

Provalo online!

— alephalpha
fonte

1

Haskell , 58 byte

-4 byte grazie a @Laikoni

f n=sum[1|x<-[2..n],gcd x n>1,all((>)2.gcd x)[2..x-1]]

Provalo online!

Spiegazione

In sostanza, genera tutti i numeri primi al massimo ne li filtra per essere un fattore di n, quindi prende la lunghezza del risultato.

f n=                                                   -- main function
    sum[                                             ] -- output the length of the list
        1|x<-[2..n],                                   -- consider all potential primes <=n
                                                       -- and insert 1 into the list if predicates are satisfied
                    gcd x n>1,                         -- which are a factor of n
                              all(          )[2..x-1]  -- and for which all smaller numbers satisfy
                                  (>)2.                -- 2 being larger than
                                       gcd x           -- the gcd of x with the current smaller number

— SEJPM
fonte

Puoi usare sum[1|x<- ... ]invece di length.

— Laikoni,

1

Japt, 5 4 byte

â èj

Provalo

Prendi i divisori ( â) e conta ( è) i primi ( j).

— ispido
fonte

1

ARBLE , 28 byte

len(unique(primefactors(n)))

Provalo online!

Questa è una soluzione molto letterale

— ATACO
fonte

Stavo guardando questo e dicendo "Ehi, aspetta un minuto, questo è un frammento!" E poi vedo ... questo dovrebbe essere un linguaggio non esoterico con IO implicito ?!

— totalmente umano il

@icrieverytim Complimenti, hai scoperto uno dei motivi principali per cui questa lingua esiste.

— ATaco,

0

Dyalog APL , 17 byte

⎕CY'dfns'
≢∪3pco⎕

Provalo online!

— Uriel
fonte

0

Python 2 , 63 55 byte

^{Una risposta molto più interessante ...}

-8 byte grazie a Jonathan Frech (utilizzare un argomento con un valore predefinito per la post-regolazione del risultato dei numeri primi da 0a 1- molto meglio di un lambda avvolgente !!)

f=lambda n,o=1:sum(n%i+f(i,0)<1for i in range(2,n))or o

Una funzione ricorsiva che prende un numero intero positivo ne restituisce un numero intero positivo, il conteggio.

Provalo online! Davvero inefficiente, non preoccuparti nemmeno degli altri casi di test.

— Jonathan Allan
fonte

55 byte .

— Jonathan Frech,

@JonathanFrech Grazie, è molto più pulito.

— Jonathan Allan,

0

J, 12 byte

{:@$@(__&q:)

q: è la funzione principale degli esponenti di J, dandogli l'argomento __ produce una matrice la cui prima riga è costituita da tutti i fattori primi diversi da zero e la cui seconda riga sono i loro esponenti.

Prendiamo la forma $di quella matrice - righe per colonne - il numero di colonne è la risposta che cerchiamo.

{: ci dà l'ultimo elemento di questo elenco di due elementi (num righe, num colonne), e quindi la risposta.

Provalo online!

— Giona
fonte

0

Java (OpenJDK 9) , 67 byte

n->{int c=0,p=1;for(;p<n;)if(n%++p<1)for(c++;n%p<1;n/=p);return c;}

Provalo online!

— Olivier Grégoire
fonte

0

Javascript ES6, 56 caratteri

n=>eval(`for(q=2,r=0;q<=n;++q)n%q||(n/=q,r+=!!(n%q--))`)

Test:

f=n=>eval(`for(q=2,r=0;q<=n;++q)n%q||(n/=q,r+=!!(n%q--))`)
console.log([24,126,1538493,123456].map(f)=="2,3,4,3")

Espandi frammento

— Qwertiy
fonte

Quanti numeri primi unici?

Il tuo compito:

Ingresso:

Produzione:

Casi test:

punteggio:

MATL , 4 3 byte

05AB1E , 2 byte

Come?

Mathematica, 7 byte

Mathematica, 21 byte

Gaia , 2 byte

Python 2, 56 byte

Retina , 31 30 byte

Come funziona

Utilità Bash + GNU, 33

Spiegazione

Gelatina , 3 byte

Come?

Ohm v2 , 2 byte

Gelatina , 2 byte

Alice , 10 byte

Spiegazione

JavaScript 45 byte

CJam , 7 5 byte

Spiegazione

Brachylog , 3 byte

Spiegazione

Pyth, 3 byte

Buccia , 3 byte

Spiegazione

In realtà , 2 byte

Pyke , 3 byte

Python 3 , 68 67 byte

Numeri R +, 30 14 byte

Convesso , 3 byte

Pari / GP , 5 byte

Haskell , 58 byte

Japt, 5 4 byte

ARBLE , 28 byte

Dyalog APL , 17 byte

Python 2 , 63 55 byte

J, 12 byte

Java (OpenJDK 9) , 67 byte

Javascript ES6, 56 caratteri