Is this a consecutive-prime/constant-exponent number?

05AB1E, 4 bytes

Ó0ÛË


Try it online!

Explanation

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


Regex (ECMAScript), 276205201193 189 bytes

Comparing the multiplicities (exponents) of different prime factors is an interesting problem for solving with ECMAScript regex – the lack of backreferences that persist through iterations of a loop makes it a challenge to count anything. Even if counting the numerical trait in question is possible, often a more indirect approach makes for better golf.

As with my other ECMA regex posts, I'll give a spoiler warning: I highly recommend learning how to solve unary mathematical problems in ECMAScript regex. It's been a fascinating journey for me, and I don't want to spoil it for anybody who might potentially want to try it themselves, especially those with an interest in number theory. See this earlier post for a list of consecutively spoiler-tagged recommended problems to solve one by one.

So do not read any further if you don't want some advanced unary regex magic spoiled for you. If you do want to take a shot at figuring out this magic yourself, I highly recommend starting by solving some problems in ECMAScript regex as outlined in that post linked above.

The main payload from a regex I previously developed turned out to be very applicable to this challenge. That is the regex that finds the prime(s) of highest multiplicity. My first solution for that was very long, and I later golfed it way down in stages, first rewriting it to use molecular lookahead, and then porting it back to plain ECMAScript using an advanced technique to work around the lack of molecular lookahead, and subsequently golfing it down to be much smaller than the original plain ECMAScript solution.

The part from that regex that applies to this problem is the first step, which finds Q, the smallest factor of N that shares all of its prime factors. Once we have this number, all we have to do to show that N is a "constant-exponent number" is divide N by Q until we can't any longer; if the result is 1, all primes are of equal multiplicity.

After submitting an answer using my previously developed algorithm for finding Q, I realized that it could be calculated in an entirely different way: Find the largest square-free factor of N (using the same algorithm as my Carmichael number regex). As it turns out, this poses no difficulty at all* in terms of stepping around the lack of molecular lookahead and variable-length lookbehind (no need to pull in the advanced technique previously used), and is 64 bytes shorter! Additionally it eliminates the complexity of treating square-free N and prime N as different special cases, dropping another 7 bytes from this solution.

(There still remain other problems that require the advanced technique formerly used here to golf down the calculation of Q, but currently none of them are represented by my PPCG posts.)

I put the multiplicity test before the consecutive-primes test because the latter is much slower; putting tests that can fail more quickly first makes the regex faster for uniformly distributed input. It's also better golf to put it first, because it uses more backreferences (which would cost more if they were double-digit).

I was able to drop 4 bytes from this regex (193 → 189) using a trick found by Grimy that can futher shorten division in the case that the quotient is guaranteed to be greater than or equal to the 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?)$)) Try it 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?)$
)
)


* It is still cleaner with molecular lookahead, with no special case for N being square-free. This drops 6 bytes, yielding a 195 187 183 byte solution:

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


Here it is ported to variable-length lookbehind:

Regex (ECMAScript 2018), 198195194186 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+)))) Try it online! # For the purposes of these comments, the input number = N. ^ # Assert that all of N's prime factors are of equal multiplicity # Step 1: Find Q, the largest square-free factor of N (which will also be the smallest # factor of N that has all the same prime factors as N) and put it in \1. (?= (x+)(?=\1*$)      # \1 = factor of N; head = \1
(?<=              # This is evaluated right-to-left, so please read bottom to top.
^x
(
(?<!^\5*)        # Assert that head is no longer divisible by \6, i.e. that
# that prime factor was of exactly single multiplicity.
\3               # head = \4
(?<=(^\4+)(x+))  # \4 = head / \5 (implicitly); \3 = tool to make head = \4
(?<=^\5*(x+?x))  # \5 = smallest prime factor of head
)*
)
)
# Step 2: Require that the result of repeatedly dividing tail by \1 is 1.
(
# In the following division calculation, we can skip the test for divisibility
# by \1-1 because it's guaranteed that \2 <= \8. As a result, we did not need to
# capture \1-1 above, and can use a better-golfed form of the division.
(?=
(             # \7 = tail / \1
(x*)      # \8 = \7-1
(?=\1\8+$) x ) (\7*$)        # \9 = tool to make tail = \7
)
\9                # tail = \7
)*
x$# Require that the end result is 1 # Assert that there exists no trio of prime numbers such that N is divisible by the # smallest and largest prime but not the middle prime. # This is evaluated right-to-left, so please read bottom to top, but switch back to # reading top to bottom at the negative lookahead. (?<! # Assert that \13, \15, and \17 are all prime. (?! (\14\16?)? # tail = either \13, \15, or \17 ((xx+)\12+|x?)$
)

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


Jelly, 136 5 bytes

ÆEt0E


Try it online!

Still outgolfed... (thanks Erik for -1 byte)

Explanation

Æ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