Há um tempo, observei a fatoração principal de 27000:

27000 = 2 ³ × 3 ³ × 5 ³

Há duas coisas especiais sobre isso:

• primo consecutivo : os primos são consecutivos: 2 é o primeiro primo, 3 é o segundo primo, 5 é o terceiro primo.
• expoente constante : o expoente é o mesmo para cada primo (sempre 3)

Matematicamente expresso:

Um número inteiro x é um número de primos consecutivos / expoente constante, se existirem números inteiros estritamente positivos n , k , m de modo que x = p _n ^m × p _{n +1} ^m × ... × p _{n + k} ^m , em que p _j é o j- ésimo primo

Sua tarefa é testar se um número inteiro positivo atende a essas condições.

Entrada:

Um número inteiro positivo> 1, de qualquer forma razoável.

Saída:

Um dos dois valores, pelo menos um dos quais deve ser constante, indicando se a entrada é um número de primo consecutivo / expoente constante.

Casos de borda:

• os primos são verdadeiros, pois a fatoração para o primo p é p ¹
• outros números que podem ser escritos como p ^m onde p é primo também são verdadeiros.

Regras:

• Aplicam-se brechas padrão.
• Não se preocupe com o excesso de números inteiros, mas números de até 255 devem funcionar.
• O menor código em bytes vence.

Casos de teste:

Verdade:

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

Falsy:

10
12
14
72
10000000

Aqui está um script python gerando alguns casos de teste.

O fato de eu ter aceito uma resposta não significa que o desafio acabou; o vencedor ainda pode mudar!

05AB1E , 4 bytes

Ó0ÛË

Experimente online!

Explicação

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

Regex (ECMAScript), 276 205 201 193 189 bytes

Comparar as multiplicidades (expoentes) de diferentes fatores primos é um problema interessante para resolver com o regex ECMAScript - a falta de referências anteriores que persistem através das iterações de um loop torna um desafio contar qualquer coisa. Mesmo que seja possível contar a característica numérica em questão, muitas vezes uma abordagem mais indireta contribui para um melhor golfe.

Como em outras postagens de regex do ECMA, darei um aviso de spoiler: recomendo aprender como resolver problemas matemáticos unários no regex do ECMAScript. Foi uma jornada fascinante para mim, e não quero estragá-la para quem potencialmente queira experimentá-la, especialmente aqueles com interesse em teoria dos números. Consulte esta postagem anterior para obter uma lista de problemas recomendados consecutivamente identificados por spoilers para resolver um por um.

Portanto , não leia mais se não quiser que você estrague uma mágica avançada de expressões regulares unárias . Se você quiser tentar descobrir essa mágica, recomendo começar resolvendo alguns problemas no regex ECMAScript, conforme descrito no post acima.

A carga útil principal de um regex que eu desenvolvi anteriormente se mostrou muito aplicável a esse desafio. Esse é o regex que encontra os primos da maior multiplicidade . Minha primeira solução para isso foi muito longa e, mais tarde, joguei por etapas, primeiro reescrevendo-o para usar lookahead molecular e, em seguida, enviando-o de volta ao ECMAScript simples, usando uma técnica avançada para solucionar a falta de lookahead molecular e, posteriormente, diminuindo o tamanho da solução ECMAScript original.

A parte desse regex que se aplica a esse problema é a primeira etapa, que encontra Q, o menor fator de N que compartilha todos os fatores primos. Quando temos esse número, tudo o que precisamos fazer para mostrar que N é um "número de expoente constante" é dividir N por Q até que não possamos mais; se o resultado for 1, todos os números primos são de igual multiplicidade.

Depois de enviar uma resposta usando meu algoritmo desenvolvido anteriormente para encontrar Q, percebi que ele poderia ser calculado de uma maneira totalmente diferente: Encontre o maior fator livre de quadrados de N (usando o mesmo algoritmo que meu número regular de Carmichael ). Como se vê, isso não apresenta nenhuma dificuldade * em termos de contornar a falta de visores moleculares e de comprimento variável (não há necessidade de usar a técnica avançada usada anteriormente) e é 64 bytes mais curto! Além disso, elimina a complexidade de tratar N livre de quadrados e N principal como casos especiais diferentes, eliminando outros 7 bytes desta solução.

(Ainda existem outros problemas que exigem a técnica avançada usada anteriormente para reduzir o cálculo de Q, mas atualmente nenhum deles é representado pelos meus posts do PPCG.)

Coloquei o teste de multiplicidade antes do teste dos primos consecutivos, porque o último é muito mais lento; colocar testes que podem falhar mais rapidamente primeiro torna o regex mais rápido para entrada distribuída uniformemente. Também é melhor colocar o golfe em primeiro lugar, porque ele usa mais referências anteriores (que custariam mais se fossem de dois dígitos).

Consegui eliminar 4 bytes desse regex (193 → 189) usando um truque encontrado por Grimy que pode reduzir ainda mais a divisão no caso de garantir que o quociente seja maior ou igual ao 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?)$))

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

* Ainda é mais limpo com a cabeça molecular, sem nenhum caso especial para N estar livre de quadrados. Isso elimina 6 bytes, produzindo uma solução 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?)$
    )
)

Aqui é portado para lookbehind de comprimento variável:

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

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

Geléia , 13 6 5 bytes

ÆEt0E

Experimente online!

Ainda ultrapassado ... (obrigado Erik por -1 byte)

Explicação

Æ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

Retorna 0 para truthy ou um número inteiro diferente de zero para 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)

Experimente online!

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

Experimente online!

Minha primeira resposta após uma pausa de quase 2 (!) Anos, provavelmente pode ser mais praticada. Este é um bloco que recebe a entrada como um número inteiro (também pode ser mapeado para matrizes de números inteiros).

Explicação

{        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

Execute e depure

Descompactado, não jogado e comentado, parece com isso.

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

Edit: Isso não funciona 512. Vou pensar um pouco e, espero, uma correção mais tarde. Funciona agora.

Stax , 9 bytes

1 é verdade, 0 é falso

αAG<└\{┬⌠

Execute e depure

Explicação

|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

Provavelmente pode ser mais jogado, mas abrange os casos que estavam faltando na última solução.

MATL , 12 11 10 bytes

YFtgYsg)Zs

Experimente no MATL Online!

Agradecimentos a Luis Mendo pela parte remover-zero-à-zero. Ele também apontou que a troca de valores de verdade é permitida, portanto, retorna 0 para números que satisfazem os requisitos de desafio e qualquer valor positivo caso contrário.

Grosso Modo, isso gera os expoentes da fatoração primária sequencial, remove os zeros iniciais e calcula o desvio padrão.

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

Retorna como verdade 1e >=2como falsey.

Experimente online.

Explicação:

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)

Alguns exemplos de entradas:

n=15:

• A bandeira permanece 1para o primeiro 2 primo (porque 15 não é divisível por 2).
• A bandeira passa de 1para 0assim que estiver no início 3. Como 15 é divisível por 3, npassa a 5 (15/3 ¹ ) e o Conjunto passa a ser [] → [1].
• Em seguida, verificamos o próximo primo 5. Como 5 é divisível por 5, ntorna-se 1 (5/5 ¹ ) e o Conjunto permanece o mesmo ( [1] → [1]).
• Agora n=1, paramos o loop externo. O Set ( [1]) contém apenas um item, o 1de ambos os primos adjacentes 3 e 5, portanto, retornamos true.

n=14:

• A flag vai de 1para 0para o primeiro prime 2 (porque 14 é divisível por 2). ntorna-se 7 (14/2 ¹ ) e o conjunto torna-se[] → [1] .
• Em seguida, verificamos o próximo primo 3. Como 7 não é divisível por 3, n permanece o mesmo e o conjunto se torna [1] → [1,0].
• Em seguida, verificamos o próximo prime 5. Como 7 também não é divisível por 5, n permanece o mesmo e o conjunto também é o mesmo ( [1,0] → [1,0]).
• Em seguida, verificamos o próximo número primo 7. Como 7 é divisível por 7, ntorna-se 1 (7/7 ¹ ), e o Conjunto permanece o mesmo ( [1,0] → [1,0]).
• Agora n=1, paramos o loop externo. O conjunto ( [1,0]) contém dois itens, o 1dos primos não adjacentes 2 e 7 e o0 dos primos 3 e 5, portanto, retornamos false.

n=72:

• Bandeira vai desde 1a 0pela primeira Prime 2, porque 72 é divisível por 2 (várias vezes). nTorna-se então 9 (72/2 ³ ) e o conjunto torna-se[] → [3] .
• Em seguida, verificamos o próximo número primo 3. Como 9 é divisível por 3 (várias vezes), ntorna-se 1 (9/3 ² ) e o conjunto se torna[3] → [3,2] .
• Agora n=1, paramos o loop externo. O conjunto ( [3,2]) contém dois itens, o 3do primo 2 e o 2do primo 3; portanto, retornamos false.

J , 16 bytes

Muito obrigado a FrownyFrog por -8 bytes!

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

Experimente online!

Minha solução antiga:

J , 24 bytes

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

Experimente online!

Explicação:

_&q: expoentes principais

{.@I.}.] remove os zeros à esquerda localizando o primeiro elemento diferente de zero:

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

1=[:#@~. testa se todos os números restantes são iguais:

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

Casca , 11 bytes

Λ§*≈¤≈oṗ←gp

Experimente online!

Emite 0 se não for um número consecutivo de primo / expoente constante.

MATL , 7 bytes

0iYFhdz

O resultado é 1se a entrada satisfizer o requisito.

Experimente online! Ou verifique todos os casos de teste

Explicação

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

Oitava , 67 bytes

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

Experimente online!

Eu acredito que esta é a única solução que usa um histograma.

Explicação:

Isso cria um histograma, onde a variável a ser contada é o fator da entrada e colocada nas posições primes(x) , que são todos os números primos menores que a entrada. Em seguida, encontramos a localização dos fatores primos, toma a diferença entre cada um dos índices e subtrai um. Se houver algum elemento que não seja zero (ou seja, a diferença dos índices dos números primos não é 1), isso resultará em um valor falso, caso contrário, ele retornará um valor verdadeiro.

Em seguida, verificamos que todos os elementos diferentes de zero no histograma são iguais ao elemento máximo. Se houver valores diferentes, isso resultará em um valor falso, caso contrário, ele retornará um valor verdadeiro.

Se ambos os blocos são verdadeiros, nossa entrada é um número de expoente constante constante consecutivo!

APL (Dyalog Extended) , 28 bytes

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

Experimente online!

Quão:

{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}...}&

Experimente online!

Pari / GP , 63 bytes

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

Experimente online!

J , 14 bytes

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

1 na saída indica expoente constante consecutivo.

Experimente 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

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

Experimente online!

Define a função ? :: Int -> Boolusando $ :: Int -> [Int]para fatorar e @ :: Int -> Boolverificar a primalidade.

APL (NARS) 41 caracteres, 82 bytes

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

{π⍵} é a fatoração de função do argumento ⍵ na lista de fatores primos (repita se um primo aparecer mais tempo);
{1π⍵} é a função next prime (observe que, neste caso, seu argumento não é um escalar, mas uma matriz de números inteiros). teste:

  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