필라 프라임은 소수의 인 $p$ 긍정적 존재하는 $m$ 되도록 $(m! + 1) \equiv 0 \:(\text{mod } p)$$p \not\equiv 1\:(\text{mod }m)$

즉, 정수 그것이 인 경우 필라의 소수 소수 다른 양의 정수가 존재하는 경우, 되도록 계승 의 플러스 로 나누어 및 경우 로 나누어 아니다 .m m 1 p p - $p$$m$$m$$1$$p$$p - 1$$m$

입력으로 양의 정수가 주어지면 Pillai 소수인지 결정하십시오. Pillai 소수의 순서는 OEIS A063980 입니다.

예를 들어 은 다음과 같은 이유로 Pillai 소수입니다.$23$

• 2 개의 요소 만있는 소수입니다.
• 및 m = 18 상기 조건을 만족하는 23 | ( 14 ! + 1 ) 및 14 분할되지 않는 (22) ; 23 ∣ ( 18 ! + 1 ) 및 18 은 22 를나누지 않습니다.$m = 14$$m = 18$$23 \mid (14! + 1)$$14$$22$$23 \mid (18! + 1)$$18$$22$

테스트 사례

진실한 :

23
59
83
109
139
593

거짓 :

5
7
8
73
89
263
437

진실한 경우에, 각각의 m 은 [(23, [14, 18]), (59, [15, 40, 43]), (83, [13, 36, 69]), (109, [86]), (139, [16]), (593, [274])]입니다.

표준 의사 결정 문제 출력 형식 (즉, 진실 / 거짓 값)을 따르거나 Pillai 소수에 대해 일관된 값을, 그렇지 않으면 일관되지 않은 값을 가질 수 있습니다 .

모든 프로그래밍 언어로 경쟁 할 수 있으며 표준 방법을 통해 입력을 받고 출력을 제공 할 수 있지만 이러한 허점 은 기본적으로 금지되어 있습니다. 이것은 code-golf 이므로 모든 언어에 대한 가장 짧은 제출 (바이트)이 이깁니다.

파이썬 (2) , 115 (111) 110 109 바이트

^{Mr. Xcoder 덕분에 -6 바이트}

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)

온라인으로 사용해보십시오!

기능은 "Pillai 조건"을 만족 하지 않는지~-n%x<1or~f(x)%n>0 확인 하고 주요 유효성 검사를 n 수행 하는 두 부분으로 구성됩니다 n%x>0.
그이 후 all두 항목에 적용, 첫 번째 항목이 포함됩니다 False/ 0이 경우 이다 유효한 "필라 번호", 두 번째는 포함 True/ 1경우 n소수.
이것들은 이 시나리오에서 cmp돌아올 것입니다 -1(유효한 Pillai 소수입니다). 다른 조합이 [[0, 0], [1, 0], [1, 1]]반환됩니다 0또는1

젤리 , 11 8 바이트

Ṗ!%ẹ’ḍ’E

반환 0 필라 프라임에 대한 1 , 그렇지 않으면에게.

온라인으로 사용해보십시오!

작동 원리

Ṗ!%ẹ’ḍ’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 바이트

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

온라인으로 사용해보십시오!

Brachylog , 19 바이트

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

온라인으로 사용해보십시오!

질문에 대한 매우 간단한 번역 :

ṗ          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 바이트

FrownyFrog 덕분에 -4 바이트

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

온라인으로 사용해보십시오!

설명:

                        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

파이썬 2 , 65 64 53 52 바이트

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

출력은 오류 유무를 통해 이루어집니다.

온라인으로 사용해보십시오!

파이썬 2 , 109107 바이트

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)

온라인으로 사용해보십시오!

설명

는 l그렇게 전달 된 숫자의 계승을 발견 5입력 반환으로 120.

all(p%i for i in range(2,p-1))검사 숫자가 소수 인 경우 우리의 다른 조건이 이미 그 아웃 규칙으로, 우리는 0과 1을 무시 볼 수 있습니다.

마지막으로, 우리 any(~-p%m>-~l(m)%p==0for m in range(2,p))는 우리의 요구를 충족시키는 지 확인하기 위해 모든 잠재적 m을 반복합니다. ~-p의미 p+1합니다. 그런 다음 그것이보다 큰지 확인합니다 -~l(m)%p(로 변환 (m!-1)%p한 다음에 비교합니다 0. 기본적으로 ~-p%m0보다 크고 0 -~l(m)%p이어야합니다.

출처

• 계승 하여 0xKirill

개량

• Xcoder 씨 109에서 107

티오 링크에서 볼 수 있듯이 모든 경우가 통과되는 것은 아닙니다 .JS가 큰 숫자를 처리 할 수 ​​없기 때문에 그러한 요구 사항이 존재하지 않으면 구현하려고 시도하십시오. :)

F%n>n-2&(F+1)%n<1위양성을 방지하기 위해 이중 검사 가 있습니다 (하지만 js 큰 숫자 문제와 다른 방법은 아닙니다 (F+1)%n<1. 솔루션 바이트 수를 60으로 줄이면서 실제로 작은 숫자 가 필요 합니다)

자바 스크립트 (Node.js) , 90 88 86 72 68 bytes

• Arnauld 덕분에 1 바이트 감소

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

온라인으로 사용해보십시오!

Brachylog , 13 바이트

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

온라인으로 사용해보십시오!

Pillai 소수에 성공 하고 출력 변수를 통해 가장 작은 m 을 제공하고 다른 것에는 실패합니다. 이것이 sundar의 솔루션보다 바이트를 절약하는 방법의 많은 부분이 꽤 큰 숫자의 소인수 분해를 반복적으로 계산한다는 것이므로 더 큰 입력에서는 상당히 느립니다. (노트북이 배터리 전원을 사용하지 않으면 로컬 Brachylog 설치에서 이러한 사례를 실행할 것입니다.)

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

[펄], 45 바이트

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

숫자 이론 모듈에는 내장 함수로서 술어가 있습니다 (is_pillai는 실제로 0 또는 가장 작은 m을 리턴하므로 A063828도 해결합니다). 기본 C 및 Perl 코드는 물론 골프는 아닙니다. C 코드는 다음과 같습니다.

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

(일반적으로 UV를 uint64_t 또는 이와 유사한 것으로 대체하고 HALF_WORD는 mulmod를 간단한 기본 op로 최적화 할 수 있는지 여부를 결정합니다).

순수한 Perl 코드는 다음과 유사합니다.

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 바이트

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

온라인으로 사용해보십시오!

s 속말 v2 , 230 바이트

> 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

온라인으로 사용해보십시오!

이것은 필라델피아가 아닌 프라임에 대해서는 빈 목록을, 그렇지 않으면 비어 있지 않은 목록을 반환합니다.

작동 원리

Whispers는 실수 / 복소수를 조작하기 위해 설계되었으며, 소량의 배열 명령이 추가되어 좋은 측정이 추가되었으므로 Each생성 된 목록을 반복 사용하는 반복 사용 .

속삭임에 대한 약간의 배경 :

속삭임은 대부분의 다른 언어로의 실행 경로에서 약간 다릅니다. 조건부에서 분기하는 것만으로 각 줄을 선형으로 작업하는 대신 Whispers는 파일의 마지막 줄부터 시작합니다 >(규칙은 약간 복잡하지만 지금은 알아야 할 모든 것). 숫자의 의미 줄이 >또는로 시작하는지에 따라 다릅니다 >>.

라인이로 시작하는 경우 >와 같은, > 1또는 > Input, 이것은이다 상수의 라인 - 그것은 같은 값마다 반환합니다. 여기서 숫자는 숫자 형식을 나타내므로 첫 번째 줄은 호출 될 때 항상 1을 반환 합니다.

>>그러나 줄이 시작 되면 숫자는 다른 줄에 대한 참조로 간주됩니다. 예를 들어, 라인 >> 1…2, 이것은 수행하지 않는 …정수에 명령을 1 및 2 뿐만 아니라 라인들로부터 리턴 된 값에 1 및 2 . 이 경우 해당 값은 정수 1 이며 입력으로 전달 된 정수입니다.

이 예제에서는 23 의 입력을 고려하십시오 . Whispers의 전처리로 인해 두 번째 줄 ( > Input) 이로 변환됩니다 > 23.

첫 번째 명령은 3 행 >> 1…2입니다. …는 이항 범위이며,이 경우 1 에서 23까지 이며 {1, 2, ... 22, 23} 입니다. 다음으로 9 ~ 12 행으로 건너 뜁니다 .

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

여기에 우리는 4 개의 헌신적 인 Each진술이 있으며, 각각은 이전 결과에 대해 반복되며, 본질적으로 3 행의 배열에 걸쳐 4 개의 명령을 매핑합니다 : 범위. 처음 세 문장은 4 , 5 및 6 행의 간단한 맵입니다 .

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

정수 n 에 대한이 세 명령 은 (n! +1) ∣x를 산출합니다 . 여기서 ! 나타내고 팩토리얼 , | 나타내고 divisbility을 그리고 X 입력된다. 마지막으로 12 행 에는 2 차원지도 구조가 있습니다.

2 차원지도 구조는 3 개의 정수 즉, 대상, 왼쪽 및 오른쪽이 각각 다른 행에 대한 색인을 갖습니다. 여기에서 왼쪽과 오른쪽을 압축하여 쌍 목록을 생성 한 다음 dyadic 명령 (대상)으로 각 쌍을 줄입니다. 여기서 입력이 23 인 경우 목록은 {1, 2, ... 22, 23} 및 {0, 0, ... 1, 0} 이며 명령은 다음과 같습니다.

>> L⋅R

왼쪽 인수에 오른쪽을 곱합니다. 이것은 계승 증분이 입력으로 나눌 수없는 정수 색인 과 0 이있는 정수 색인에 정수 배열을 생성합니다 . 이 배열을 A 라고합니다 . 다음으로, 우리는 제거 0 에서 S 을 사이 차 집합 취하여 {0} 및 :

> {0}
>> 12∖13

예제 입력으로 {14, 18, 22} 세트가 생성 됩니다. 다음으로 입력의 나머지를 세트의 각 값으로 나눈 다음 나머지가 1 이 아닌지 확인합니다 .

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

다시 말하지만, 우리는 하나의 목록이 0 또는 1 의와 제거해야하는 0 들과 교체 한 원래의 값으로들. 여기에서 우리는 우리가 위에서 본 코드를 반복하되으로 >> 18∖13보다는 12. 마지막으로이 결과 집합을 최종 확인을위한 목록으로 캐스트합니다. 불행히도, 우리의 코드는 437 과 같은 모든 기준을 달성하는 복합 숫자도 거부해야합니다 . 최종 목록에 입력의 우선 순위를 곱하여 최종 검사를 추가합니다. Python 곱셈이 목록에서 작동하는 방식으로 인해 0 은 빈 목록으로 대체하고 1 은 영향을 미치지 않습니다. 따라서 입력의 우선도를 계산하고 m 의 목록을 곱합니다.입력과 최종 결과 출력 :

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

APL (NARS), 65 자, 130 바이트

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

여기서 23x는 23r1을 의미하고 따라서 분수 23/1을 의미합니다. 테스트:

  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 # (Visual C # 대화식 컴파일러) , 138 + 22 = 160 바이트

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 릴리스에서 System.Numerics 라이브러리를 구현하지 않았으므로 결과를 온라인에서 볼 수 있습니다! 대신에 여기 .

설명:

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 바이트

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

출력 11입력이 필라 소수 인 경우, 그렇지 않은 경우 00, 01또는10

설명:

                                         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

온라인으로 사용해보십시오!