Jakiś czas temu rzuciłem okiem na pierwszą faktoryzację 27000:

27000 = 2 ³ × 3 ³ × 5 ³

Są w tym dwie szczególne rzeczy:

• kolejna liczba pierwsza : liczby pierwsze są następujące po sobie: 2 to pierwsza liczba pierwsza, 3 to druga liczba pierwsza, 5 to trzecia liczba pierwsza.
• wykładnik stały : wykładnik jest taki sam dla każdej liczby pierwszej (zawsze 3)

Wyrażony matematycznie:

Liczba całkowita x jest liczbą pierwszą / stałą wykładnika, jeśli istnieją ściśle dodatnie liczby całkowite n , k , m takie, że x = p _n ^m × p _{n +1} ^m × ... × p _{n + k} ^m , gdzie p _j jest j-tą pierwszą liczbą pierwszą

Twoim zadaniem jest sprawdzenie, czy dodatnia liczba całkowita spełnia te warunki.

Wkład:

Dodatnia liczba całkowita> 1, w dowolnej rozsądnej formie.

Wydajność:

Jedna z dwóch wartości, z których co najmniej jedna musi być stała, wskazująca, czy dane wejściowe są liczbą pierwszą / stałą-wykładnikiem.

Obudowy krawędzi:

• liczby pierwsze są prawdą, ponieważ rozkład na czynniki pierwsze p wynosi p ¹
• inne liczby, które można zapisać jako p ^m, gdzie p jest liczbą pierwszą, są również prawdziwe.

Zasady:

• Obowiązują standardowe luki.
• Nie martw się przepełnieniem liczb całkowitych, ale liczby do 255 muszą działać.
• Najkrótszy kod w bajtach wygrywa.

Przypadki testowe:

Prawda:

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

Falsy:

10
12
14
72
10000000

Oto skrypt Pythona generujący niektóre przypadki testowe.

Fakt, że zaakceptowałem odpowiedź, nie oznacza, że ​​wyzwanie się skończyło; zwycięzca może się jeszcze zmienić!

05AB1E , 4 bajty

Ó0ÛË

Wypróbuj online!

Wyjaśnienie

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

Regex (ECMAScript), 276 205 201 193 189 bajtów

Porównywanie wielokrotności (wykładników) różnych czynników pierwszych jest interesującym problemem do rozwiązania za pomocą wyrażenia regularnego ECMAScript - brak odniesień wstecznych, które utrzymują się przez iteracje pętli, sprawia, że ​​liczenie wszystkiego jest trudne. Nawet jeśli policzenie omawianej cechy numerycznej jest możliwe, często bardziej pośrednie podejście zapewnia lepsze golfa.

Podobnie jak w przypadku moich innych wpisów regularnych ECMA, dam ostrzeżenie spoilerowe: Gorąco zalecam nauczenie się rozwiązywania pojedynczych problemów matematycznych w wyrażeniu regularnym ECMAScript. To była dla mnie fascynująca podróż i nie chcę zepsuć jej nikomu, kto mógłby potencjalnie chcieć spróbować samemu, szczególnie tym, którzy interesują się teorią liczb. W tym wcześniejszym poście znajduje się lista zalecanych problemów oznaczonych spoilerem do rozwiązania jeden po drugim.

Więc nie czytaj dalej, jeśli nie chcesz, aby zepsuła Ci się jakaś zaawansowana magia wyrażeń regularnych . Jeśli chcesz spróbować samodzielnie odkryć tę magię, zdecydowanie polecam zacząć od rozwiązania niektórych problemów z wyrażeniem regularnym ECMAScript, jak opisano w linku powyżej.

Główny ładunek z regexu, który wcześniej opracowałem, okazał się bardzo odpowiedni do tego wyzwania. To jest wyrażenie regularne, które znajduje liczbę pierwszą o największej krotności . Moje pierwsze rozwiązanie tego problemu było bardzo długie, a później grałem w golfa etapami, najpierw przepisując go, aby użyć molekularnego spojrzenia , a następnie przenosząc go z powrotem do zwykłego ECMAScript za pomocą zaawansowanej techniki, aby obejść brak molekularnej perspektywy , a następnie gra w golfa jest znacznie mniejsza niż oryginalne proste rozwiązanie ECMAScript.

Część tego wyrażenia regularnego, która dotyczy tego problemu, jest pierwszym krokiem, w którym znajduje się Q, najmniejszy czynnik N, który dzieli wszystkie swoje czynniki pierwsze. Gdy już otrzymamy tę liczbę, wszystko, co musimy zrobić, aby pokazać, że N jest „liczbą o stałym wykładniku”, dzieli N przez Q, dopóki nie możemy dłużej; jeśli wynik wynosi 1, wszystkie liczby pierwsze są równe wielokrotności.

Po przesłaniu odpowiedzi przy użyciu mojego wcześniej opracowanego algorytmu znajdowania Q, zdałem sobie sprawę, że można go obliczyć w zupełnie inny sposób: Znajdź największy współczynnik kwadratowy N (używając tego samego algorytmu jak mój regex liczby Carmichaela ). Jak się okazuje, nie stanowi to żadnego problemu * pod względem obejścia braku molekularnego spojrzenia przed siebie i spojrzenia o zmiennej długości (nie trzeba wciągać wcześniej stosowanej techniki zaawansowanej) i jest o 64 bajty krótszy! Dodatkowo eliminuje to złożoność traktowania bezkwadratowego N i pierwszej N jako różnych specjalnych przypadków, usuwając kolejne 7 bajtów z tego rozwiązania.

(Nadal istnieją inne problemy, które wymagają zaawansowanej techniki używanej wcześniej do obliczania Q, ale obecnie żaden z nich nie jest reprezentowany przez moje posty PPCG).

Test wielokrotności stawiam przed testem kolejnych liczb pierwszych, ponieważ ten drugi jest znacznie wolniejszy; umieszczenie testów, które mogą szybciej zakończyć się niepowodzeniem, sprawia, że ​​wyrażenie regularne jest szybsze dla równomiernie rozłożonego wejścia. Lepiej jest też postawić golfa na pierwszym miejscu, ponieważ wykorzystuje on więcej odwołań wstecznych (co kosztowałoby więcej, gdyby były dwucyfrowe).

Byłem w stanie usunąć 4 bajty z tego wyrażenia regularnego (193 → 189), używając sztuczki znalezionej przez Grimy'ego, która może dalej skracać podział w przypadku, gdy iloraz gwarantowany jest większy lub równy dzielnikowi.

^(?=(|(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?)$))

Wypróbuj 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?)$
    )
)

* Jest jeszcze czystszy z molekularnym spojrzeniem w przód, bez specjalnego przypadku, w którym N nie ma kwadratu. To zrzuca 6 bajtów, co daje 195 187 183 bajtów :

^(?=(?*(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?)$
    )
)

Tutaj jest przeniesiony do look-look za zmienną długością:

Regex (ECMAScript 2018), 198 195 194 186 182 bajtów

^(?=(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+))))

Wypróbuj 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
)

Galaretka , 13 6 5 bajtów

ÆEt0E

Wypróbuj online!

Nadal zalesiony ... (dzięki Erik za -1 bajt)

Wyjaśnienie

Æ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 bajtów

Zwraca 0 dla wartości true lub niezerową liczbę całkowitą dla falsy.

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)

Wypróbuj online!

Skomentował

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 bajtów

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

Wypróbuj online!

Moja pierwsza odpowiedź po prawie 2 (!) - letniej przerwie, więc prawdopodobnie można więcej grać w golfa. Jest to blok, który przyjmuje dane wejściowe jako liczbę całkowitą (można je również odwzorować dla tablic liczb całkowitych).

Wyjaśnienie

{        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 bajtów

╣♥qJ╬c

Uruchom i debuguj

Rozpakowane, niepolowane i skomentowane, wygląda to tak.

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

Edycja: To nie działa 512. Zastanowię się i mam nadzieję, że później. Teraz działa.

Stax , 9 bajtów

1 to prawda, 0 to fałsz

αAG<└\{┬⌠

Uruchom i debuguj

Wyjaśnienie

|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

Prawdopodobnie można grać w golfa więcej, ale obejmuje przypadki, których brakowało mi w ostatnim rozwiązaniu.

MATL , 12 11 10 bajtów

YFtgYsg)Zs

Wypróbuj w MATL Online!

Podziękowania dla Luisa Mendo za część usuwania wiodących zer. Zwrócił także uwagę, że zamiana wartości prawdy jest dozwolona, ​​więc to powraca 0 dla liczb, które spełniają wymagania wyzwania, i wszelkich wartości dodatnich w przeciwnym razie.

Grosso Modo, to generuje wykładniki sekwencyjnego rozkładania na czynniki pierwsze, usuwa zera wiodące i oblicza odchylenie standardowe.

Java 10, 223 191 178 176 168 bajtów

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

Zwraca 1jako prawdomówny i >=2falsey.

Wypróbuj online.

Wyjaśnienie:

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)

Niektóre przykładowe dane wejściowe:

n=15:

• Flaga pozostaje 1 dla pierwszej liczby pierwszej 2 (ponieważ 15 nie jest podzielne przez 2).
• Flaga przechodzi od 1do, 0gdy tylko nosiągniemy liczbę pierwszą 3. Ponieważ 15 można podzielić przez 3, staje się 5 (15/3 ¹ ), a zestaw staje się[] → [1] .
• Następnie sprawdzamy kolejną liczbę pierwszą 5. Ponieważ 5 można podzielić przez 5, nstaje się 1 (5/5 ¹ ), a Set pozostaje ten sam ([1] → [1] ).
• Teraz n=1zatrzymujemy zewnętrzną pętlę. Set ( [1]) zawiera tylko jeden element, 1z obu sąsiednich liczb pierwszych 3 i 5, więc zwracamy true.

n=14:

• Flaga przechodzi od 1do 0dla pierwszej liczby pierwszej 2 (ponieważ 14 można podzielić przez 2). nstaje się 7 (14/2 ¹ ), a Zestaw staje się [] → [1].
• Następnie sprawdzamy kolejną liczbę pierwszą 3. Ponieważ 7 nie jest podzielne przez 3, npozostaje takie samo, a Set staje się[1] → [1,0] .
• Następnie sprawdzamy kolejną liczbę pierwszą 5. Ponieważ 7 również nie jest podzielne przez 5, npozostaje takie samo, a Set również pozostaje taki sam ( [1,0] → [1,0]).
• Następnie sprawdzamy kolejną liczbę pierwszą 7. Ponieważ 7 można podzielić przez 7, nstaje się 1 (7/7 ¹ ), a Set pozostaje taki sam ( [1,0] → [1,0]).
• Teraz n=1zatrzymujemy zewnętrzną pętlę. Set ( [1,0]) zawiera dwa elementy, 1z nieprzylegających liczb pierwszych 2 i 7 oraz 0z liczb pierwszych 3 i 5, więc zwracamy false.

n=72:

• Flaga przechodzi od 1do 0dla pierwszej liczby pierwszych 2, ponieważ 72 można podzielić przez 2 (wiele razy). Tak więc nstaje się 9 (72/2 ³ ), a Set staje się[] → [3] .
• Następnie sprawdzamy kolejną liczbę pierwszą 3. Ponieważ 9 można podzielić przez 3 (wiele razy), nstaje się 1 (9/3 ² ), a Set staje się [3] → [3,2].
• Teraz n=1zatrzymujemy zewnętrzną pętlę. Set ( [3,2]) zawiera dwa elementy, 3from prime 2 i 2from prime 3, więc zwracamy false.

J , 16 bajtów

Ogromne podziękowania dla FrownyFrog za -8 bajtów!

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

Wypróbuj online!

Moje stare rozwiązanie:

J , 24 bajty

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

Wypróbuj online!

Wyjaśnienie:

_&q: pierwsi wykładnicy

{.@I.}.] usuwa wiodące zera, znajdując pierwszy niezerowy element:

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

1=[:#@~. sprawdza, czy wszystkie pozostałe liczby są równe:

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

Łuska , 11 bajtów

Λ§*≈¤≈oṗ←gp

Wypróbuj online!

Wyprowadza wartość 0, jeśli nie jest liczbą pierwszą / stałą wykładnika.

MATL , 7 bajtów

0iYFhdz

Wynikiem jest 1wejście iff spełniające wymagania.

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe

Wyjaśnienie

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

Oktawa , 67 bajtów

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

Wypróbuj online!

Uważam, że to jedyne rozwiązanie wykorzystujące histogram.

Wyjaśnienie:

To tworzy histogram, w którym zmienną do zliczenia są czynniki wejściowe i umieszczane w przedziałach primes(x) , które są liczbami pierwszymi mniejszymi niż dane wejściowe. Następnie znajdujemy lokalizację czynników pierwszych, uwzględniamy różnicę między każdym z indeksów i odejmujemy jeden. Jeśli są jakieś elementy, które nie są zerowe (tj. Różnica wskaźników liczb pierwszych nie wynosi 1), spowoduje to wartość fałszowania, w przeciwnym razie zwróci wartość prawdziwości.

Następnie sprawdzamy, czy wszystkie niezerowe elementy na histogramie są równe maksymalnemu elementowi. Jeśli istnieją wartości, które nie są równe, spowoduje to wartość fałszowania, w przeciwnym razie zwróci wartość prawdziwości.

Jeśli oba te bloki są zgodne z prawdą, to naszym wejściem jest kolejna liczba wykładnicza stałej stałej!

APL (Dyalog Extended) , 28 bajtów

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

Wypróbuj online!

W jaki sposób:

{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 bajtów

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

Wypróbuj online!

Pari / GP , 63 bajty

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

Wypróbuj online!

J , 14 bajtów

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

1 na wyjściu oznacza kolejny stały wykładnik.

Wypróbuj 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

Czysty , 127 bajtów

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]

Wypróbuj online!

Definiuje funkcję ? :: Int -> Boolużywając $ :: Int -> [Int]na czynniki i @ :: Int -> Boolsprawdzić pierwszości.

APL (NARS) 41 znaków, 82 bajty

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

{π⍵} to funkcja faktoryzacji argumentu ⍵ na liście czynników pierwszych (powtórz, jeśli jedna liczba pierwsza pojawi się więcej czasu);
{1π⍵} jest funkcją next prime (zwróć uwagę, że w tym przypadku jej argumentem nie jest skalar, ale jedna tablica liczb całkowitych). test:

  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