Bir Pillai asal bir asal sayıdır olumlu orada mevcut olduğu böyle ve .m ( m ! + 1 ) ≡ $p$$m$$(m! + 1) \equiv 0 \:(\text{mod } p)$$p \not\equiv 1\:(\text{mod }m)$

Diğer bir deyişle, bir tam sayı $p$ eğer bu bir bir Pillai asal asal sayı bir pozitif tamsayı mevcutsa, $m$ , öyle ki faktör bir $m$ , artı $1$ bölünemeyen bir $p$ ve eğer $p - 1$ ile bölünebilir değildir $m$ .

Girdi olarak pozitif bir tamsayı verildiğinde, bunun bir Pillai üssü olup olmadığına karar verin. Pillai primlerinin dizisi OEIS A063980'dir .

Örneğin, $23$ bir Pillai üssüdür çünkü:

• Sadece 2 faktörü olan asal bir sayıdır.
• $m = 14$ ve $m = 18$ yukarıdaki koşulları karşılar: $23 \mid (14! + 1)$ ve 14 22'yi$14$ bölmez ; 23 \ mid (18! + 1) ve 18 de 22'yi bölmez.$22$$23 \mid (18! + 1)$$18$$22$

Test senaryoları

Doğru:

23
59
83
109
139
593

Falsy:

5
7
8
73
89
263
437

Truthy durumlarda, ilgili m 'ler [(23, [14, 18]), (59, [15, 40, 43]), (83, [13, 36, 69]), (109, [86]), (139, [16]), (593, [274])].

Standart karar problemi çıktı biçimini (doğruluk / falsy değerleri) izleyebilir veya Pillai primeleri için tutarlı bir değere ve aksi takdirde tutarlı olmayan bir değere sahip olabilirsiniz .

Herhangi bir programlama dilinde rekabet edebilir ve herhangi bir standart yöntemle girdi alabilir ve çıktı sağlayabilir , bu boşlukların varsayılan olarak yasaklandığını unutmayın . Bu kod golf , bu nedenle her dil için en kısa gönderme (bayt cinsinden) kazanır.

Python 2 , 115 111 110 109 bayt

^{Bay Xcoder sayesinde -6 bayt}

lambda n:n>2and cmp(*map(all,zip(*[[n%x==1or~f(x)%n,n%x]for x in range(2,n)])))<0
f=lambda x:0**x or x*f(x-1)

Çevrimiçi deneyin!

Fonksiyonlar iki parçadan oluşur ~-n%x<1or~f(x)%n>0doğrular eğer n yok karşılayan "Pillai koşulları" ve n%x>0asal doğrulama için.
Bundan sonra allher iki öğelere uygulanır, ilk öğe içerecektir False/ 0orada eğer olduğunu , geçerli bir "Pillai numarası", ikincisi içerecektir True/ 1eğer nasal olduğunu.
Bunlar bu cenario'da cmpgeri dönecek -1olana geçer (geçerli bir Pillai üssüdür). Diğer kombinasyonlar [[0, 0], [1, 0], [1, 1]]geri döner 0veya1

Jöle , 11 8 bayt

Ṗ!%ẹ’ḍ’E

Pillai üssü için 0 , aksi takdirde 1 değerini döndürür .

Çevrimiçi deneyin!

Nasıl çalışır

Ṗ!%ẹ’ḍ’E  Main link. Argument: n

Ṗ         Pop; yield [1, ..., n-1].
 !        Take the factorial of each integer.
  %       Take the factorials modulo p.
   ẹ’     Find all indices of n-1.
     ḍ’   Test n-1 for divisibility by each of these indices.
       E  Return 1 if all of the resulting Booleans are equal (all 1 means there is
          no suitable m, all 0 means n is not prime), 0 if they are different.

Pari / GP , 44 bayt

p->isprime(p)&&sum(m=2,p,p%m-1&&!((m!+1)%p))

Çevrimiçi deneyin!

Brachylog , 19 bayt

ṗ>.ḟ+₁;?%0&-₁;.%>0∧

Çevrimiçi deneyin!

Sorunun oldukça basit çevirisi:

ṗ          Input is a prime
>.         And output is a number less than the input
ḟ+₁;?%0    And output's factorial + 1 mod input is 0
&-₁;.%>0   And input - 1 mod output is greater than 0
∧          No further constraints

J , 30 26 bayt

FrownyFrog sayesinde -4 bayt

1 e.i.((|1+!)~<1~:|)1&p:*]

Çevrimiçi deneyin!

Açıklama:

                        1&p:*]      checks if the number is prime and if not sets it to 0
                   1~:|             checks if p is not 1 mod m
           (|1+!)~                  m factorial plus 1 modulo n
                  <                 are both conditions met?  
       i.                           generates successive m's (a list 0..n-1)
   1 e.                             1's are at the indices of m, so if there's 1 - Pillai

Python 2 , 65 64 53 52 bayt

f=lambda n,k=3,m=2:~m%n<1<n%k%(n%~-k)or f(n,k+1,m*k)

Çıktı, bir hatanın varlığı veya yokluğu yoluyla gerçekleşir.

Çevrimiçi deneyin!

Python 2 , 109107 bayt

lambda p:any(~-p%m>~l(m)%p<1for m in range(2,p))*all(p%i for i in range(2,p-1))
l=lambda a:0**a or a*l(a-1)

Çevrimiçi deneyin!

açıklama

lBu nedenle, geçirilen bir sayının faktörünü bulur 5giriş olarak döndüğü 120.

all(p%i for i in range(2,p-1))Çekler bir sayı asal sayı ise bizim diğer koşullar zaten o out kural olarak, biz 0 ve 1 görmezden görmek için.

Son olarak, any(~-p%m>-~l(m)%p==0for m in range(2,p))ihtiyaçlarımızı karşılayıp karşılamadığını görmek için tüm potansiyel m'leri yinelemek için kullanırız . ~-panlamına gelir p+1. Sonra biz daha büyük olup olmadığını kontrol eder -~l(m)%p(çevirir (m!-1)%pve sonra karşılaştırırız 0. Temelde ~-p%m0'dan büyük ve 0 -~l(m)%polmalıdır.

Kaynaklar

• Çarpınım tarafından 0xKirill

İyileştirmeler

• 109'dan 107'ye, Bay Xcoder

Muhtemelen tio bağlantısında görebileceğiniz gibi tüm durumlar geçmiyor, çünkü js büyük sayıları işleyemiyor, bu tür bir gereksinim varsa hasta uygulamayı deneyin :)

F%n>n-2&(F+1)%n<1yanlış pozitif önlemek için bir çift kontrol var (ama js büyük sayı sorunları ile tersi değil, gerçekten (F+1)%n<1küçük sayılara ihtiyacımız var, bu yüzden çözüm bayt sayısını 60'a düşürüyor

JavaScript (Node.js) , 90 88 86 72 68 bayt

• 1 bayt azalttığı için Arnauld'a teşekkürler

f=(n,F=i=2,g=0)=>n%i?f(n,F*=++i,g|=F%n>n-2&(F+1)%n<1&~-n%i>0):i==n*g

Çevrimiçi deneyin!

Brachylog , 13 bayt

>.ḟ+₁ḋ∋?-₁f≡ⁿ

Çevrimiçi deneyin!

Pillai primerleri için başarılı olur, çıkış değişkeni boyunca en küçük m değerini sağlar ve başka bir şey için başarısız olur. Bunun bayt'ı sundar çözümüne nasıl kaydettiğinin büyük bir kısmı, bazı oldukça büyük sayıların asal çarpanlarını tekrar tekrar hesaplaması olduğundan, daha büyük girdilerde inanılmaz derecede yavaştır. (Dizüstü bilgisayarım pil gücüyle çalışmadığında muhtemelen bu vakaları yerel Brachylog kurulumumda çalıştıracağım.)

 .               The output
>                is less than the input,
       ?         the input
      ∋          is an element of
     ḋ           the prime factorization of
 .               the output's
  ḟ              factorial
   +₁            plus one,
           ≡ⁿ    and the output is not an element of
          f      the list of all factors of
       ?         the input
        -₁       minus one.

[Perl], 45 bayt

use ntheory":all";is_prime($n)&&is_pillai($n)

Sayı teorisi modülü, yerleşik işlevler olarak tahminlere sahiptir (is_pillai aslında 0 veya en küçük m değerini döndürür, bu nedenle A063828'i de çözer). Temel C ve Perl kodu golf değildir (elbette). C kodu şuna benzer:

UV pillai_v(UV n) {
  UV v, fac = 5040 % n;
  if (n == 0) return 0;
  for (v = 8; v < n-1 && fac != 0; v++) {
    fac = (n < HALF_WORD) ? (fac*v) % n : mulmod(fac,v,n);
    if (fac == n-1 && (n % v) != 1)
      return v;
  }
  return 0;
}

(genel olarak UV'yi uint64_t veya benzeriyle değiştirin ve HALF_WORD, çok parçalı ürünü basit yerel işlemlere optimize edip edemeyeceğimize karar verir).

Saf Perl kodu şuna benzer:

sub is_pillai {
  my $p = shift;
  return 0 if $p <= 2;
  my($pm1, $nfac) = ($p-1, 5040 % $p);
  for (my $n = 8; $n < $p; $n++) {
    $nfac = mulmod($nfac, $n, $p);
    return $n if $nfac == $pm1 && ($p % $n) != 1;
  }
  0;
}

C (gcc) , 64 bayt

f(n,k,m,r){for(k=m=1,r=0;k<n;m=m*++k%n)r|=m/~-n<<(n%k==1);r/=3;}

Çevrimiçi deneyin!

Fısıltılar v2 , 230 bayt

> 1
> Input
>> 1…2
>> L!
>> L+1
>> L∣2
>> L⋅R
>> 2%L
>> Each 4 3
>> Each 5 9
>> Each 6 10
>> Each 7 11 3
> {0}
>> 12∖13
>> Each 8 14
>> L≠1
>> Each 16 15
>> Each 7 17 15
>> 18∖13
>> [19]
>> 2’
>> 21⋅20
>> Output 22

Çevrimiçi deneyin!

Bu, Pillai olmayan asallar için boş bir liste, aksi takdirde boş olmayan bir liste döndürür.

Nasıl çalışır

Fısıltılar, gerçek / karmaşık sayılar üzerinde manipülasyon için tasarlandı, iyi bir ölçüm için biraz dizi komutları eklendi, böylece Eacholuşturulan listeler üzerinde tekrarlamak için tekrarlanan kullanımı .

Fısıltılar hakkında biraz bilgi:

Fısıltılar, diğer dillerin çoğunun yürütme yolunda biraz farklıdır. Her satırda doğrusal olarak çalışmak yerine, yalnızca koşullu dallanma, Whispers dosyadaki son satırda başlar >(kurallar bundan biraz daha karmaşıktır, ancak şimdilik bilmemiz gereken tek şey) ve sayıların anlamları satırın >veya ile başlayıp başlamadığına bağlı olarak farklılık gösterir >>.

Çizgi ile başlarsa >gibi, > 1ya da > Input, bu bir sabit hat - aynı değer her bir zaman verir. Burada, sayılar sayısal formlarını temsil eder, bu nedenle ilk satır çağrıldığında her zaman 1 değerini döndürür .

>>Bununla birlikte, hat ile başlarsa , numaralar diğer satırlara referans olarak kabul edilir, eğer isterseniz, benzer işlev çağrıları gibi. Örneğin, satırda >> 1…2, bu …komut 1 ve 2 tamsayılarında değil, satır 1 ve 2'den döndürülen değerlerde komutu yerine getirir . Bu durumda, bu değerler 1 tamsayısıdır ve girdi olarak hangi tamsayıyı geçiririz.

Bu örnek için, 23 girişini ele alalım . Whispers'in önişlemi nedeniyle ikinci satırın ( > Input) dönüştürüldüğünü unutmayın > 23.

Bizim ilk komut satırında 3 üzerindedir: >> 1…2. …diyadik aralığı bu durumda gelen, olan , 1 ile 23 elde edildi, {1, 2, ... 22, 23} . Sonra, satır aşağı atlamak 9 ile 12 :

>> Each 4 3
>> Each 5 9
>> Each 6 10
>> Each 7 11 3

Burada Each, her biri bir önceki sonuç üzerinde yinelenen 4 temelde deyimimiz var , temel olarak 4 komutunu 3. satırdaki dizi üzerinde eşleştiriyoruz : aralık. İlk üç ifade, 4 , 5 ve 6 satırlı basit haritalardır :

>> L!
>> L+1
>> L∣2

Bu üç tam sayı fazla komutları, n , verimler (n! 1) |x , burada ! belirtmektedir faktöryel , | belirtir divisbility ve x girişidir. Son olarak, hat 12 bir var diyadik haritası yapısını.

Bir ikili harita yapısı üç tamsayı alır: hedef, sol ve sağ, her biri diğer satırlara endekslenir. Burada, bir çift listesi oluşturmak için sola ve sağa sıkıştırıyoruz, ardından her çifti ikili komutla (hedef) azaltıyoruz. Burada, giriş 23 ise, listeler {1, 2, ... 22, 23} ve {0, 0, ... 1, 0} şeklindedir ve komut

>> L⋅R

sol argümanı sağ ile çarpar. Bu , faktöriyelleri artırılan tamsayıların dizinlerinde 0 ve girdiler tarafından bölünemeyen bir tamsayı dizisi ve bulundukları yerde orijinal dizin oluşturur. Bu diziye A diyoruz . Daha sonra, kaldırma 0 dan s A arasındaki grubu farkını alarak {0} ve A :

> {0}
>> 12∖13

Örnek girişimizle bu, {14, 18, 22} kümesini üretir . Sonra, girdinin kalanını setteki her değere böleriz ve kalanın 1'e eşit olup olmadığını kontrol ederiz :

>> 2%L
>> Each 8 14
>> L≠1
>> Each 16 15

Yine, ya bir listesi var 0 veya 1 s ve çıkarmaya gerek 0 s ve değiştirme 1 özgün değerlerle s. Burada yukarıda gördüğümüz kodu tekrarlıyoruz, ama >> 18∖13yerine 12. Son olarak, bu sonuç kümesini son bir kontrol için bir listeye yayınladık. Maalesef kodumuz, 437 gibi tüm bu ölçütleri karşılayan kompozit sayıları da reddetmelidir . Bu yüzden son kontrolümüzü ekleyerek son listemizi girdinin ilkeliğiyle çarpıyoruz. Python çarpımının listelerde nasıl çalıştığı nedeniyle, 0 boş bir listeyle değiştirilir ve 1'in hiçbir etkisi yoktur. Bu nedenle, girdinin ilkeliğini hesaplıyoruz, bunu m listesiyle çarpıyoruzgiriş için s ve nihai sonuç çıkış:

>> 2’
>> 21⋅20
>> Output 22

APL (NARS), 65 karakter, 130 bayt

{∼0π⍵:0⋄m←⎕ct⋄⎕ct←0⋄r←⍬≢a/⍨{0≠⍵∣p}¨a←k/⍨0=⍵∣1+!k←⍳p←¯1+⍵⋄⎕ct←m⋄r}

Burada 23x, 23r1 anlamına gelir ve böylece 23/1 fraksiyonu, böylece diğerleri; Ölçek:

  f←{∼0π⍵:0⋄m←⎕ct⋄⎕ct←0⋄r←⍬≢a/⍨{0≠⍵∣p}¨a←k/⍨0=⍵∣1+!k←⍳p←¯1+⍵⋄⎕ct←m⋄r}
  f¨23x 59x 83x 109x 139x 593x
1 1 1 1 1 1 
  f¨5x 7x 73x 89x 263x 437x
0 0 0 0 0 0 

C # (Görsel C # Etkileşimli Derleyici) , 138 + 22 = 160 bayt

n=>Enumerable.Range(2,n-2).All(x=>n%x>0)&Enumerable.Range(1,n).Any(x=>{BigInteger a,b=1;for(a=1;a<=x;a++)b*=a;return(b+1)%n<1&(n-1)%x>0;})

TIO, Mono sürümünde System.Numerics kütüphanesini uygulamadı, böylece sonuçları görebilirsiniz. Çevrimiçi deneyin! İşte bunun yerine.

Açıklama:

using System.Numerics; //necessary to handle large numbers created by the factorials

return 
    Enumerable.Range(2,n-2).All(x=>n%x>0)       // is prime
    &
    Enumerable.Range(1,n).Any(x=>
    {
        BigInteger a,b=1;for(a=1;a<=x;a++)b*=a; //b = a!
        return (b+1)%n<1
               &                                //the condition for PPs
               (n-1)%x>0;             
    });

CJam , 37 bayt

ri_mp\[_{_M)m!)@%!\_M)%1=!@&\}fM]);:|

Çıkışlar 11girdi bir Pillai asal sayı ise, aksi halde 00, 01ya10

Açıklama:

                                         e# Explanation | Stack
ri_mp\[_{_M)m!)@%!\_M)%1=!@&\}fM]);:|    e# Whole code | Example input: 593
ri                                       e# Read input as integer | 593
  _                                      e# Duplicate | 593 593
   mp                                    e# Is it prime? | 593 1
     \                                   e# Swap top two stack elements | 1 593
      [                         ]        e# Delimits an array. Any operations that
                                         e# push a value are placed into the array
       _                                 e# Duplicate | 1 593 [593]
        {                    }fM         e# A for loop from 0 to (n-1) looped through
                                         e# variable M
         _                               e# Duplicate top stack value | ...[593 593]
          M)                             e# Get M+1, as if we try M=0 we get an error
                                         e# | ...[593 593 1]
            m!                           e# Factorial | ...[593 593 1]
              )                          e# Add one | ...[593 593 2]
               @                         e# Rotate stack | ...[593 2 593]
                %                        e# Modulus | ...[593 2]
                 !                       e# Equal to 0? | ...[593 0]
                  \_                     e# Swap and duplicate | ...[0 593 593]
                    M)                   e# Push M+1 | ...[0 593 593 1]
                      %                  e# Modulus | ...[0 593 0]
                       1=!               e# Not equal to 1? | ...[0 593 1]
                          @              e# Rotate | ...[593 1 0]
                           &             e# AND | ...[593 0]
                            \            e# Swap | ...[0 593]
                             }     
                                ]
                                 );      e# Dump and discard last element
                                         e# | 1 593 [...]
                                   :|    e# Flatten array with OR | 1 1
                                         e# Implicit output

Çevrimiçi deneyin!