Vor einiger Zeit habe ich mir die Primfaktorisierung von 27000 angesehen:

27000 = 2 ³ × 3 ³ × 5 ³

Das hat zwei Besonderheiten:

• aufeinanderfolgende Primzahl : Die Primzahlen sind konsekutiv: 2 ist die 1. Primzahl, 3 ist die 2. Primzahl, 5 ist die 3. Primzahl.
• konstanter Exponent : Der Exponent ist für jede Primzahl gleich (immer 3)

Mathematisch ausgedrückt:

Eine Ganzzahl x ist eine fortlauf-prime / constant-Exponentenzahl , wenn es vorhanden ist streng positive ganze Zahlen n , k , m , so dass x = p _n ^m × p _{n + 1} ^m × ... × P _{n + k} ^m , wobei p _j ist die j- te Primzahl

Ihre Aufgabe ist es zu testen, ob eine positive ganze Zahl diese Bedingungen erfüllt.

Eingang:

Eine positive ganze Zahl> 1 in jeder vernünftigen Form.

Ausgabe:

Einer von zwei Werten, von denen mindestens einer konstant sein muss, um anzuzeigen, ob die Eingabe eine fortlaufende Primzahl / Konstanten-Exponenten-Zahl ist.

Randfälle:

• Primzahlen sind truthy, da die Faktorisierung für Primzahl p ist , p ¹
• andere Zahlen, die als p ^m geschrieben werden können, wobei p eine Primzahl ist, sind ebenfalls wahr.

Regeln:

• Es gelten Standardlücken.
• Keine Sorge um den Überlauf von Ganzzahlen, aber Zahlen bis zu 255 müssen funktionieren.
• Kürzester Code in Bytes gewinnt.

Testfälle:

Wahrheit:

2
3
4
5
6
7
8
9
11
13
15
27000
456533

Falsch:

10
12
14
72
10000000

Hier ist ein Python-Skript, das einige Testfälle generiert.

Die Tatsache, dass ich eine Antwort akzeptiert habe, bedeutet nicht, dass die Herausforderung vorbei ist. Der Gewinner kann sich noch ändern!

05AB1E , 4 Bytes

Ó0ÛË

Probieren Sie es online!

Erläuterung

Ó     # get a list of prime exponents
 0Û   # remove leading zeroes
   Ë  # all remaining elements are equal

Regex (ECMAScript), 276 205 201 193 189 Bytes

Der Vergleich der Multiplizitäten (Exponenten) verschiedener Primfaktoren ist ein interessantes Problem für die Lösung mit ECMAScript Regex - das Fehlen von Rückreferenzen, die durch Iterationen einer Schleife bestehen, macht es zu einer Herausforderung, alles zu zählen. Selbst wenn das Zählen des fraglichen numerischen Merkmals möglich ist, führt ein indirekterer Ansatz oft zu einem besseren Golf.

Wie bei meinen anderen regulären ECMA-Posts gebe ich eine Spoiler-Warnung ausgeben: Ich empfehle dringend, zu lernen, wie man unäre mathematische Probleme in ECMAScript-Regex löst. Es war eine faszinierende Reise für mich, und ich möchte sie keinem verderben, der sie möglicherweise selbst ausprobieren möchte, insbesondere denen, die sich für Zahlentheorie interessieren. In diesem früheren Beitrag finden Sie eine Liste der nacheinander mit Spoiler-Tags gekennzeichneten empfohlenen Probleme, die nacheinander gelöst werden müssen.

So lesen keine weiteren , wenn Sie nicht einige erweiterte einstellige regex Magie für Sie verwöhnen wollen . Wenn Sie versuchen möchten, diese Magie selbst herauszufinden, empfehle ich dringend, zunächst einige Probleme in ECMAScript regex zu lösen, wie in dem oben verlinkten Beitrag beschrieben.

Die Hauptnutzlast eines Regex, den ich zuvor entwickelt habe, erwies sich als sehr zutreffend für diese Herausforderung. Das ist der reguläre Ausdruck, der die Primzahlen der höchsten Multiplizität findet . Meine erste Lösung dafür war sehr lang, und ich spielte sie später schrittweise ab, indem ich sie zuerst für die Verwendung von Molecular Lookahead umschrieb und dann mit einer fortschrittlichen Technik auf einfaches ECMAScript portierte , um das Fehlen von Molecular Lookahead zu umgehen , und anschließend Golf es viel kleiner als die ursprüngliche einfache ECMAScript-Lösung.

Der Teil dieses regulären Ausdrucks, der für dieses Problem gilt, ist der erste Schritt, bei dem Q ermittelt wird, der kleinste Faktor von N, der alle seine Primfaktoren teilt. Sobald wir diese Zahl haben, müssen wir nur noch N durch Q teilen, bis wir nicht mehr können. Wenn das Ergebnis 1 ist, sind alle Primzahlen gleich vielfach.

Nachdem ich eine Antwort unter Verwendung meines zuvor entwickelten Algorithmus zur Ermittlung von Q eingereicht hatte, stellte ich fest, dass diese auf eine völlig andere Weise berechnet werden kann: Ermitteln Sie den größten quadratfreien Faktor von N (unter Verwendung desselben Algorithmus wie bei meinem Carmichael-Zahlen-Regex) ). Wie sich herausstellt, ist dies überhaupt keine Schwierigkeit * im Hinblick auf das Fehlen eines molekularen Lookaheads und eines Lookbehinds mit variabler Länge (es ist nicht erforderlich, die zuvor verwendete fortschrittliche Technik einzuarbeiten), und es ist 64 Byte kürzer! Darüber hinaus entfällt die Komplexität, quadratfreies N und Prim N als unterschiedliche Sonderfälle zu behandeln, wodurch weitere 7 Byte aus dieser Lösung entfernt werden.

(Es verbleiben noch andere Probleme, die die fortgeschrittene Technik erfordern, die früher hier zum Herabsetzen der Berechnung von Q verwendet wurde, aber derzeit wird keine von ihnen durch meine PPCG-Posts dargestellt.)

Ich habe den Multiplizitätstest vor den Konsekutiv-Primzahlen-Test gestellt, weil letzterer viel langsamer ist; Wenn Sie Tests durchführen, die schneller fehlschlagen können, wird der reguläre Ausdruck für gleichmäßig verteilte Eingaben schneller. Es ist auch besser, Golf an erster Stelle zu setzen, weil es mehr Rückreferenzen verwendet (die mehr kosten würden, wenn sie zweistellig wären).

Ich konnte 4 Bytes aus dieser Regex (193 → 189) mit einem von Grimy gefundenen Trick löschen , der die Division weiter verkürzen kann, falls der Quotient garantiert größer oder gleich dem Divisor ist.

^(?=(|(x+)\2*(?=\2$))((?=(xx+?)\4*$)(?=(x+)(\5+$))\6(?!\4*$))*x$)(?=.*$\2|((?=((x*)(?=\2\9+$)x)(\8*$))\10)*x$)(?!(((x+)(?=\13+$)(x+))(?!\12+$)(x+))\11*(?=\11$)(?!(\15\14?)?((xx+)\18+|x?)$))

Probieren Sie es online!

# For the purposes of these comments, the input number = N.
^

# Assert that all of N's prime factors are of equal multiplicity
# Step 1: Find Q, the largest square-free factor of N (which will also be the smallest
# factor of N that has all the same prime factors as N) and put it in \2.
# If N is square-free, \2 will be unset.
(?=
    # Search through all factors of N, from largest to smallest, searching for one that
    # satisfies the desired property. The first factor tried will be N itself, for which
    # \2 will be unset.
    (|(x+)\2*(?=\2$))     # for factors < N: \2 = factor of N; tail = \2
    # Assert that tail is square-free (its prime factors all have single multiplicity)
    (
        (?=(xx+?)\4*$)    # \4 = smallest prime factor of tail
        (?=(x+)(\5+$))    # \5 = tail / \4 (implicitly); \6 = tool to make tail = \5
        \6                # tail = \5
        (?!\4*$)          # Assert that tail is no longer divisible by \4, i.e. that that
                          # prime factor was of exactly single multiplicity.
    )*x$
)
# Step 2: Require that either \2 is unset, or that the result of repeatedly
# dividing tail by \2 is 1.
(?=
    .*$\2
|
    (
        # In the following division calculation, we can skip the test for divisibility
        # by \2-1 because it's guaranteed that \2 <= \8. As a result, we did not need to
        # capture \2-1 above, and can use a better-golfed form of the division.
        (?=
            (              # \8 = tail / \2
                (x*)       # \9 = \8-1
                (?=\2\9+$)
                x
            )
            (\8*$)         # \10 = tool to make tail = \8
        )
        \10               # tail = \8
    )*
    x$                    # Require that the end result is 1
)

# Assert that there exists no trio of prime numbers such that N is divisible by the
# smallest and largest prime but not the middle prime.
(?!
    (                          # \11 = a factor of N
        (                      # \12 = a non-factor of N between \11 and \13
            (x+)(?=\13+$)      # \13 = a factor of N smaller than \11
            (x+)               # \14 = tool (with \15) to make tail = \13
        )
        (?!\12+$)
        (x+)                   # \15 = tool to make tail = \12
    )
    \11*(?=\11$)               # tail = \11

    # Assert that \11, \12, and \13 are all prime
    (?!
        (\15\14?)?             # tail = either \11, \12, or \13
        ((xx+)\18+|x?)$
    )
)

* Mit molekularem Lookahead ist es immer noch sauberer, ohne dass N quadratfrei ist. Dies lässt 6 Bytes fallen und ergibt eine 195 187 183-Byte- Lösung:

^(?=(?*(x+))\1*(?=\1$)((?=(xx+?)\3*$)(?=(x+)(\4+$))\5(?!\3*$))*x$)(?=((?=((x*)(?=\1\8+$)x)(\7*$))\9)*x$)(?!(((x+)(?=\12+$)(x+))(?!\11+$)(x+))\10*(?=\10$)(?!(\14\13?)?((xx+)\17+|x?)$))

# For the purposes of these comments, the input number = N.
^

# Assert that all of N's prime factors are of equal multiplicity
# Step 1: Find Q, the largest square-free factor of N (which will also be the smallest
# factor of N that has all the same prime factors as N) and put it in \1.
(?=
    (?*(x+))              # \1 = proposed factor of N
    \1*(?=\1$)            # Assert that \1 is a factor of N; tail = \1
    # Assert that tail is square-free (its prime factors all have single multiplicity)
    (
        (?=(xx+?)\3*$)    # \3 = smallest prime factor of tail
        (?=(x+)(\4+$))    # \4 = tail / \3 (implicitly); \5 = tool to make tail = \4
        \5                # tail = \4
        (?!\3*$)          # Assert that tail is no longer divisible by \3, i.e. that that
                          # prime factor was of exactly single multiplicity.
    )*x$
)
# Step 2: Require that the result of repeatedly dividing tail by \1 is 1.
(?=
    (
        # In the following division calculation, we can skip the test for divisibility
        # by \1-1 because it's guaranteed that \2 <= \8. As a result, we did not need to
        # capture \1-1 above, and can use a better-golfed form of the division.
        (?=
            (             # \7 = tail / \1
                (x*)      # \8 = \7-1
                (?=\1\8+$)
                x
            )
            (\7*$)        # \9 = tool to make tail = \7
        )
        \9                # tail = \7
    )*
    x$                    # Require that the end result is 1
)

# Assert that there exists no trio of prime numbers such that N is divisible by the
# smallest and largest prime but not the middle prime.
(?!
    (                          # \10 = a factor of N
        (                      # \11 = a non-factor of N between \10 and \12
            (x+)(?=\12+$)      # \12 = a factor of N smaller than \10
            (x+)               # \13 = tool (with \14) to make tail = \12
        )
        (?!\11+$)
        (x+)                   # \14 = tool to make tail = \11
    )
    \10*(?=\10$)               # tail = \10

    # Assert that \10, \11, and \12 are all prime
    (?!
        (\14\13?)?             # tail = either \10, \11, or \12
        ((xx+)\17+|x?)$
    )
)

Hier wird es auf Lookbehind mit variabler Länge portiert:

Regex (ECMAScript 2018), 198 195 194 186 182 Bytes

^(?=(x+)(?=\1*$)(?<=^x((?<!^\5*)\3(?<=(^\4+)(x+))(?<=^\5*(x+?x)))*))((?=((x*)(?=\1\8+$)x)(\7*$))\9)*x$(?<!(?!(\14\16?)?((xx+)\12+|x?)$)(?<=^\13+)((x+)(?<!^\15+)((x+)(?<=^\17+)(x+))))

Probieren Sie es online!

# For the purposes of these comments, the input number = N.
^

# Assert that all of N's prime factors are of equal multiplicity
# Step 1: Find Q, the largest square-free factor of N (which will also be the smallest
# factor of N that has all the same prime factors as N) and put it in \1.
(?=
    (x+)(?=\1*$)      # \1 = factor of N; head = \1
    (?<=              # This is evaluated right-to-left, so please read bottom to top.
        ^x
        (
            (?<!^\5*)        # Assert that head is no longer divisible by \6, i.e. that
                             # that prime factor was of exactly single multiplicity.
            \3               # head = \4
            (?<=(^\4+)(x+))  # \4 = head / \5 (implicitly); \3 = tool to make head = \4
            (?<=^\5*(x+?x))  # \5 = smallest prime factor of head
        )*
    )
)
# Step 2: Require that the result of repeatedly dividing tail by \1 is 1.
(
    # In the following division calculation, we can skip the test for divisibility
    # by \1-1 because it's guaranteed that \2 <= \8. As a result, we did not need to
    # capture \1-1 above, and can use a better-golfed form of the division.
    (?=
        (             # \7 = tail / \1
            (x*)      # \8 = \7-1
            (?=\1\8+$)
            x
        )
        (\7*$)        # \9 = tool to make tail = \7
    )
    \9                # tail = \7
)*
x$                    # Require that the end result is 1

# Assert that there exists no trio of prime numbers such that N is divisible by the
# smallest and largest prime but not the middle prime.
# This is evaluated right-to-left, so please read bottom to top, but switch back to
# reading top to bottom at the negative lookahead.
(?<!
    # Assert that \13, \15, and \17 are all prime.
    (?!
        (\14\16?)?           # tail = either \13, \15, or \17
        ((xx+)\12+|x?)$
    )

    (?<=^\13+)
    (                        # tail = \13
        (x+)                 # \14 = tool to make tail = \15
        (?<!^\15+)
        (
            (x+)             # \16 = tool (with \14) to make tail = \17
            (?<=^\17+)(x+)   # \17 = a factor of N smaller than \13
        )                    # \15 = a non-factor of N between \13 and \17
    )                        # \13 = a factor of N
)

Jelly , 13 6 5 Bytes

ÆEt0E

Probieren Sie es online!

Immer noch outgolfed ... (danke Erik für -1 Byte)

Erläuterung

ÆE     # get a list of prime exponents (noooo long builtin name)
  t0   # remove zeroes on both sides (leading or trailing)
    E  # all remaining elements are equal

JavaScript (ES6), 87 Byte

Gibt 0 für wahr oder eine ganze Zahl ungleich Null für falsch zurück.

f=(n,k=2,j,i)=>n%k?j*(P=d=>k%--d?P(d):d==!i)(k)|j-i|(n>1&&f(n,k+1,j||i)):f(n/k,k,j,-~i)

Probieren Sie es online!

Kommentiert

f = (                     // f() = recursive function taking:
  n,                      //   n = input
  k = 2,                  //   k = current factor
  j,                      //   j = reference exponent, initially undefined
  i                       //   i = current exponent, undefined each time we start testing
) =>                      //       the next factor
  n % k ?                 // if k is not a divisor of n:
    j * (                 //   ignore the primality of k if j is still undefined
      P = d =>            //     P() = function testing if k is prime:
        k % --d ?         //       decrement d; if d is not a divisor of k:
          P(d)            //         do a recursive call until it is
        :                 //       else:
          d == !i         //         unless i is already defined: d must not be equal to 1
                          //         (if it is: k is the next prime but does not divide n)
    )(k) |                //   initial call to P() with d = k
    j - i | (             //   if both i and j are defined, they must be equal
      n > 1 &&            //   if n is not yet equal to 1,
      f(n, k + 1, j || i) //   go on with k + 1; if j is undefined, set it to i
    )                     //   (otherwise, stop recursion and return what we have)
  :                       // else:
    f(n / k, k, j, -~i)   //   increment the current exponent and go on with n / k

CJam , 30 29 Bytes

{mFz~)-!\__W=,\0=>\-:mp1#W=&}

Probieren Sie es online!

Meine erste Antwort nach fast 2 (!) - jähriger Pause, damit kann man wohl mehr golfen. Dies ist ein Block, der Eingaben als Ganzzahl akzeptiert (kann auch für Arrays von Ganzzahlen abgebildet werden).

Erläuterung

{        e# Begin block
 mF      e# Factor input, giving an array of primes and their powers
 z~      e# Transpose and dump, giving an array of primes and an array of powers
 )-      e# Check that the powers are the same: subtract each power from the last element
 !       e# Negate to make sure they're all 0
 \__W=,  e# Get the range from 0 to the largest prime minus one
 \0=>    e# Slice that array so it only includes everything larger than the smallest prime
 \-      e# Remove the original primes from the range array
 :mp     e# Check each element for primality. If the input's primes are consecutive,
         e# this will contain no primes
 1#W=    e# Make sure a "1" is not found
 &       e# If the powers are the same AND primes are consecutive, return 1. Otherwise, 0.
}

Stax , 5 6 Bytes

╣♥qJ╬c

Führen Sie es aus und debuggen Sie es

Entpackt, ungolfed und kommentiert sieht es so aus.

|n    get the exponents of the prime factorization
0:D   trim leading zeroes
:u    array has exactly a single distinct element

Bearbeiten: Dies funktioniert nicht 512. Ich werde darüber nachdenken und hoffentlich später eine Lösung finden. Es funktioniert jetzt.

Stax , 9 Bytes

1 ist wahr, 0 ist falsch

αAG<└\{┬⌠

Führen Sie es aus und debuggen Sie es

Erläuterung

|nX0-u%x:^=      # Full Program, unpacked, implicit input
|n               # Exponents of sequential primes in factorization. (eg. 20 -> [2 0 1])
  X              # Save to X register
   0-            # Remove all '0' from array
     u%          # Get unique numbers and get length of array
       x         # Copy back the array saved to X
        :^       # Is it ascending
         =       # Are the two comparisons equal? implicit output

Kann wahrscheinlich mehr golfen werden, aber es deckt die Fälle ab, die ich in der letzten Lösung vermisst habe.

MATL , 12 11 10 Bytes

YFtgYsg)Zs

Probieren Sie es bei MATL Online!

Vielen Dank an Luis Mendo für das Entfernen der führenden Nullen. Er wies auch darauf hin, dass das Austauschen von Wahrheitswerten zulässig ist, sodass für Zahlen, die die Herausforderungsanforderungen erfüllen, und für jeden anderen positiven Wert 0 zurückgegeben wird .

Grosso Modo, dies generiert die Exponenten der sequentiellen Primfaktorisierung, entfernt führende Nullen und berechnet die Standardabweichung.

Java 10, 223 191 178 176 168 Bytes

n->{var s=new java.util.HashSet();for(int f=1,i=1,x,j;n>1;){for(x=++i,j=2;j<x;)x=x%j++<1?1:x;if(x>1){for(j=0;n%i<1&&n>(f=0);n/=i)j++;if(f<1)s.add(j);}}return s.size();}

Returns 1als truthy und >=2als Falsey.

Probieren Sie es online aus.

Erläuterung:

n->{                   // Method with integer parameter and boolean return-type
  var s=new java.util.HashSet();
                       //  Set to keep track of the prime exponents
  for(int f=1,         //  Prime-flag, starting at 1
          i=1,x,j;     //  Index and temp integers
          n>1;){       //  Loop as long as `n` is still larger than 1
    for(x=++i,         //   Set `x` to `i`, after we've increased `i` by 1 first with `++i`
        j=2;           //   Set `j` to 2 (first prime)
        j<x;)          //   Inner loop as long as `j` is still smaller than `x`
      x=x%j++<1?       //    If `x` is divisible by `j`:
         1             //     Set `x` to 1
        :              //    Else:
         x;            //     Leave `x` unchanged
    if(x>1){           //    If `x` is larger than 1 (if `i` is a prime):
      for(j=0;         //     Use `j` as counter, and set it to 0
          n%i<1        //     If `n` is divisible by `i`:
                       //      And loop as long as `n` is still divisible by `i`,
          &&n>         //      and `n` is larger than 0
              (f=0);   //      (and set `f` to 0 at the same time)
          n/=i)        //       Divide `n` by `i`
        j++;           //       And increase `j` by 1
      if(f<1)          //     If the flag `f` is now/still 0:
        s.add(j);}}    //      Add counter `j` to the Set
  return s.size();}    //  Return the amount of items in the Set
                       //  (1 being true, >=2 being false)

Einige Beispieleingaben:

n=15:

• Flagge bleibt 1 für die erste Primzahl 2 (da 15 nicht durch 2 teilbar ist).
• Das Flag geht von 1bis 0, sobald wir bei Primzahl 3 sind. Da 15 durch 3 teilbar ist, nwird 5 (15/3 ¹ ) und das Set wird [] → [1].
• Dann überprüfen wir die nächste Primzahl 5. Da 5 durch 5 teilbar ist, nwird 1 (5/5 ¹ ) und die Menge bleibt gleich ( [1] → [1]).
• Nun n=1stoppen wir also die äußere Schleife. Das Set ( [1]) enthält nur ein Element, das 1aus den beiden benachbarten Primzahlen 3 und 5 stammt. Wir geben also true zurück.

n=14:

• Flag geht von 1bis 0für die erste Primzahl 2 (da 14 durch 2 teilbar ist). nwird zu 7 (14/2 ¹ ) und das Set wird [] → [1].
• Dann prüfen wir die nächste Primzahl 3. Da 7 nicht durch 3 teilbar ist, nbleibt sie gleich und die Menge wird[1] → [1,0] .
• Dann überprüfen wir die nächste Primzahl 5. Da 7 auch nicht durch 5 teilbar ist, nbleibt sie gleich, und die Menge bleibt auch gleich ([1,0] → [1,0] ).
• Dann überprüfen wir die nächste Primzahl 7. Da 7 durch 7 teilbar ist, nwird 1 (7/7 ¹ ) und die Menge bleibt gleich ( [1,0] → [1,0]).
• Nun n=1stoppen wir also die äußere Schleife. Das Set ( [1,0]) enthält zwei Elemente, das 1aus den nicht benachbarten Primzahlen 2 und 7 und das 0aus den Primzahlen 3 und 5, sodass wir false zurückgeben.

n=72:

• Flag geht von 1bis 0für die erste Primzahl 2, da 72 durch 2 teilbar ist (mehrfach). So nwird 9 (72/2 ³ ) und das Set wird [] → [3].
• Dann überprüfen wir die nächste Primzahl 3. Da 9 durch 3 (mehrfach) teilbar ist, nwird 1 (9/3 ² ) und die Menge wird [3] → [3,2].
• Nun n=1stoppen wir also die äußere Schleife. Das Set ( [3,2]) enthält zwei Elemente, das 3von Prim 2 und das 2von Prim 3, also geben wir false zurück.

J , 16 Bytes

Vielen Dank an FrownyFrog für -8 Bytes!

(=&#+/\=@#])_&q:

Probieren Sie es online!

Meine alte Lösung:

J , 24 Bytes

[:(1=[:#@~.{.@I.}.])_&q:

Probieren Sie es online!

Erläuterung:

_&q: Hauptexponenten

{.@I.}.] Entfernt die führenden Nullen, indem das erste Nicht-Null-Element gefunden wird:

     }.   drop
       ]  from the list of exponents
{.@       as much items as the first of the 
   I.     indices of non-zero elements

1=[:#@~. prüft, ob alle verbleibenden Zahlen gleich sind:

  [:#@~.  finds the length of the list after removing the duplicates
1=        is it 1?

Schale , 11 Bytes

Λ§*≈¤≈oṗ←gp

Probieren Sie es online!

Gibt 0 aus, wenn keine fortlaufende Primzahl / konstante Exponentenzahl.

MATL , 7 Bytes

0iYFhdz

Das Ergebnis ist, 1wenn die Eingabe die Anforderung erfüllt.

Probieren Sie es online! Oder überprüfen Sie alle Testfälle

Erläuterung

0    % Push 0
i    % Push input number
YF   % Exponents of consecutive prime factors
h    % Concatenate horizontally
d    % Consecutive differences
z    % Number of nonzeros. Implicitly display

Oktave , 67 Bytes

@(x)~any(diff(find(h=histc(factor(x),primes(x))))-1)&h(h>0)==max(h)

Probieren Sie es online!

Ich glaube, dies ist die einzige Lösung, die ein Histogramm verwendet.

Erläuterung:

Auf diese Weise wird ein Histogramm erstellt, in dem die zu zählende Variable die Faktoren der Eingabe darstellt und in die Bins platziert wird primes(x), bei denen es sich um Primzahlen handelt, die kleiner als die Eingabe sind. Wir finden dann die Position der Primfaktoren, nehmen die Differenz zwischen den einzelnen Indizes und subtrahieren einen. Wenn es Elemente gibt, die nicht Null sind (dh die Differenz der Indizes von Primzahlen ist nicht 1), führt dies zu einem falschen Wert, andernfalls wird ein wahrer Wert zurückgegeben.

Wir prüfen dann, dass alle Nicht-Null-Elemente im Histogramm gleich dem maximalen Element sind. Wenn es Werte gibt, die nicht gleich sind, führt dies zu einem falschen Wert, andernfalls wird ein wahrer Wert zurückgegeben.

Wenn beide Blöcke wahr sind, ist unsere Eingabe eine fortlaufende konstante Exponenten-Primzahl!

APL (Dyalog Extended) , 28 Byte

{f p←`↓⍭⍵⋄(1=≢∪p)∧∨/f⍷⍸1⍭⍳⍵}

Probieren Sie es online!

Wie:

{f p←`↓⍭⍵⋄(1=≢∪p)∧∨/f⍷⍸1⍭⍳⍵} ⍝ Monadic function, takes an argument ⍵
       ⍭⍵                     ⍝ Prime factors and exponents of ⍵
     `↓                        ⍝ split the resulting matrix in 2 vectors
 f p←                          ⍝ assign the factors to f and the powers to p
         ⋄                     ⍝ then
                          ⍳⍵   ⍝ range [1..⍵]
                        1⍭     ⍝ primality check for each element in the vector
                       ⍸        ⍝ where; returns the indices of truthy values
                     f⍷         ⍝ find the factors; returns a boolean vector
                   ∨/           ⍝ logical OR reduction
                  ∧             ⍝ logical AND
           (   ∪p)              ⍝ unique members of the powers
              ≢                 ⍝ tally; returns the number of elements in the vector
            1=                  ⍝ check if there's only one element

Wolfram Language (Mathematica) , 65 Byte

Differences[{PrimePi@#,#2}&@@@FactorInteger@#]~MatchQ~{{1,0}...}&

Probieren Sie es online!

Pari / GP , 63 Bytes

n->#Set(vector(#(a=factor(n)~),i,[primepi(a[1,i])-i,a[2,i]]))<2

Probieren Sie es online!

J , 14 Bytes

1#.2~:/\0,_&q:

1 in der Ausgabe gibt einen konsekutiven konstanten Exponenten an.

Probieren Sie es online!

        0,_&q:   zero followed by the prime exponents of input
   2~:/\         for every two consecutive values, 1 if they are different
1#.              convert from base-1, just add them up

Sauber , 127 Bytes

import StdEnv
@n=[]== $n
?n#j= $n
= @n||j==filter@[hd j..last j]&&any(\p=(prod j)^p==n)[1..n]
$n=[i\\i<-[2..n-1]|n/i*i==n&& @i]

Probieren Sie es online!

Legt die Funktion ? :: Int -> Boolmit $ :: Int -> [Int]faktorisieren und @ :: Int -> Boolprimality zu überprüfen.

APL (NARS) 41 Zeichen, 82 Byte

{(1=≢∪+/¨{v=⍵⊃v}¨⍳≢v)∧(1↓w)≡¯1↓1πw←∪v←π⍵}

{π⍵} ist die Funktionsfaktorisierung des Arguments ⍵ in der Liste der Primfaktoren (Wiederholung, wenn ein Prim mehrmals auftritt);
{1π⍵} ist die nächste Primzahl der Funktion (in diesem Fall ist das Argument kein Skalar, sondern ein Array von Ganzzahlen). Prüfung:

  h←{(1=≢∪+/¨{v=⍵⊃v}¨⍳≢v)∧(1↓w)≡¯1↓1πw←∪v←π⍵}
  (2..30)/⍨h¨2..30
2 3 4 5 6 7 8 9 11 13 15 16 17 19 23 25 27 29 30 
  h¨27000 456533 72 10000000
1 1 0 0