Піллаі просте просте число $p$ , для яких існує деякий позитивний $m$ таке , що $(m! + 1) \equiv 0 \:(\text{mod } p)$$p \not\equiv 1\:(\text{mod }m)$

Іншими словами, ціле число є простим Піллаі , якщо це просте число , якщо існує ще одне натуральне число таке , що факторіала з , плюс ділиться на і якщо не ділиться на .$p$$m$$m$$1$$p$$p - 1$$m$

З огляду на додатне ціле число, вирішіть, чи є це простим числом Піллая. Послідовність праймів Pillai - OEIS A063980 .

Наприклад, - це прем'єр-міністр Піллая, оскільки:$23$

• Це просте число, що має лише 2 фактори.
• $m = 14$ і задовольняють наведеним вище умовам: і не ділить ; і не ділиться23 ∣ ( 14 ! + 1 ) 14 22 23 ∣ ( 18 ! + 1 ) 18 $m = 18$$23 \mid (14! + 1)$$14$$22$$23 \mid (18! + 1)$$18$$22$ .

Тестові справи

Truthy:

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

Ви можете дотримуватися стандартного формату виходу проблеми (тобто значення truthy / falesy) або мати послідовне значення для праймерів Pillai і невідповідне значення в іншому випадку або навпаки .

Ви можете змагатися з будь-якою мовою програмування і можете приймати введення та надавати висновок будь-яким стандартним методом , беручи до уваги, що ці лазівки заборонені за замовчуванням. Це код-гольф , тому найкоротше подання (у байтах) на кожну мову виграє.

Python 2 , 115 111 110 109 байт

^{-6 байт завдяки спадару 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)

Спробуйте в Інтернеті!

Функції складаються з двох частин, ~-n%x<1or~f(x)%n>0які перевіряють, чи n не вони відповідають "умовам Піллая", та n%x>0для валідації простих.
Після цього allбуде застосовано до обох елементів, перший елемент буде містити False/ 0якщо є дійсний номер "Pillai", а другий буде містити True/ 1якщо nє простим.
Вони передаються до cmpтого, що повернеться -1в цьому ченаріо (є дійсним прем'єром Піллая). Інші комбінації [[0, 0], [1, 0], [1, 1]]повернуться 0або1

Желе , 11 8 байт

Ṗ!%ẹ’ḍ’E

Повертає 0 для Pillai prime, 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.

Парі / GP , 44 байти

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

Спробуйте в Інтернеті!

Брахілог , 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 байт

-4 байти завдяки FrownyFrog

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

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

Вихід здійснюється через наявність або відсутність помилки.

Спробуйте в Інтернеті!

Python 2 , 109 107 байт

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))для перегляду всіх потенційних можливостей м, щоб побачити, чи задовольняє хтось наші потреби. ~-pзасоби p+1. Потім ми перевіряємо, чи є вона більша -~l(m)%p(що перекладається на (m!-1)%p, а потім ми порівнюємо її 0. В основному вона ~-p%mповинна бути більшою за 0 і -~l(m)%pповинна бути 0.

Джерела

• Факторіал від 0xKirill

Поліпшення

• З 109 по 107, містер Xcoder

як ви, напевно, бачите, що у посиланні tio не всі випадки проходять, ось тому, що js не може обробляти великі цифри, якщо така вимога існує погано, спробуйте її реалізувати :)

є подвійна перевірка, F%n>n-2&(F+1)%n<1щоб запобігти хибному позитиву (але не навпаки, коли проблеми з великою кількістю js нам дійсно потрібні (F+1)%n<1для менших чисел, що зменшує кількість байтів рішення до 60

JavaScript (Node.js) , 90 88 86 72 68 байт

• завдяки Арноульду за зменшення на 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

Спробуйте в Інтернеті!

Брахілог , 13 байт

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

Спробуйте в Інтернеті!

Успіх для Pillai праймес, забезпечуючи найменший m через вихідну змінну, і не вдається для нічого іншого. Оскільки велика частина того, як це економить байти над рішенням сундара, полягає в тому, що він неодноразово обчислює основні факторизації деяких досить великих чисел, на великих входах це дуже неймовірно повільно. (Я, мабуть, запускаю ці випадки на локальній установці 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.

[Perl], 45 байт

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

Модуль теорії чисел має предикати як вбудовані функції (is_pillai фактично повертає або 0, або найменший m, тому вирішує також A063828). Основний код C і Perl, звичайно, не гольф. Код С виглядає так:

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

(загалом замініть УФ на uint64_t або подібне, і HALF_WORD вирішує, чи можемо ми оптимізувати мульмод у прості рідні програми).

Чистий код 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;}

Спробуйте в Інтернеті!

Шепіт 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

Спробуйте в Інтернеті!

Це повертає порожній список для не-Pillai праймес, а не порожній список в іншому випадку.

Як це працює

Шепіт був розроблений для маніпулювання на реальних / складних числах, з хорошою мірою додано трохи команд масиву, отже, неодноразове використання Eachдля повторення генерованих списків.

Трохи фону про Шепіт:

Шепіт дещо відрізняється у своєму виконанні до більшості інших мов. Замість того, щоб працювати через кожен рядок лінійно, лише розгалужуючись на умовних умовах, Шепіт починається з останнього рядка у файлі, починаючи з >(правила дещо складніше, ніж це, але це все, що нам потрібно знати зараз), і значення чисел відрізняються залежно від того, починається лінія з >або >>.

Якщо рядок починається з >, наприклад, > 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твердження, кожне з яких повторює попередній результат, по суті відображаючи 4 команди над масивом у рядку 3 : діапазон. Перші три твердження - це прості карти із рядками 4 , 5 та 6 :

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

Ці три команди, над цілим n , дають (n! +1) ∣x , де ! позначає факторіала , | позначає divisbility і х є входом. Нарешті, рядок 12 має діадичну структуру карти .

Структура діадичної карти містить три цілі числа: цільове, ліве та праве, кожне вказує на інші рядки. Тут ми блискавки праворуч і праворуч створюємо список пар, а потім зменшуємо кожну пару командою діадік (ціль). Тут, якщо вхід 23 , списки {1, 2, ... 22, 23} і {0, 0, ... 1, 0} і команда:

>> L⋅R

який помножує лівий аргумент на правий. Це створює масив цілих чисел з 0 в індексах цілих чисел, чиї фактичні показники, збільшені не поділяються на вхідні дані, та вихідний індекс, де вони є. Ми будемо називати цей масив A . Далі, ми видаляємо 0 s з A , приймаючи встановлену різницю між {0} і A :

> {0}
>> 12∖13

З нашого прикладу введення, це створює множину {14, 18, 22} . Далі беремо залишок вхідного сигналу, поділеного на кожне значення в наборі, і перевіряємо, чи не залишилося це значення 1 :

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

Знову ми маємо список або 0, або 1 с, і потрібно видалити 0 с і замінити 1 с вихідними значеннями. Тут ми повторюємо код, який ми бачили вище, але з >> 18∖13замість цього 12. Нарешті, ми видаємо цей отриманий набір до списку для остаточної перевірки. На жаль, наш код також повинен відхиляти складені числа, які досягають усіх цих критеріїв, наприклад 437 . Тож ми додаємо остаточну перевірку, помноживши наш остаточний список на первинність введення. Завдяки тому, як множення Python працює у списках, 0 замінює його порожнім списком, а 1 не впливає. Отже, обчислюємо первинність вхідного даних, помножимо його на список ms для введення та вихідного кінцевого результату:

>> 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 # Interactive Compiler) , 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 не реалізував бібліотеку System.Numerics у своєму випуску Mono, тому ви можете побачити результати Спробуйте в Інтернеті! Тут замість цього.

Пояснення:

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

Спробуйте в Інтернеті!