Beberapa waktu yang lalu, saya melihat faktorisasi utama 27000:

27000 = 2 ³ × 3 ³ × 5 ³

Ada dua hal khusus tentang itu:

• consecutive-prime : Bilangan prima berturut-turut: 2 adalah prima 1, 3 adalah prima 2, 5 adalah prima 3.
• konstanta-eksponen : Eksponen adalah sama untuk setiap prime (selalu 3)

Secara matematis diungkapkan:

Integer x adalah bilangan berurutan / eksponen konstan jika ada bilangan bulat positif n , k , m sehingga x = p _n ^m × p _{n +1} ^m × ... × p _{n + k} ^m , di mana p _j adalah prime j -th

Tugas Anda adalah menguji apakah bilangan bulat positif memenuhi persyaratan ini.

Memasukkan:

Bilangan bulat positif> 1, dalam bentuk apa pun yang wajar.

Keluaran:

Salah satu dari dua nilai, setidaknya satu di antaranya harus konstan, menunjukkan apakah inputnya adalah bilangan berurutan / prima konstan.

Kasus tepi:

• bilangan prima adalah benar, karena faktorisasi untuk prime p adalah p ¹
• nomor lain yang dapat ditulis sebagai p ^{m di} mana p adalah bilangan prima juga benar.

Aturan:

• Celah standar berlaku.
• Tidak ada kekhawatiran tentang integer overflow, tetapi angka hingga 255 harus berfungsi.
• Kode terpendek dalam byte menang.

Kasus uji:

Benar:

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

Falsy:

10
12
14
72
10000000

Berikut ini adalah skrip python yang menghasilkan beberapa kasus uji.

Fakta bahwa saya menerima jawaban tidak berarti bahwa tantangan sudah selesai; pemenangnya masih bisa berubah!

05AB1E , 4 byte

Ó0ÛË

Cobalah online!

Penjelasan

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

Regex (ECMAScript), 276 205 201 193 189 byte

Membandingkan multiplisitas (eksponen) dari faktor prima yang berbeda adalah masalah yang menarik untuk dipecahkan dengan regex ECMAScript - kurangnya referensi yang bertahan melalui iterasi dari loop membuatnya menjadi tantangan untuk menghitung apa pun. Sekalipun menghitung sifat numerik yang dipermasalahkan adalah mungkin, seringkali pendekatan yang lebih tidak langsung membuat golf lebih baik.

Seperti dengan posting regex ECMA saya yang lain, saya akan memberikan peringatan spoiler: Saya sangat merekomendasikan belajar bagaimana memecahkan masalah matematika unary di ECMAScript regex. Ini adalah perjalanan yang menarik bagi saya, dan saya tidak ingin merusaknya untuk siapa pun yang mungkin ingin mencobanya sendiri, terutama mereka yang tertarik pada teori bilangan.Lihat posting ini sebelumnya untuk daftar masalah yang direkomendasikan untuk ditandai dengan spoiler bertanda satu per satu.

Jadi jangan membaca lebih jauh jika Anda tidak ingin beberapa sihir regex unary canggih dimanjakan untuk Anda . Jika Anda ingin mencoba mencari tahu sendiri keajaiban ini, saya sangat menyarankan memulai dengan menyelesaikan beberapa masalah dalam ECMAScript regex sebagaimana diuraikan dalam pos yang ditautkan di atas.

Payload utama dari regex yang saya kembangkan sebelumnya ternyata sangat berlaku untuk tantangan ini. Itu adalah regex yang menemukan yang terbaik dari multiplisitas tertinggi . Solusi pertama saya untuk itu sangat panjang, dan saya kemudian turun golf secara bertahap, pertama menulis ulang untuk menggunakan lookahead molekuler , dan kemudian porting kembali ke ECMAScript menggunakan teknik canggih untuk mengatasi kekurangan lookahead molekuler , dan kemudian bermain golf menjadi jauh lebih kecil dari solusi ECMAScript polos asli.

Bagian dari regex yang berlaku untuk masalah ini adalah langkah pertama, yang menemukan Q, faktor terkecil N yang memiliki semua faktor prima. Setelah kita memiliki angka ini, yang harus kita lakukan untuk menunjukkan bahwa N adalah "angka eksponen konstan" dibagi N dengan Q sampai kita tidak bisa lagi; jika hasilnya 1, semua bilangan prima memiliki multiplisitas yang sama.

Setelah mengirimkan jawaban menggunakan algoritme yang saya kembangkan sebelumnya untuk menemukan Q, saya menyadari bahwa itu dapat dihitung dengan cara yang sama sekali berbeda: Temukan faktor N bebas kuadrat terbesar (menggunakan algoritme yang sama dengan regex nomor Carmichael saya ). Ternyata, ini tidak menimbulkan kesulitan sama sekali * dalam hal melangkah di sekitar kekurangan molekul lookahead dan melihat-panjang variabel di belakang (tidak perlu menarik teknik canggih yang sebelumnya digunakan), dan 64 byte lebih pendek! Selain itu menghilangkan kompleksitas memperlakukan N bebas dan N prima sebagai kasus khusus yang berbeda, menjatuhkan 7 byte lain dari solusi ini.

(Masih ada masalah lain yang memerlukan teknik canggih yang sebelumnya digunakan di sini untuk mengurangi perhitungan Q, tetapi saat ini tidak satupun dari mereka yang diwakili oleh posting PPCG saya.)

Saya menempatkan tes multiplisitas sebelum tes bilangan prima berturut-turut karena yang terakhir jauh lebih lambat; melakukan tes yang dapat gagal lebih cepat terlebih dahulu membuat regex lebih cepat untuk input yang didistribusikan secara merata. Golf juga lebih baik untuk didahulukan, karena menggunakan lebih banyak referensi (yang akan lebih mahal jika dua digit).

Saya dapat menjatuhkan 4 byte dari regex ini (193 → 189) menggunakan trik yang ditemukan oleh Grimy yang dapat memperpendek pembagian dalam kasus bahwa hasil bagi dijamin lebih besar dari atau sama dengan pembagi.

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

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

* Masih lebih bersih dengan lookahead molekuler, tanpa kasus khusus untuk N yang bebas persegi. Ini turun 6 byte, menghasilkan solusi 195 187 183 byte :

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

Ini porting ke tampilan panjang variabel:

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

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

Cobalah 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 , 13 6 5 byte

ÆEt0E

Cobalah online!

Masih kalah ... (terima kasih Erik untuk -1 byte)

Penjelasan

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

Mengembalikan 0 untuk truey atau integer non-nol untuk 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)

Cobalah online!

Berkomentar

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 byte

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

Cobalah online!

Jawaban pertama saya setelah hampir 2 (!) - istirahat setahun, jadi mungkin bisa bermain golf lebih banyak. Ini adalah blok yang mengambil input sebagai integer (juga bisa dipetakan untuk array integer).

Penjelasan

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

╣♥qJ╬c

Jalankan dan debug itu

Dibongkar, tidak diserang, dan dikomentari, sepertinya ini.

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

Sunting: Ini tidak berfungsi 512. Saya akan memikirkannya dan semoga perbaikan nanti. Ini berfungsi sekarang.

Stax , 9 byte

1 benar, 0 palsu

αAG<└\{┬⌠

Jalankan dan debug itu

Penjelasan

|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

Mungkin bisa bermain golf lebih banyak, tetapi ini mencakup kasus-kasus yang saya lewatkan dalam solusi terakhir.

MATL , 12 11 10 byte

YFtgYsg)Zs

Cobalah di MATL Online!

Terima kasih kepada Luis Mendo untuk bagian hapus-terkemuka-nol. Dia juga menunjukkan bahwa bertukar nilai kebenaran diperbolehkan, jadi ini mengembalikan 0 untuk angka yang memenuhi persyaratan tantangan dan nilai positif apa pun sebaliknya.

Grosso Modo, ini menghasilkan eksponen dari faktorisasi prima berurutan, menghilangkan nol terkemuka dan menghitung standar deviasi.

Java 10, 223 191 178 176 168 byte

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

Kembali 1sebagai kebenaran, dan >=2sebagai kepalsuan.

Cobalah online.

Penjelasan:

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)

Beberapa contoh input:

n=15:

• Bendera tetap ada 1 untuk prime 2 pertama (karena 15 tidak dapat dibagi oleh 2).
• Bendera beralih dari 1ke 0begitu kita berada di prime 3. Sejak 15 dibagi oleh 3, nmenjadi 5 (15/3 ¹ ), dan Set menjadi[] → [1] .
• Kemudian kita periksa prime berikutnya 5. Karena 5 dapat dibagi 5, nmenjadi 1 (5/5 ¹ ), dan Set tetap sama ( [1] → [1]).
• Sekarang n=1, jadi kita hentikan loop luar. Set ( [1]) hanya berisi satu item, 1dari kedua bilangan prima 3 dan 5 yang berdekatan, jadi kami mengembalikan true.

n=14:

• Bendera beralih dari 1ke 0untuk prime 2 pertama (karena 14 dapat dibagi oleh 2). nmenjadi 7 (14/2 ¹ ), dan Set menjadi [] → [1].
• Kemudian kita periksa prime 3 berikutnya. Karena 7 tidak habis dibagi 3, n tetap sama, dan Set menjadi [1] → [1,0].
• Kemudian kita periksa prime 5. berikutnya. Karena 7 juga tidak habis dibagi 5, ntetap sama, dan Set tetap sama juga ([1,0] → [1,0] ).
• Kemudian kita periksa prime 7. berikutnya. Karena 7 dibagi oleh 7, nmenjadi 1 (7/7 ¹ ), dan Set tetap sama ([1,0] → [1,0] ).
• Sekarang n=1, jadi kita hentikan loop luar. Set ( [1,0]) berisi dua item, 1dari bilangan prima 2 dan 7 yang tidak berdekatan, dan 0dari bilangan prima 3 dan 5, jadi kami mengembalikan false.

n=72:

• Bendera beralih dari 1ke 0untuk prime 2 pertama, karena 72 dibagi 2 oleh (berkali-kali). Jadi nmenjadi 9 (72/2 ³ ), dan Set menjadi [] → [3].
• Kemudian kita periksa prime 3 berikutnya. Karena 9 dibagi menjadi 3 (beberapa kali), nmenjadi 1 (9/3 ² ), dan Set menjadi [3] → [3,2].
• Sekarang n=1, jadi kita hentikan loop luar. Set ( [3,2]) berisi dua item, dari 3dari prime 2, dan 2dari prime 3, jadi kami mengembalikan false.

J , 16 byte

Terima kasih banyak kepada FrownyFrog untuk -8 byte!

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

Cobalah online!

Solusi lama saya:

J , 24 byte

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

Cobalah online!

Penjelasan:

_&q: eksponen utama

{.@I.}.] menghapus nol terkemuka dengan menemukan elemen non-nol pertama:

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

1=[:#@~. menguji apakah semua angka yang tersisa sama:

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

Sekam , 11 byte

Λ§*≈¤≈oṗ←gp

Cobalah online!

Menghasilkan 0 jika bukan angka berurutan-prima / konstan-eksponen.

MATL , 7 byte

0iYFhdz

Hasilnya adalah 1 jika input memenuhi persyaratan.

Cobalah online! Atau verifikasi semua kasus uji

Penjelasan

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

Oktaf , 67 byte

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

Cobalah online!

Saya percaya ini adalah satu-satunya solusi yang menggunakan histogram.

Penjelasan:

Ini membuat histogram, di mana variabel yang akan dihitung adalah faktor input, dan ditempatkan di tempat sampah primes(x) , yang semuanya lebih rendah dari input. Kami kemudian menemukan lokasi faktor prima, mengambil perbedaan antara masing-masing indeks dan mengurangi satu. Jika ada elemen yang tidak nol (yaitu selisih indeks bilangan prima bukan 1), maka ini akan menghasilkan nilai palsu, jika tidak maka akan mengembalikan nilai yang sebenarnya.

Kami kemudian chech bahwa semua elemen non-nol dalam histogram sama dengan elemen maksimum. Jika ada nilai yang tidak sama maka ini akan menghasilkan nilai palsu, jika tidak maka akan mengembalikan nilai yang benar.

Jika kedua blok itu benar maka input kami adalah bilangan eksponen konstan prima berturut-turut!

APL (Dyalog Extended) , 28 byte

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

Cobalah online!

Bagaimana:

{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

Bahasa Wolfram (Mathematica) , 65 byte

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

Cobalah online!

Pari / GP , 63 byte

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

Cobalah online!

J , 14 byte

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

1 dalam output menunjukkan eksponen konstan berturut-turut.

Cobalah 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

Bersihkan , 127 byte

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]

Cobalah online!

Menentukan fungsi yang ? :: Int -> Booldigunakan $ :: Int -> [Int]untuk memfaktisasi dan @ :: Int -> Boolmemeriksa primality.

APL (NARS) 41 karakter, 82 byte

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

{π⍵} adalah faktorisasi fungsi argumen ⍵ dalam daftar faktor prima (ulangi jika satu prime muncul lebih banyak waktu);
{1π⍵} adalah fungsi prime berikutnya (perhatikan bahwa dalam kasus ini argumennya bukan skalar tetapi satu array bilangan bulat). uji:

  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