Bu bir ardışık-asal / sabit üslü sayı mı?


22

Bir süre önce, 27000’in temel çarpanlarına bir baktım:

27000 = 2 3 × 3 3 × 5 3

Bununla ilgili iki özel şey var:

  • ardışık-asal : Asallar ardışıktır: 2, birinci asal, 3, ikinci asal, 5, asaldır.
  • sabit üs : üs, her asal için aynıdır (her zaman 3)

Matematiksel olarak ifade edilir:

Bir tam sayı x katı pozitif tamsayılar mevcut ise ardışık bir prime / sabit üs sayıdır , n , k , m , öyle ki x = p , n m x s , n + 1 m x ... x s , n + k m , p j , j- üssüdür

Göreviniz, pozitif bir tamsayının bu koşulları sağlayıp sağlamadığını test etmektir.

Giriş:

Herhangi bir makul biçimde> 1 olan pozitif bir tamsayı.

Çıktı:

Girişin ardışık-asal / sabit-üs-üs numarası olup olmadığını gösteren en az birinin sabit olması gereken iki değerden biri.

Kenar durumlarda:

  • asal için çarpanlara olarak asal, truthy olan p olan p 1
  • olarak yazılabilir diğer sayılar p m p bir asal olduğu da truthy vardır.

Kurallar:

  • Standart boşluklar uygulanır.
  • Tamsayı taşması konusunda endişelenmeyin, ancak 255'e kadar sayıların çalışması gerekir.
  • Bayt cinsinden en kısa kod kazanır.

Test durumları:

Truthy:

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

Falsy:

10
12
14
72
10000000

İşte bazı test senaryoları üreten bir python betiği.

Bir cevabı kabul etmem gerçeği, mücadelenin bittiği anlamına gelmez; kazanan hala değişebilir!


Muhtemelen bu şekilde tüm bu numaraların bir listesini oluşturarak ve girişin listede olup olmadığını kontrol ederek başka bir yoldan gelebilirsiniz
Engineer Toast

@EngineerToast Yine de sonsuz sayıda truthy sayısı var.
Alexis Olson

@AlexisOlson Tabii, ancak birçok dilde tamsayı olarak kullanılabilecek bir sonlu.
Mühendis Toast,

Matematiksel ifadeniz Pj'nin rolle bir ilgisi yok x = Pn^m. Sanırım, Pn, n'inci birinci sırada.
Veskah,

@Veskah n belirli bir değer (ilk asal bölme endeksi vardır x bunu söyleyerek,) Pn olan n -inci asal da ima etmek istiyorsanız garip Pn + 1 olan n + 1 'inci asal.
Dennis,

Yanıtlar:


13

05AB1E , 4 bayt

Ó0ÛË

Çevrimiçi deneyin!

açıklama

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

ÎÓKËBundan başka düşünebildiğim tek şey, güzel olan ... Düşünüyordum ßama düşündüğümün tersini yapıyor.
Sihirli Ahtapot Urn

7

Regex (ECMAScript), 276 205 201 193 189 bayt

Farklı asal faktörlerin çarpımlarının (üstlerinin) karşılaştırılması, ECMAScript regex ile çözme için ilginç bir sorundur - bir döngünün yinelemeleriyle devam eden geri dönüşlerin olmaması, bir şeyi saymak için zorlaştırır. Söz konusu sayısal özelliği saymak bile mümkün olsa da, genellikle daha dolaylı bir yaklaşım daha iyi golf oynamayı sağlar.

Diğer ECMA regex yayınlarımda olduğu gibi, bir spoiler uyarısı vereceğim : ECMAScript regex’te sıradan matematik problemlerini nasıl çözeceğinizi öğrenmenizi şiddetle tavsiye ederim. Benim için büyüleyici bir yolculuk oldu ve bunu denemek isteyebilecek herhangi biri için, özellikle de sayı teorisine ilgi duyanlar için onu mahvetmek istemiyorum. Birbiri ardına çözmek için art arda spoiler etiketli önerilen sorunların bir listesi için bu önceki yazıya bakın .

Bu yüzden , sizin için şımarık bazı gelişmiş regex sihrini istemiyorsanız, daha fazla okumayın . Bu sihri kendiniz bulmaya bir göz atmak isterseniz, yukarıda belirtilen bağlantıda belirtildiği gibi ECMAScript regex'teki bazı sorunları çözerek başlamanızı şiddetle tavsiye ederim.

Daha önce geliştirdiğim bir regex'in ana yükünün bu zorluğa çok uygun olduğu ortaya çıktı. En yüksek çokluğun asalını bulan regex'tir . Bunun için ilk çözüm çok uzun oldu ve daha sonra ilk yolu aşağı aşamalarında bunu golfed moleküler lookahead kullanmak için yeniden sonra ve geri düz ECMAScript'e için taşıma için gelişmiş bir teknik kullanılarak moleküler lookahead eksikliği etrafında çalışması ve daha sonra Orijinal ECMAScript çözümünden çok daha küçük olması için aşağı doğru golf oynamaya.

Bu soruna uygulanan söz konusu regex'ten gelen bölüm, tüm ana faktörleri paylaşan en küçük N faktörü olan Q'yu bulan ilk adımdır. Bu sayıya sahip olduktan sonra, N'nin bir "sabit üs sayısı" olduğunu göstermek için tek yapmamız gereken, artık yapamayana kadar Q'yu N'ye bölmek; sonuç 1 ise, tüm primler eşit çokluğa sahiptir.

Q bulmak için önceden geliştirilen algoritmamı kullanarak bir cevap gönderdikten sonra, bunun tamamen farklı bir şekilde hesaplanabileceğini fark ettim: En büyük N kare-kare faktörünü bulun ( Carmichael sayı regex'im ile aynı algoritmayı kullanarak ). Görünüşe göre, bu, moleküler bakış açılarının ve değişken uzunluktaki gözlerin yokluğunun (daha önce kullanılan ileri teknikten çekmeye gerek kalmaması) etrafındaki adım atma konusunda hiçbir zorluk * yaratmıyor ve 64 byte daha kısa! Ek olarak, kare içermeyen N ve asal N'i farklı özel durumlar olarak ele almanın karmaşıklığını ortadan kaldırarak, bu çözümden 7 baytı daha düşürür.

(Eskiden burada Q hesaplamasını yapmak için kullanılan ileri teknik gerektiren başka problemler var, ancak şu anda hiçbiri PPCG postalarım tarafından temsil edilmiyor.)

Çokluk testini ardışık primerler testinden önce koydum çünkü ikincisi çok daha yavaş; daha hızlı bir şekilde başarısız olabilecek testleri koymak, ilk önce düzgün dağılmış giriş için regex'i daha hızlı hale getirir. Ayrıca ilk önce koymak daha iyidir, çünkü daha fazla geri dönüş kullanır (eğer iki basamaklı olsaydı daha pahalı olurdu).

Bölümün bölene eşit veya ondan daha büyük olması garanti edildiğinde daha fazla bölünmeyi daha da kısaltabilecek bir hile kullanarak bu regex'ten (193 → 189) 4 bayt bırakmayı başardım .

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

Çevrimiçi deneyin!

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


* N'nin karesiz olması için özel bir durum olmadan, moleküler görünüşle hala daha temiz. Bu işlem 6 baytlık bir düşüşle 195 187 183 baytlık bir çözüm üretiyor :

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

Burada değişken uzunluktaki gözbebekine taşınır:

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

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

Çevrimiçi deneyin!

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

Sen yerini alabilir .*$\2ile\2^
H.PWiz

Buna rağmen, bunun geçerli olduğuna inanıyorum:^(?=(|(x+)\2*(?=\2$))(((?=(xx+?)\5*$)(?=(x+)(\6+$))\7(?!\5*$))*x$))(?!(((xx+)(?=\10+$)(x+))(?!\9+$)(x+))\8*(?=\8$)(?!(\12\11?)?(xx+)\14+$))((?=((x*)(?=\2\17+$)x)(\16*$))\19)*\3$
H.PWiz

Optimal olsa yakın görünmüyor
H.PWiz

6

Jöle , 13 6 5 bayt

ÆEt0E

Çevrimiçi deneyin!

Yine de aşıldı ... (Erik -1 bayt için teşekkürler)


açıklama

Æ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

œl-> t. Sonrasındaki sıfırların ilingE çıktısında mevcut olması için hiçbir neden yoktur.
Outgolfer Erik


@dylnan Bu 2250 için başarısız olur .
Dennis,

@Dennis Teşekkürler, işe yaramayacağını fark ettim ama dört baytlık bir çözüme ilham vereceğini umuyorum
dylnan

6

JavaScript (ES6), 87 bayt

İade 0 truthy veya falsy için, sıfır olmayan bir tamsayı.

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)

Çevrimiçi deneyin!

Yorumlananlar

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

Bu değişim ile kırıldı j||ietmek i. Şimdi birçok yanlış pozitif sonuç veriyor.
Deadcode

@Deadcode Bunu şu an için kontrol edemiyorum veya düzeltemiyorum, bu yüzden şimdilik geri aldım.
Arnauld

5

CJam , 30 29 bayt

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

Çevrimiçi deneyin!

Yaklaşık 2 (!) Yıllık bir aradan sonra ilk cevabım, bu yüzden muhtemelen daha fazla golf olabilir. Bu bir tamsayı olarak girdi alan bir bloktur (tamsayı dizileri için de eşlenebilir).

açıklama

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

5

Stax , 5 6 bayt

╣♥qJ╬c

Koş ve hata ayıkla

Ambalajsız, ağzı açılmış ve yorumlanmış gibi görünüyor.

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

Düzenleme: Bu işe yaramaz 512. Biraz düşüneceğim ve umarım daha sonra düzelteceğim. Şuan çalışıyor.


3

Stax , 9 bayt

1 truthy, 0 sahtedir

αAG<└\{┬⌠

Koş ve hata ayıkla

açıklama

|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

Muhtemelen daha çok golf oynayabilir, ancak son çözümde kaçırdığım davaları kapsar.


3

MATL , 12 11 10 bayt

YFtgYsg)Zs

MATL Online'da deneyin!

Sıfırları sıfırlama bölümü için Luis Mendo'ya teşekkürler. Ayrıca takas gerçeği değerlerine izin verildiğine de dikkat çekti, bu nedenle bu , meydan okuma gereksinimlerini karşılayan sayılar ve aksi takdirde herhangi bir pozitif değer için 0 döndürüyor .

Grosso Modo, bu sıralı asal çarpanlara ayırmanın üslerini oluşturur, baştaki sıfırları siler ve standart sapmayı hesaplar.


Bence 0iYFhdz7 bayt için çalışıyor: ardışık çarpanlara ayırma, ardışık farklılıklar, sıfır olmayanların sayıları için 0 hazırla. Sonuçta 1iff girişi gereksinimi karşılar
Luis Mendo

@LuisMendo Gecikmiş cevap için özür dilerim, ancak bunu ayrı bir cevap olarak gönderebilirsiniz. Kesinlikle çok farklı.
Bay Xcoder

Tamam, cevap olarak gönderdim
Luis Mendo

3

Java 10, 223 191 178 176 168 bayt

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

1Gerçeği ve falsey olarak döndürür >=2.

Çevrimiçi deneyin.

Açıklama:

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)

Bazı örnek girişler:

n=15:

  • Bayrak 1ilk ana 2 için kalır (çünkü 15 2 ile bölünemez).
  • Bayrak gider 1için 0en kısa sürede 15 beri asal 3. konum olarak 3 ile bölünebilir olduğu, n5 (15/3 olur 1 ) ve Set olur [] → [1].
  • Sonra bir sonraki asal 5'i kontrol ederiz. 5 5 ile bölünebildiğinden, n1 (5/5 1 ) olur ve Set aynı kalır ( [1] → [1]).
  • Şimdi n=1dış döngüyü durduruyoruz. Set ( [1]) sadece bir öğe içeriyor 1, her ikisi de bitişik 3 ve 5 primerlerinden, bu yüzden true çıkıyoruz.

n=14:

  • Bayrak gider 1için 0(2 ile bölünebilir 14 çünkü) ilk asal 2 için. n7 (14/2 1 ) olur ve Set olur [] → [1].
  • Ardından bir sonraki asal 3'ü kontrol ederiz. 7, 3 ile bölünemediğinden n, aynı kalır ve Set olur [1] → [1,0].
  • Sonra bir sonraki asal 5'i kontrol ederiz. 7 aynı zamanda 5 ile bölünemez nolduğu için aynı kalır ve Set aynı şekilde kalır ( [1,0] → [1,0]).
  • Sonra bir sonraki asal 7'yi kontrol ederiz. 7, 7 ile bölünebildiğinden, n1 (7/7 1 ) olur ve Set aynı kalır ( [1,0] → [1,0]).
  • Şimdi n=1dış döngüyü durduruyoruz. Set ( [1,0]), 1bitişik olmayan primer 2 ve 7'den ve 0primer 3 ve 5'ten iki öğe içerir , bu yüzden false döndürürüz.

n=72:

  • Bayrak gider 1üzere 072 2 (birden çok kez) ile bölünebilir olduğu için, ilk asal 2 kişilik. Böylece n9 (72/2 3 ) olur ve Set olur [] → [3].
  • Sonra bir sonraki asal 3'ü kontrol ederiz. 9 9'a bölünebildiğinden, n1 (9/3 2 ) olur ve Set olur [3] → [3,2].
  • Şimdi n=1dış döngüyü durduruyoruz. Set ( [3,2]), 3asal 2 ve 2asal 3 olmak üzere iki öğe içerir , bu yüzden false döndürürüz.

1
Bir <2int'yi kaldırabilir ve geri döndürebilirsiniz (truthy için 1 döndürdüğünüzü belirtin).
18'de

@wastl Ah, tutarlı olan iki değerden sadece birinin kuralını kaçırdı. Bu durumda 1truthy ve 2daha yüksek falsey . Teşekkürler.
Kevin Cruijssen

Bana kim ödül verdi, ama neden?
Kevin Cruijssen

1
ECMAScript yanıtıma daha fazla dikkat çekmek için bir "mevcut cevabı ödüllendirdi" ödülüne başladım, hala kazanıldığından daha fazlasını hak ettiğini düşünüyorum (ödülün başarısız olduğunu düşünürdüm). Hafta bittiğinde, ödülü vermek için kendimden başka bir cevap seçmek ya da en yüksek oy alanlara varsayılan olarak bırakmak zorunda kaldım. Bunu hak ettiğini düşünmedim, ancak cevabınız en iyi açıklamayı yaptı ve bu yüzden size verdim; PPCG'de iyi açıklamalar çok nadirdir. Cevabım gelince, zamanım olduğunda planladığım daha iyi bir yazı yazmam gerektiğini düşünüyorum.
Deadcode

1
@Deadcode Ah, bu yüzden. Belki birisinin ödül almaya başladığını düşündüm, ama yanlışlıkla bırakmalarına izin verdiler ve bana geldi. Yine de biraz sonra neden benim cevabımın en yüksek olduğu değil de kafam karıştı. Tüm Regex cevaplarından etkilendiğimi söylemeliyim. Onlardan bazılarını gördüm ve her zaman şaşırdım. Özellikle de aynı cevaba daha sonra döndüğümde daha çok golf oynuyorsun. : DI fark ettim ki bu meydan okuma için bir tanesini görmedim ya da ondan haksızlık ettim, ben de yaptım. Biliyor musun, bu cevabına bir lütuf katacağım . :)
Kevin Cruijssen

2

J , 16 bayt

FrownyFrog'a -8 bayt için teşekkürler!

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

Çevrimiçi deneyin!

Eski çözümüm:

J , 24 bayt

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

Çevrimiçi deneyin!

Açıklama:

_&q: ana üsler

{.@I.}.] ilk sıfır olmayan öğeyi bularak baştaki sıfırları kaldırır:

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

1=[:#@~. Kalan tüm sayıların eşit olup olmadığını test eder:

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



2

Octave , 67 bayt

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

Çevrimiçi deneyin!

Bunun histogram kullanan tek çözüm olduğuna inanıyorum.

Açıklama:

Bu sayılacak değişkenin girdi faktörleri olduğu ve primes(x)tümü girdiden daha küçük olan kutulara yerleştirildiği bir histogram oluşturur . Daha sonra ana faktörlerin yerlerini buluruz, endekslerin her biri arasındaki farkı alır ve birini çıkarırız. Sıfır olmayan herhangi bir öğe varsa (yani asal sayıların indekslerinin farkı 1 değilse), o zaman bu sahte bir değere yol açar, aksi takdirde bir truthy değeri döndürür.

Daha sonra histogramdaki sıfır olmayan tüm öğelerin maksimum öğeye eşit olduğunu kontrol ediyoruz. Eşit olmayan değerler varsa, bu sahte bir değere yol açar, aksi takdirde bir gerçek değer döndürür.

Bu blokların her ikisi de truthy ise, girişimiz ardışık bir ana sabit üs numarasıdır!


1

APL (Dyalog Genişletilmiş) , 28 bayt

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

Çevrimiçi deneyin!

Nasıl:

{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



0

J , 14 bayt

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

Çıkıştaki 1 ardışık sabit üssü gösterir.

Çevrimiçi deneyin!

        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

0

127 bayt temiz

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]

Çevrimiçi deneyin!

Faktörleşmeyi ve ilkelliği kontrol etmeyi ? :: Int -> Boolkullanarak işlevi tanımlar .$ :: Int -> [Int]@ :: Int -> Bool


0

APL (NARS) 41 karakter, 82 bayt

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

{π⍵}, asal çarpanlar listesindeki ⍵ argümanının işlev çarpanlaştırmasıdır (bir asal daha fazla zaman gelirse tekrarlayın);
{1π⍵} bir sonraki asal fonksiyondur (bu durumda argümanının skaler değil bir tamsayı dizisi olduğunu unutmayın). Ölçek:

  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 
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.