Il y a quelque temps, j'ai jeté un œil à la factorisation de 27000:

27000 = 2 ³ × 3 ³ × 5 ³

Il y a deux choses spéciales à ce sujet:

• consécutive-prime : Les nombres premiers sont consécutifs: 2 est le 1er premier, 3 est le 2ème premier, 5 est le 3ème premier.
• exposant constant : l'exposant est le même pour chaque nombre premier (toujours 3)

Exprimé mathématiquement:

Un entier x est un nombre consécutif premier / exposant constant s'il existe des entiers strictement positifs n , k , m tels que x = p _n ^m × p _{n +1} ^m × ... × p _{n + k} ^m , où p _j est le j premier -ième

Votre tâche consiste à tester si un entier positif remplit ces conditions.

Contribution:

Un entier positif> 1, sous toute forme raisonnable.

Sortie:

L'une des deux valeurs, dont au moins une doit être constante, indiquant si l'entrée est un nombre consécutif premier / exposant constant.

Cas de bord:

• les nombres premiers sont véridiques, car la factorisation de p premier est p ¹
• d'autres nombres qui peuvent s'écrire p ^m où p est un nombre premier sont également vrais.

Règles:

• Des échappatoires standard s'appliquent.
• Pas de soucis de débordement d'entier, mais les nombres jusqu'à 255 doivent fonctionner.
• Le code le plus court en octets gagne.

Cas de test:

Vérité:

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

Faux:

10
12
14
72
10000000

Voici un script python générant des cas de test.

Le fait d'avoir accepté une réponse ne signifie pas que le défi est terminé; le gagnant peut encore changer!

05AB1E , 4 octets

Ó0ÛË

Essayez-le en ligne!

Explication

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

Regex (ECMAScript), 276 205 201 193 189 octets

La comparaison des multiplicités (exposants) de différents facteurs premiers est un problème intéressant à résoudre avec les expressions rationnelles ECMAScript - le manque de références inverses qui persistent à travers les itérations d'une boucle fait qu'il est difficile de compter n'importe quoi. Même s'il est possible de compter le trait numérique en question, une approche plus indirecte permet souvent un meilleur golf.

Comme pour mes autres publications sur les expressions rationnelles ECMA, je vais donner un avertissement de spoiler: je recommande fortement d'apprendre à résoudre des problèmes mathématiques unaires dans les expressions régulières ECMAScript. Ce fut un voyage fascinant pour moi, et je ne veux pas le gâter pour quiconque pourrait vouloir l'essayer lui-même, en particulier ceux qui s'intéressent à la théorie des nombres. Voir ce post précédent pour une liste des problèmes recommandés consécutivement marqués de spoiler à résoudre un par un.

Alors ne lisez pas plus loin si vous ne voulez pas que la magie regex unaire avancée soit gâtée pour vous . Si vous voulez essayer de découvrir cette magie vous-même, je vous recommande vivement de commencer par résoudre certains problèmes dans les expressions rationnelles ECMAScript, comme indiqué dans cet article lié ci-dessus.

La charge utile principale d'une expression régulière que j'ai développée précédemment s'est avérée très applicable à ce défi. C'est l' expression rationnelle qui trouve le ou les nombres premiers de la multiplicité la plus élevée . Ma première solution a été très longue, et je l'ai ensuite étudiée par étapes, la réécrivant d' abord pour utiliser l'antichambre moléculaire , puis la portant à nouveau sur ECMAScript en utilisant une technique avancée pour contourner le manque d'anticipation moléculaire , puis jouer au golf pour être beaucoup plus petit que la solution ECMAScript originale.

La partie de cette expression rationnelle qui s'applique à ce problème est la première étape, qui trouve Q, le plus petit facteur de N qui partage tous ses facteurs premiers. Une fois que nous avons ce nombre, tout ce que nous avons à faire pour montrer que N est un "nombre d'exposants constants" est de diviser N par Q jusqu'à ce que nous ne puissions plus; si le résultat est 1, tous les nombres premiers sont de multiplicité égale.

Après avoir soumis une réponse en utilisant mon algorithme développé précédemment pour trouver Q, je me suis rendu compte qu'il pouvait être calculé d'une manière entièrement différente: Trouver le plus grand facteur sans carré de N (en utilisant le même algorithme que mon expression rationnelle de Carmichael ). Il s'avère que cela ne pose aucune difficulté * en termes de contournement du manque d'anticipation moléculaire et de recherche de longueur variable (pas besoin de recourir à la technique avancée précédemment utilisée), et est 64 octets plus court! De plus, cela élimine la complexité du traitement du N sans carré et du N premier comme différents cas spéciaux, en laissant tomber 7 autres octets de cette solution.

(Il reste encore d'autres problèmes qui nécessitent la technique avancée précédemment utilisée ici pour jouer au golf le calcul de Q, mais actuellement aucun d'entre eux n'est représenté par mes messages PPCG.)

Je mets le test de multiplicité avant le test des nombres premiers consécutifs car ce dernier est beaucoup plus lent; mettre des tests qui peuvent échouer plus rapidement en premier accélère l'expression régulière pour une entrée uniformément distribuée. Il est également préférable de mettre le golf en premier, car il utilise plus de références arrières (qui coûteraient plus cher si elles étaient à deux chiffres).

J'ai pu supprimer 4 octets de cette expression régulière (193 → 189) en utilisant une astuce trouvée par Grimy qui peut encore raccourcir la division dans le cas où le quotient est garanti supérieur ou égal au diviseur.

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

Essayez-le en ligne!

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

* Il est toujours plus propre avec l'anticipation moléculaire, sans cas particulier pour N étant sans carré. Cela laisse tomber 6 octets, ce qui donne une solution de 195 187 183 octets :

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

Ici, il est porté sur une apparence de longueur variable:

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

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

Essayez-le en ligne!

# 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ée , 13 6 5 octets

ÆEt0E

Essayez-le en ligne!

Toujours dépassé ... (merci Erik pour -1 octet)

Explication

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

Renvoie 0 pour la vérité ou un entier non nul pour la fausse.

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)

Essayez-le en ligne!

Commenté

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 octets

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

Essayez-le en ligne!

Ma première réponse après une pause de près de 2 (!) Ans, donc il peut probablement être joué plus. Il s'agit d'un bloc qui prend l'entrée comme un entier (peut également être mappé pour des tableaux d'entiers).

Explication

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

╣♥qJ╬c

Exécuter et déboguer

Déballé, non golfé et commenté, il ressemble à ceci.

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

Modifier: cela ne fonctionne pas 512. Je vais y réfléchir et, espérons-le, une solution plus tard. Ça fonctionne maintenant.

Stax , 9 octets

1 est vrai, 0 est faux

αAG<└\{┬⌠

Exécuter et déboguer

Explication

|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

Peut probablement être plus joué au golf, mais il couvre les cas qui me manquaient dans la dernière solution.

MATL , 12 11 10 octets

YFtgYsg)Zs

Essayez-le sur MATL Online!

Merci à Luis Mendo pour la partie supprimer les zéros non significatifs. Il a également souligné que l'échange de valeurs de vérité est autorisé, ce qui renvoie 0 pour les nombres qui satisfont aux exigences du défi et toute valeur positive dans le cas contraire.

Grosso Modo, cela génère les exposants de la factorisation première séquentielle, supprime les zéros en tête et calcule l'écart type.

Java 10, 223 191 178 178 176 168 octets

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

Retourne 1comme véridique et >=2comme falsey.

Essayez-le en ligne.

Explication:

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)

Quelques exemples d'entrées:

n=15:

• Le drapeau reste 1pour le premier premier 2 (car 15 n'est pas divisible par 2).
• Le drapeau passe de 1à 0dès que nous sommes au premier 3. Puisque 15 est divisible par 3, ndevient 5 (15/3 ¹ ), et l'ensemble devient [] → [1].
• Ensuite, nous vérifions le premier premier 5. Puisque 5 est divisible par 5, ndevient 1 (5/5 ¹ ), et l'ensemble reste le même ( [1] → [1]).
• Maintenant n=1, nous arrêtons la boucle externe. Set ( [1]) ne contient qu'un seul élément, celui 1des deux nombres premiers adjacents 3 et 5, donc nous retournons vrai.

n=14:

• Le drapeau va de 1à 0pour le premier premier 2 (car 14 est divisible par 2). ndevient 7 (14/2 ¹ ), et l'ensemble devient [] → [1].
• Ensuite, nous vérifions le premier premier 3. Puisque 7 n'est pas divisible par 3, nreste le même, et l'ensemble devient [1] → [1,0].
• Ensuite, nous vérifions le premier premier 5. Puisque 7 n'est pas non plus divisible par 5, nreste le même, et l'ensemble reste le même ( [1,0] → [1,0]).
• Ensuite, nous vérifions le premier premier 7. Puisque 7 est divisible par 7, ndevient 1 (7/7 ¹ ), et l'ensemble reste le même ( [1,0] → [1,0]).
• Maintenant n=1, nous arrêtons la boucle externe. Set ( [1,0]) contient deux éléments, celui 1des nombres premiers non adjacents 2 et 7, et celui 0des nombres premiers 3 et 5, donc nous retournons faux.

n=72:

• Le drapeau va de 1à 0pour le premier premier 2, car 72 est divisible par 2 (plusieurs fois). Devient nainsi 9 (72/2 ³ ), et l'ensemble devient [] → [3].
• Ensuite, nous vérifions le premier premier 3. Puisque 9 est divisible par 3 (plusieurs fois), ndevient 1 (9/3 ² ), et l'ensemble devient [3] → [3,2].
• Maintenant n=1, nous arrêtons la boucle externe. Set ( [3,2]) contient deux éléments, le 3from prime 2 et le 2from prime 3, nous retournons donc false.

J , 16 octets

Un grand merci à FrownyFrog pour -8 octets!

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

Essayez-le en ligne!

Mon ancienne solution:

J , 24 octets

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

Essayez-le en ligne!

Explication:

_&q: principaux exposants

{.@I.}.] supprime les zéros non significatifs en trouvant le premier élément non nul:

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

1=[:#@~. teste si tous les nombres restants sont égaux:

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

Husk , 11 octets

Λ§*≈¤≈oṗ←gp

Essayez-le en ligne!

Renvoie 0 si ce n'est un nombre consécutif premier / exposant constant.

MATL , 7 octets

0iYFhdz

Le résultat est 1si une entrée satisfait à l'exigence.

Essayez-le en ligne! Ou vérifiez tous les cas de test

Explication

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

Octave , 67 octets

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

Essayez-le en ligne!

Je pense que c'est la seule solution qui utilise un histogramme.

Explication:

Cela fait un histogramme, où la variable à compter sont les facteurs de l'entrée, et placés dans les bacs primes(x) , qui sont tous des nombres premiers inférieurs à l'entrée. Nous trouvons ensuite l'emplacement des facteurs premiers, prend la différence entre chacun des indices et soustrayons un. S'il y a des éléments qui ne sont pas nuls (c'est-à-dire que la différence des indices des nombres premiers n'est pas 1), alors cela se traduira par une valeur fausse, sinon cela retournera une valeur vraie.

On vérifie ensuite que tous les éléments non nuls de l'histogramme sont égaux à l'élément maximum. S'il y a des valeurs qui ne sont pas égales, cela se traduira par une valeur fausse, sinon cela renverra une valeur vraie.

Si ces deux blocs sont véridiques, notre entrée est un nombre d'exposants constants premiers consécutifs!

APL (Dyalog Extended) , 28 octets

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

Essayez-le en ligne!

Comment:

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

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

Essayez-le en ligne!

Pari / GP , 63 octets

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

Essayez-le en ligne!

J , 14 octets

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

1 dans la sortie indique un exposant constant consécutif.

Essayez-le en ligne!

        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

Nettoyer , 127 octets

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]

Essayez-le en ligne!

Définit la fonction à l' ? :: Int -> Boolaide $ :: Int -> [Int]de la factorisation et @ :: Int -> Boolde la vérification de la primalité.

APL (NARS) 41 caractères, 82 octets

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

{π⍵} est la factorisation de la fonction de l'argument ⍵ dans la liste des facteurs premiers (répétez si un nombre premier apparaît plus longtemps);
{1π⍵} est la fonction next prime (notez que dans ce cas, son argument n'est pas un scalaire mais un tableau d'entiers). tester:

  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