Hace un tiempo, eché un vistazo a la factorización prima de 27000:

27000 = 2 ³ × 3 ³ × 5 ³

Hay dos cosas especiales al respecto:

• consecutiva de alto riesgo : Los números primos son consecutivas: 2 es la primera de primera, 3 es el segundo primo, 5 es el primer tercio.
• constante-exponente : el exponente es el mismo para cada primo (siempre 3)

Expresado matemáticamente:

Un número entero x es un número primo consecutivo / exponente constante si existen enteros estrictamente positivos n , k , m tal que x = p _n ^m × p _{n +1} ^m × ... × p _{n + k} ^m , donde p _j es el j -ésimo primer

Su tarea es probar si un entero positivo cumple estas condiciones.

Entrada:

Un entero positivo> 1, en cualquier forma razonable.

Salida:

Uno de los dos valores, al menos uno de los cuales tiene que ser constante, lo que indica si la entrada es un número primo consecutivo / exponente constante.

Casos de borde:

• los números primos son verdaderos, ya que la factorización para primer p es p ¹
• otros números que se pueden escribir como p ^m donde p es primo también son verdaderos.

Reglas:

• Se aplican lagunas estándar.
• No se preocupe por el desbordamiento de enteros, pero los números hasta 255 deben funcionar.
• El código más corto en bytes gana.

Casos de prueba:

Verdad:

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

Falsy

10
12
14
72
10000000

Aquí hay un script de Python que genera algunos casos de prueba.

El hecho de que acepté una respuesta no significa que el desafío haya terminado; ¡el ganador aún puede cambiar!

05AB1E , 4 bytes

Ó0ÛË

Pruébalo en línea!

Explicación

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

Regex (ECMAScript), 276 205 201 193 189 bytes

Comparar las multiplicidades (exponentes) de diferentes factores primos es un problema interesante para resolver con la expresión regular ECMAScript: la falta de referencias posteriores que persisten a través de iteraciones de un bucle hace que sea un desafío contar cualquier cosa. Incluso si es posible contar el rasgo numérico en cuestión, a menudo un enfoque más indirecto mejora el golf.

Al igual que con mis otras publicaciones de expresiones regulares ECMA, daré una advertencia de spoiler: recomiendo aprender a resolver problemas matemáticos unarios en expresiones regulares ECMAScript. Ha sido un viaje fascinante para mí, y no quiero estropearlo para cualquiera que quiera probarlo ellos mismos, especialmente aquellos interesados ​​en la teoría de números. Consulte esta publicación anterior para obtener una lista de problemas recomendados etiquetados consecutivamente con spoilers para resolver uno por uno.

Así que no sigas leyendo si no quieres que se te estropee un poco de magia regex unaria avanzada . Si desea intentar descubrir esta magia usted mismo, le recomiendo comenzar resolviendo algunos problemas en la expresión regular de ECMAScript como se describe en la publicación vinculada anteriormente.

La carga útil principal de una expresión regular que desarrollé previamente resultó ser muy aplicable a este desafío. Esa es la expresión regular que encuentra el (los) primo (s) de mayor multiplicidad . Mi primera solución para eso fue muy larga, y luego lo jugué por etapas, primero lo reescribí para usar el lookahead molecular , y luego lo volví a convertir al ECMAScript simple usando una técnica avanzada para evitar la falta de lookahead molecular , y luego jugando golf para que sea mucho más pequeño que la solución ECMAScript original.

La parte de esa expresión regular que se aplica a este problema es el primer paso, que encuentra Q, el factor más pequeño de N que comparte todos sus factores primos. Una vez que tenemos este número, todo lo que tenemos que hacer para demostrar que N es un "número de exponente constante" es dividir N entre Q hasta que no podamos más; Si el resultado es 1, todos los primos son de igual multiplicidad.

Después de enviar una respuesta usando mi algoritmo previamente desarrollado para encontrar Q, me di cuenta de que podría calcularse de una manera completamente diferente: encontrar el factor libre de cuadrados más grande de N (usando el mismo algoritmo que mi expresión regular de números de Carmichael ). Resulta que esto no plantea ninguna dificultad * en términos de evitar la falta de anticipación molecular y de retroceso de longitud variable (no es necesario incorporar la técnica avanzada utilizada anteriormente), ¡y es 64 bytes más corto! Además, elimina la complejidad de tratar el N sin cuadrados y el N principal como diferentes casos especiales, eliminando otros 7 bytes de esta solución.

(Todavía quedan otros problemas que requieren la técnica avanzada utilizada anteriormente para reducir el cálculo de Q, pero actualmente ninguno de ellos está representado por mis publicaciones PPCG).

Puse la prueba de multiplicidad antes de la prueba de primos consecutivos porque esta última es mucho más lenta; poner pruebas que pueden fallar más rápidamente primero hace que la expresión regular sea más rápida para una entrada distribuida uniformemente. También es mejor el golf para ponerlo primero, porque usa más referencias inversas (lo que costaría más si fueran de dos dígitos).

Pude eliminar 4 bytes de esta expresión regular (193 → 189) usando un truco encontrado por Grimy que puede acortar aún más la división en el caso de que se garantice que el cociente sea mayor o igual que el divisor.

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

Pruébalo en línea!

# 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?)$
    )
)

* Todavía es más limpio con anticipación molecular, sin ningún caso especial para que N esté libre de cuadrados. Esto deja caer 6 bytes, produciendo una solución de 195 187 183 bytes :

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

Aquí está portado a lookbehind de longitud variable:

Expresiones regulares (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+))))

Pruébalo en línea!

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

Jalea , 13 6 5 bytes

ÆEt0E

Pruébalo en línea!

Todavía superado ... (gracias Erik por -1 byte)

Explicación

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

Devuelve 0 para verdadero o un entero distinto de cero para falso.

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)

Pruébalo en línea!

Comentado

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=&}

Pruébalo en línea!

Mi primera respuesta después de un descanso de casi 2 (!) Años, por lo que probablemente pueda jugar más. Este es un bloque que toma la entrada como un entero (también se puede asignar para matrices de enteros).

Explicación

{        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

Ejecutar y depurarlo

Desempaquetado, sin golf y comentado, se ve así.

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

Editar: esto no funciona 512. Lo pensaré un poco y, con suerte, una solución más tarde. Ahora funciona.

Stax , 9 bytes

1 es verdadero, 0 es falso

αAG<└\{┬⌠

Ejecutar y depurarlo

Explicación

|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

Probablemente se pueda jugar más al golf, pero cubre los casos que me faltaban en la última solución.

MATL , 12 11 10 bytes

YFtgYsg)Zs

¡Pruébalo en MATL Online!

Gracias a Luis Mendo por la parte de eliminar ceros a la izquierda. También señaló que se permite intercambiar valores de verdad, por lo que esto devuelve 0 para los números que satisfacen los requisitos de desafío y cualquier valor positivo de lo contrario.

Grosso Modo, esto genera los exponentes de la factorización prima secuencial, elimina los ceros a la izquierda y calcula la desviación estándar.

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

Vuelve 1como veraz y >=2como falsey.

Pruébalo en línea.

Explicación:

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)

Algunas entradas de ejemplo:

n=15:

• La bandera permanece 1para el primer primo 2 (porque 15 no es divisible por 2).
• La bandera va de 1a 0tan pronto como estemos en el número 3. Como 15 es divisible por 3, se nconvierte en 5 (15/3 ¹ ), y el Conjunto se convierte en [] → [1].
• Luego verificamos el siguiente primo 5. Como 5 es divisible por 5, se nconvierte en 1 (5/5 ¹ ), y el Conjunto permanece igual ( [1] → [1]).
• Ahora n=1, entonces detenemos el bucle externo. El Set ( [1]) solo contiene un elemento, el 1de los dos primos adyacentes 3 y 5, por lo que devolvemos verdadero.

n=14:

• La bandera va de 1a 0para el primer primo 2 (porque 14 es divisible por 2). nse convierte en 7 (14/2 ¹ ), y el Set se convierte en [] → [1].
• Luego verificamos el próximo primo 3. Como 7 no es divisible por 3, n permanece igual y el Conjunto se convierte [1] → [1,0].
• Luego verificamos el siguiente primo 5. Como 7 tampoco es divisible por 5, n sigue siendo el mismo y el Conjunto sigue siendo el mismo ( [1,0] → [1,0]).
• Luego verificamos el próximo primo 7. Como 7 es divisible por 7, se nconvierte en 1 (7/7 ¹ ), y el Conjunto permanece igual ( [1,0] → [1,0]).
• Ahora n=1, entonces detenemos el bucle externo. El Set ( [1,0]) contiene dos elementos, el 1de los primos no adyacentes 2 y 7, y el 0de los primos 3 y 5, por lo que devolvemos falso.

n=72:

• La bandera va de 1a 0para el primer primo 2, porque 72 es divisible por 2 (varias veces). Entonces se nconvierte en 9 (72/2 ³ ), y el Set se convierte en[] → [3] .
• Luego verificamos el siguiente primo 3. Como 9 es divisible por 3 (varias veces), se nconvierte en 1 (9/3 ² ), y el Conjunto se convierte en [3] → [3,2].
• Ahora n=1, entonces detenemos el bucle externo. El Set ( [3,2]) contiene dos elementos, 3from from prime 2 y 2from from prime 3, por lo que devolvemos false.

J , 16 bytes

¡Muchas gracias a FrownyFrog por -8 bytes!

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

Pruébalo en línea!

Mi vieja solución:

J , 24 bytes

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

Pruébalo en línea!

Explicación:

_&q: exponentes primos

{.@I.}.] elimina los ceros iniciales al encontrar el primer elemento distinto de cero:

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

1=[:#@~. prueba si todos los números restantes son iguales:

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

Casco , 11 bytes

Λ§*≈¤≈oṗ←gp

Pruébalo en línea!

Emite 0 si no es un número primo consecutivo / exponente constante.

MATL , 7 bytes

0iYFhdz

El resultado es 1 si la entrada cumple el requisito.

Pruébalo en línea! O verificar todos los casos de prueba

Explicación

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

Octava , 67 bytes

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

Pruébalo en línea!

Creo que esta es la única solución que usa un histograma.

Explicación:

Esto hace un histograma, donde la variable a contar son los factores de la entrada y se colocan en los contenedores. primes(x) , que son todos primos menores que la entrada. Luego encontramos la ubicación de los factores primos, tomamos la diferencia entre cada uno de los índices y restamos uno. Si hay elementos que no son cero (es decir, la diferencia de los índices de los números primos no es 1), esto dará como resultado un valor falso, de lo contrario devolverá un valor verdadero.

Luego verificamos que todos los elementos distintos de cero en el histograma son iguales al elemento máximo. Si hay valores que no son iguales, esto dará como resultado un valor falso, de lo contrario devolverá un valor verdadero.

Si ambos bloques son verdaderos, ¡entonces nuestra entrada es un número de exponente constante primo consecutivo!

APL (Dyalog Extended) , 28 bytes

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

Pruébalo en línea!

Cómo:

{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 bytes

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

Pruébalo en línea!

Pari / GP , 63 bytes

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

Pruébalo en línea!

J , 14 bytes

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

1 en la salida indica exponente constante consecutivo.

Pruébalo en línea!

        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

Limpio , 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]

Pruébalo en línea!

Define la función ? :: Int -> Boolusando $ :: Int -> [Int]para factorizar y @ :: Int -> Boolverificar la primalidad.

APL (NARS) 41 caracteres, 82 bytes

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

{π⍵} es la factorización de función del argumento ⍵ en la lista de factores primos (repita si un primo aparece más tiempo);
{1π⍵} es la función next prime (tenga en cuenta que en este caso su argumento no es un escalar sino una matriz de enteros). prueba:

  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