Wie viele einzigartige Primzahlen?


14

Eine Möglichkeit, eine natürliche Zahl darzustellen, besteht darin, Exponenten von Primzahlen zu multiplizieren. Zum Beispiel kann 6 durch 2 ^ 1 * 3 ^ 1 dargestellt werden und 50 kann durch 2 ^ 1 * 5 ^ 2 dargestellt werden (wobei ^ die Exponierung anzeigt). Die Anzahl der Primzahlen in dieser Darstellung kann dazu beitragen, festzustellen, ob die Verwendung dieser Darstellungsmethode im Vergleich zu anderen Methoden kürzer ist. Da ich diese aber nicht von Hand berechnen möchte, brauche ich ein Programm, das das für mich erledigt. Da ich mir das Programm jedoch merken muss, bis ich nach Hause komme, muss es so kurz wie möglich sein.

Deine Aufgabe:

Schreiben Sie ein Programm oder eine Funktion, um zu bestimmen, wie viele verschiedene Primzahlen in dieser Darstellung einer Zahl enthalten sind.

Eingang:

Eine ganze Zahl n mit 1 <n <10 ^ 12, die mit einer normalen Methode ermittelt wird.

Ausgabe:

Die Anzahl der unterschiedlichen Primzahlen, die für die Darstellung der Eingabe erforderlich sind, wie in der Einführung erläutert.

Testfälle:

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)

Dies ist OEIS A001221 .

Wertung:

Dies ist , die niedrigste Punktzahl in Bytes gewinnt!


3
So viele Hauptfragen in letzter Zeit! Ich liebe es.
Giuseppe


3
Der Grund für die Ablehnung könnte seine Trivialität sein. Soweit ich sehen konnte, gibt es 3 Situationen, wenn es um Golfsprachen geht: 1. Eingebaut 2. Kette von zwei Eingebauten 3. Kette von 3 Eingebauten (ich persönlich habe drei 2-Byte-Antworten); Ich weiß nicht, ob das ein solider Grund für eine Ablehnung ist, aber es ist eine mögliche Ursache
Mr. Xcoder

1
Könnte sein, aber ich würde es begrüßen, wenn einer der drei Downvoter mir das gesagt hätte. Während es ist in Golf - Sprachen trivial, gibt es ein paar interessanten Lösungen in nicht Golf spielenden Sprachen, die diejenigen sind , die ich sehen wollte , als ich diese Herausforderung geschrieben. Schließlich gibt es auf der Website viele Herausforderungen, die für Golflangs trivial sind, aber interessante Nicht-Golflang-Lösungen hervorbringen.
Gryphon

1
Es wäre vorteilhaft, eine Primzahl in die Testfälle aufzunehmen. Außerdem sind einige Sprachen / Ansätze nur schwer auf große Zahlen zu testen. Ein paar kleinere Testfälle wären schön.
Dennis

Antworten:



5

05AB1E , 2 Bytes

eine weitere ziemlich langweilige Antwort ...

fg

Ein vollständiges Programm, das eine numerische Eingabe akzeptiert und das Ergebnis druckt

Probieren Sie es online!

Wie?

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

5

Mathematica, 7 Bytes

PrimeNu

Ja, da ist ein eingebautes.

Mathematica, 21 Bytes

Length@*FactorInteger

Der weite Weg.


Was ist der Grund für das Sternchen? Ist das nicht Length@FactorIntegerdasselbe?
Numbermaniac

1
Length@*FactorIntegerproduziert eine reine Funktion: die Zusammensetzung von Lengthund FactorInteger. Ich kann definieren fun=Length@*FactorIntegerund dann anrufen fun[1001]. Auf der anderen Seite Length@FactorIntegerwürde bedeuten Length[FactorInteger]und bewerten 0.
Mischa Lawrow


4

Python 2, 56 Bytes

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

Ist das eine Antwort von Dennis hier ?
Jonathan Allan

1
@JonathanAllan Ja, geändert, um stattdessen eindeutige Primfaktoren zu zählen.
Orlp

4

Retina , 31 30 Bytes

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

Die Eingabe ist unär.

Vielen Dank an @MartinEnder für das Golfen von 1 Byte!

Probieren Sie es online! (einschließlich Dezimal-Unär-Umrechner)

Wie es funktioniert

Da das Programm aus einem einzelnen regulären Ausdruck mit dem &Modifikator besteht, zählt Retina einfach die Anzahl überlappender Übereinstimmungen. Es wird angenommen, dass die Eingabe aus n Wiederholungen von 1 besteht und nichts anderem besteht.

Der negative Ausblick

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

an Stellen Einstimmungen zwischen 1 s, die nicht von zwei oder mehr gefolgt 1 s '( 11+), gefolgt durch eine oder mehr Wiederholungen der gleichen Menge an 1 ‚s ( \1+), durch das Ende der Eingabe folgt ( $).

Jede zusammengesetzte Zahl ab mit a, b> 1 kann geschrieben werden als b Wiederholungen eine Wiederholung von 1 , so dass die Look - Ahead - Standorten entspricht nur gefolgt von p Wiederholungen von 1 , wobei p = 1 oder p ist eine Primzahl.

Der Regex

(11+)$

stellt sicher , p> 1 durch mindestens zwei bedürftigen 1 ‚s ( 11+) und speichert der Schwanz von 1 ‘ in der zweiten Einfanggruppe s ( \2).

Endlich der positive Lookbehind

(?<=^\2+)

überprüft, ob die gesamte Eingabe aus kp Vorkommen ( k ≥ 1 ) von 1 besteht , und überprüft, ob p die Eingabe teilt.

Somit entspricht jede Übereinstimmung einem eindeutigen Primteiler p .


4

Bash + GNU-Dienstprogramme, 33

  • Dank @Dennis 1 Byte gespart
factor|grep -Po ' \d+'|uniq|wc -l

Probieren Sie es online aus .

Erläuterung

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

1
grep -Po ' \d+'Speichert ein Byte über tr \ \\n|sed 1d.
Dennis

Scheitert leider grep -Po '( \d+)\1*'bei Eingabe 46 .
Dennis

@ Tennis Dank - Ich habe es mit Ihrem ursprünglichen Vorschlag behoben
Digital Trauma

3

Gelee , 3 Bytes

eine ziemlich langweilige Antwort ...

ÆFL

Ein monadischer Link, der eine Nummer aufnimmt und eine Nummer zurückgibt

Probieren Sie es online!

Wie?

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

1
Wie hast du vermisst Æv?
Mein Pronomen ist monicareinstate

Es war einfach - ich hatte nie eine Verwendung dafür und habe die Liste im Wiki nicht durchsucht.
Jonathan Allan

Wie schreibst du Jelly-Zeichen ohne Atomliste und Quicks-Liste?
Mein Pronomen ist monicareinstate

1. Æist Alt-Code 0198. 2. Sie können eine Tastatur einrichten (ich habe nicht). 3. Die Codepage.
Jonathan Allan



3

Alice , 10 Bytes

/o
\i@/Dcd

Probieren Sie es online!

Erläuterung

/o
\i@/...

Dies ist nur das Standardframework für lineare arithmetisch anspruchsvolle Programme, die dezimale E / A benötigen. Das eigentliche Programm selbst ist dann nur:

Dcd

Welches tut:

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.

3

JavaScript 45 Bytes

* Für @SEJPM fordern Sie eine Erklärung an: Was ich hier tue, ist, dass ich von 2 - n gehe (was sich ändert und schließlich der größte Primfaktor sein wird) - jetzt, wenn die aktuelle Zahlenteilung ni es nur einmal zählen möchte (gerade) obwohl es ein Faktor von 2 * 2 * 2 * 3 sein kann - 2 wird einmal gezählt) - so kommt das "j" zum Bild, wenn j im Aufruf der Funktion nicht angegeben ist - j erhält den Wert von " undefined ", und wenn n% i == 0, dann rufe ich die Funktion mit j = 1 beim nächsten Aufruf auf) - und dann addiere ich nur 1, wenn j gleich undefined ist, was! j + Funktion ist (n / i, i, ( j = 1 oder nur 1)). ich ändere i in dieser Angelegenheit nicht, weil es noch durch i wieder teilbar sein kann (2 * 2 * 3), aber dann wird j gleich 1 und es wird nicht als ein Faktor gezählt. Ich hoffe, ich habe es gut genug erklärt.

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);

Wenn die letzte Primzahl sehr groß ist, hat sie einen maximalen Aufrufstapel. Wenn dies ein Problem ist, kann ich eine iterative ausführen


Würde es Ihnen etwas ausmachen, eine Erklärung für diese Antwort zu schreiben? Es scheint einen gewöhnlichen Ansatz aus dem Rest der Antworten zu verwenden.
SEJPM

@ SEJPM Ich habe dort eine Erklärung hinzugefügt
DanielIndie

1
Zu Ihrer Information können wir für die Mehrzahl der Code-Golf-Herausforderungen unendliche Call-Stacks / unendliche Ressourcen annehmen (sofern in der Frage nicht anders angegeben).
Jonathan Allan








2

R + numbers, 30 14 bytes

16 bytes removed thanks to @Giuseppe

numbers::omega

Also, here is the Try it online!! link per @Giuseppe.


You may omit the f=function(x) and the (x) as numbers::omega is a function already. However, as numbers is not standard for R, you should make your answer "R + numbers". Also, you should include a TIO link. Still, +1, very nice.
Giuseppe

@Giuseppe, you are too nice. Thanks for your help. BTW, in addition to some of your insightful answers, I checked out Tips for golfing in R, as you suggested. There are some real gems there. Anywho, I will update my answer with your recommendations. Also, your MATL solution is very nice (+1 yesterday).
Joseph Wood

NP, feel free to ping me in chat or comment on an answer of mine if you have questions.
Giuseppe

@Giuseppe is there a meta consensus on needing to explicitly state "R + numbers"? It seems like if we state the additional package then we should be able to save the bytes of explicitly calling it with numbers::. Otherwise, to me it's the same as using an import in any other language.
BLT

(scrolls down and sees a python example of this...) I guess I'm wondering about a broader meta consensus, then. It just sort of seems silly to me.
BLT



1

Haskell, 58 bytes

-4 bytes thanks to @Laikoni

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

Try it online!

Explanation

Essentially generates all primes at most as large as n and filters them for being a factor of n and then takes the length of the result.

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

You can use sum[1|x<- ... ] instead of length.
Laikoni

1

Japt, 5 4 bytes

â èj

Try it

Get the divisors (â) and count (è) the primes (j).


1

ARBLE, 28 bytes

len(unique(primefactors(n)))

Try it online!

This is a very literal solution


I was looking at this and going "Hey, wait a minute, this is a snippet!" And then I see... is this supposed to be a non-esoteric language with implicit IO?!
totallyhuman

@icrieverytim Congratulations, you have discovered one of the main reasons this language exists.
ATaco


0

Python 2,  63  55 bytes

A much more interesting answer...

-8 bytes thanks to Jonathan Frech (use an argument with a default for the post-adjustment of the result of primes from 0 to 1 -- much better than a wrapping lambda!!)

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

A recursive function taking a positive integer, n, and returning a positive integer, the count.

Try it online! Really inefficient, don't even bother with the other test cases.



@JonathanFrech Thanks, that is much cleaner.
Jonathan Allan

0

J, 12 bytes

{:@$@(__&q:)

q: is J's prime exponents function, giving it the argument __ produces a matrix whose first row is all nonzero prime factors and whose 2nd row is their exponents.

We take the shape $ of that matrix -- rows by columns -- the number of columns is the answer we seek.

{: gives us the last item of this two items (num rows, num columns) list, and hence the answer.

Try it online!



0

Javascript ES6, 56 chars

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")

Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.