Một số nguyên tố Pillai là số nguyên tố tồn tại một số dương sao cho và .$p$$m$$(m! + 1) \equiv 0 \:(\text{mod } p)$$p \not\equiv 1\:(\text{mod }m)$

Nói cách khác, số nguyên $p$ là số nguyên tố Pillai nếu là số nguyên tố , nếu tồn tại một số nguyên dương $m$ khác sao cho giai thừa của $m$ , cộng $1$ chia hết cho $p$ và nếu $p - 1$ không chia hết cho $m$ .

Cho một số nguyên dương làm đầu vào, quyết định xem đó có phải là số nguyên tố Pillai không. Chuỗi các số nguyên tố Pillai là OEIS A063980 .

Ví dụ: $23$ là số nguyên tố Pillai vì:

• Đó là một số nguyên tố, chỉ có 2 yếu tố.
• $m = 14$ và $m = 18$ thỏa mãn các điều kiện trên: $23 \mid (14! + 1)$ và $14$ không chia $22$ ; $23 \mid (18! + 1)$ và $18$ cũng không chia $22$ .

Các trường hợp thử nghiệm

Sự thật:

23
59
83
109
139
593

Giả mạo:

5
7
số 8
73
89
263
437

Đối với các trường hợp trung thực, các m tương ứng là [(23, [14, 18]), (59, [15, 40, 43]), (83, [13, 36, 69]), (109, [86]), (139, [16]), (593, [274])].

Bạn có thể theo định dạng đầu ra của vấn đề quyết định tiêu chuẩn (nghĩa là giá trị trung thực / giả) hoặc có giá trị nhất quán cho các số nguyên tố Pillai và giá trị không nhất quán theo cách khác hoặc ngược lại .

Bạn có thể cạnh tranh trong bất kỳ ngôn ngữ lập trình nào và có thể nhận đầu vào và cung cấp đầu ra thông qua bất kỳ phương thức tiêu chuẩn nào , trong khi lưu ý rằng các lỗ hổng này bị cấm theo mặc định. Đây là môn đánh gôn , vì vậy bài nộp ngắn nhất (tính bằng byte) cho mọi ngôn ngữ sẽ thắng.

Python 2 , 115 111 110 109 byte

^{-6 byte nhờ ông Xcoder}

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)

Hãy thử trực tuyến!

Các chức năng bao gồm hai phần ~-n%x<1or~f(x)%n>0xác minh nếu n không thỏa mãn "điều kiện Pillai" và n%x>0để xác thực chính.
Sau đó allđược áp dụng cho cả hai mục, mục đầu tiên sẽ chứa False/ 0nếu có là một "Pillai số" hợp lệ, và lần thứ hai sẽ chứa True/ 1nếu nlà số nguyên tố.
Chúng được chuyển đến cmpđó sẽ trở lại -1trong cenario này (là một số nguyên tố Pillai hợp lệ). Các kết hợp khác [[0, 0], [1, 0], [1, 1]]sẽ trở lại 0hoặc1

Thạch , 11 8 byte

Ṗ!%ẹ’ḍ’E

Trả về 0 cho số nguyên tố Pillai, 1 nếu không.

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Ṗ!%ẹ’ḍ’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 byte

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

Hãy thử trực tuyến!

Brachylog , 19 byte

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

Hãy thử trực tuyến!

Bản dịch khá đơn giản của câu hỏi:

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

-4 byte nhờ FrownyFrog

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

Hãy thử trực tuyến!

Giải trình:

                        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 byte

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

Đầu ra là thông qua sự hiện diện hoặc vắng mặt của một lỗi.

Hãy thử trực tuyến!

Python 2 , 109 107 byte

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)

Hãy thử trực tuyến!

Giải trình

Việc ltìm thấy giai thừa của số được truyền vào, để 5trả về đầu vào 120.

Các all(p%i for i in range(2,p-1))kiểm tra xem nếu một số là số nguyên tố, chúng tôi bỏ qua 0 và 1 như các điều kiện khác của chúng tôi đã loại trừ những người ra.

Cuối cùng, chúng tôi sử dụng any(~-p%m>-~l(m)%p==0for m in range(2,p))để lặp đi lặp lại qua tất cả các m tiềm năng để xem liệu có thỏa mãn nhu cầu của chúng tôi không. ~-pcó nghĩa là p+1. Sau đó, chúng tôi kiểm tra xem nó có lớn hơn không -~l(m)%p(có nghĩa là (m!-1)%p, và sau đó chúng tôi so sánh nó với 0. Về cơ bản ~-p%mphải lớn hơn 0 và -~l(m)%pphải bằng 0.

Nguồn

• Nhân tố của 0xKirill

Cải tiến

• Từ 109 đến 107, ông Xcoder

như bạn có thể thấy trong liên kết tio không phải tất cả các trường hợp đều vượt qua, đó là vì js không thể xử lý số lượng lớn, nếu yêu cầu đó tồn tại, hãy thử thực hiện nó :)

có một kiểm tra kép F%n>n-2&(F+1)%n<1để ngăn chặn dương tính giả (nhưng không phải là cách khác với các vấn đề về số lượng lớn của js, chúng tôi thực sự cần (F+1)%n<1số lượng nhỏ hơn làm giảm số lượng byte giải pháp xuống còn 60

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

• cảm ơn Arnauld vì đã giảm 1 byte

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

Hãy thử trực tuyến!

Brachylog , 13 byte

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

Hãy thử trực tuyến!

Thành công cho các số nguyên tố Pillai, cung cấp m nhỏ nhất thông qua biến đầu ra và không thành công cho bất kỳ thứ gì khác. Vì một phần lớn của cách này giúp tiết kiệm byte trên giải pháp của chủ nhật là nó liên tục tính toán các thừa số nguyên tố của một số số khá lớn, nên nó khá chậm đối với các đầu vào lớn hơn. (Có lẽ tôi sẽ chạy các trường hợp đó khi cài đặt Brachylog cục bộ của mình một khi máy tính xách tay của tôi không sử dụng pin.)

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

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

Mô-đun lý thuyết số có các vị từ là các hàm dựng sẵn (is_pillai thực sự trả về 0 hoặc nhỏ nhất m, do đó cũng giải quyết A063828). Mã C và Perl cơ bản không được đánh gôn (tất nhiên). Mã C trông giống như:

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

(nói chung thay thế UV bằng uint64_t hoặc tương tự, và HALF_WORD quyết định liệu chúng ta có thể tối ưu hóa mulmod thành các op gốc đơn giản hay không).

Mã Perl thuần túy tương tự như:

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 byte

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

Hãy thử trực tuyến!

Thì thầm v2 , 230 byte

> 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

Hãy thử trực tuyến!

Điều này trả về một danh sách trống cho các số nguyên tố không phải là Pillai và một danh sách không trống khác.

Làm thế nào nó hoạt động

Whispers được thiết kế để thao tác trên các số thực / số phức, với một ít lệnh mảng được thêm vào để đo lường tốt, do đó việc sử dụng Eachlặp đi lặp lại các danh sách được tạo.

Một chút nền tảng về Whispers:

Lời thì thầm hơi khác trong đường dẫn thực thi của nó đối với hầu hết các ngôn ngữ khác. Thay vì làm việc theo từng dòng một cách tuyến tính, chỉ phân nhánh tại các điều kiện, Whispers bắt đầu ở dòng cuối cùng trong tệp bắt đầu bằng >(quy tắc phức tạp hơn một chút so với điều đó, nhưng đó là tất cả những gì chúng ta cần biết bây giờ) và ý nghĩa của các con số khác nhau, tùy thuộc vào việc dòng bắt đầu bằng >hoặc >>.

Nếu dòng bắt đầu bằng >, chẳng hạn như > 1hoặc > Input, đây là một dòng không đổi - nó trả về cùng một giá trị mỗi lần. Ở đây, các số đại diện cho dạng số của chúng, vì vậy dòng đầu tiên sẽ luôn trả về 1 khi được gọi.

>>Tuy nhiên, nếu dòng bắt đầu bằng , các số được coi là tham chiếu đến các dòng khác, giống như các lệnh gọi hàm, nếu bạn muốn. Ví dụ, trong dòng >> 1…2, điều này không thực hiện …lệnh trên các số nguyên 1 và 2 , mà là các giá trị được trả về từ dòng 1 và 2 . Trong trường hợp này, các giá trị đó là số nguyên 1 và bất kỳ số nguyên nào chúng tôi chuyển qua làm đầu vào.

Trong ví dụ này, hãy xem xét đầu vào của 23 . Hãy nhớ rằng, do tiền xử lý của Whispers, dòng thứ hai ( > Input) được chuyển đổi thành > 23.

Lệnh đầu tiên của chúng tôi là trên dòng 3 : >> 1…2. …là phạm vi dyadic, trong trường hợp này từ 1 đến 23 , thu được {1, 2, ... 22, 23} . Tiếp theo, chúng tôi bỏ qua các dòng 9 đến 12 :

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

Ở đây chúng ta có 4 Eachcâu lệnh liên tục, mỗi câu lặp lại kết quả trước đó, về cơ bản ánh xạ 4 lệnh trên mảng trên dòng 3 : phạm vi. Ba câu lệnh đầu tiên là các bản đồ đơn giản, với các dòng 4 , 5 và 6 :

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

Ba lệnh này, trên một số nguyên n , mang lại (n! +1) x , trong đó ! biểu thị thừa , | biểu divisbility và x là đầu vào. Cuối cùng, dòng 12 có cấu trúc bản đồ dyadic .

Một cấu trúc bản đồ dyadic có ba số nguyên: mục tiêu, bên trái và bên phải, mỗi chỉ mục cho các dòng khác. Ở đây, chúng tôi nén bên trái và bên phải để tạo danh sách các cặp, sau đó giảm từng cặp bằng lệnh dyadic (mục tiêu). Ở đây, nếu đầu vào là 23 , thì các danh sách là {1, 2, ... 22, 23} và {0, 0, ... 1, 0} và lệnh là

>> L⋅R

nhân số đối số bên trái của bên phải. Điều này tạo ra một mảng các số nguyên, với 0 tại các chỉ số của các số nguyên có các yếu tố tăng dần không chia hết cho các đầu vào và chỉ mục ban đầu của chúng. Chúng tôi sẽ gọi cho mảng này Một . Tiếp theo, chúng tôi xóa 0 s khỏi A bằng cách lấy chênh lệch đã đặt giữa {0} và A :

> {0}
>> 12∖13

Với đầu vào ví dụ của chúng tôi, điều này tạo ra tập {14, 18, 22} . Tiếp theo, chúng tôi lấy phần còn lại của đầu vào được chia cho mỗi giá trị trong tập hợp và kiểm tra xem phần còn lại có bằng không 1 :

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

Một lần nữa, chúng tôi có một danh sách 0 hoặc 1 giây và cần xóa 0 s và thay thế 1 s bằng các giá trị ban đầu. Ở đây chúng tôi lặp lại mã chúng tôi đã thấy ở trên, nhưng với >> 18∖13hơn là 12. Cuối cùng, chúng tôi bỏ kết quả này được đặt thành một danh sách để kiểm tra lần cuối. Thật không may, mã của chúng tôi cũng phải từ chối các số tổng hợp đạt được tất cả các tiêu chí này, chẳng hạn như 437 . Vì vậy, chúng tôi thêm kiểm tra cuối cùng của chúng tôi, nhân danh sách cuối cùng của chúng tôi với tính nguyên thủy của đầu vào. Do cách nhân của Python hoạt động trên các danh sách, 0 thay thế nó bằng một danh sách trống và 1 không có hiệu lực. Vì vậy, chúng tôi tính toán tính nguyên thủy của đầu vào, nhân số đó với danh sách m giây cho đầu vào và đưa ra kết quả cuối cùng:

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

APL (NARS), 65 ký tự, 130 byte

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

Ở đây 23x có nghĩa là 23r1 và vì vậy phân số 23/1, vì vậy tất cả các phần khác; kiểm tra:

  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 # (Trình biên dịch tương tác Visual C #) , 138 + 22 = 160 byte

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 đã không triển khai thư viện System.Numerics trong bản phát hành Mono, vì vậy bạn có thể xem kết quả Dùng thử trực tuyến! Ở đây thay thế.

Giải trình:

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 byte

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

Đầu ra 11nếu đầu vào là một nguyên tố trụ, nếu không 00, 01hoặc10

Giải trình:

                                         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

Hãy thử trực tuyến!