Учитывая положительное целое число n , вычислите n- ^е число Вильсона W (n), где

и e = 1, если n имеет первообразный корень по модулю n , в противном случае e = -1. Другими словами, n имеет примитивный корень, если не существует целого числа x, где 1 < x < n-1 и x ² = 1 mod n .

• Это код-гольф, поэтому создайте кратчайший код для функции или программы, которая вычисляет n- ^е число Уилсона для входного целого числа n > 0.
• Вы можете использовать индексирование на основе 1 или 0. Вы также можете выбрать вывод первых n чисел Уилсона.
• Это последовательность OEIS A157249 .

Тестовые случаи

n  W(n)
1  2
2  1
3  1
4  1
5  5
6  1
7  103
8  13
9  249
10 19
11 329891
12 32
13 36846277
14 1379
15 59793
16 126689
17 1230752346353
18 4727
19 336967037143579
20 436486
21 2252263619
22 56815333
23 48869596859895986087
24 1549256
25 1654529071288638505

Желе , 8 7 байт

1 байт благодаря Денису.

gRỊTP‘:

Попробуйте онлайн!

Вы действительно не должны вычислять, eтак как вам все равно нужно делить.

шелуха , 11 байт

S÷ȯ→Π§foε⌋ḣ

Попробуйте онлайн!

объяснение

          ḣ   Range from 1 to input
     §foε⌋    Keep only those whose gcd with the input is 1
    Π         Product
  ȯ→          Plus 1
S÷            Integer division with input

Mathematica, 91 байт

If[(k=#)==1,2,(Times@@Select[Range@k,CoprimeQ[k,#]&]+If[IntegerQ@PrimitiveRoot@#,1,-1])/#]&

Pyth , 11 байт

/h*Ff>2iTQS

Попробуй это здесь!

Как?

• /h*Ff>2iTQS - Полная программа.

• S- Генерация включающего диапазона [1, вход]

• f - Фильтр-оставь те:

  • iTQ чей ГКД со входом.

  • >2- меньше , чем два (можно заменить любым из следующих условий : q1, !t)

• *F- Применить умножение повторно. Другими словами, продукт из списка.

• h - Увеличить продукт на 1.

• / - Этаж деления с входом.

TL; DR : получить все взаимно простые числа на входе в диапазоне [1, вход] , получить их произведение, увеличить его и разделить на вход.

Python 2 , 62 байта

n=input();k=r=1
exec'r*=k/n*k%n!=1or k/n;k+=1;'*n*n
print-~r/n

Попробуйте онлайн!

J, 33 байта

3 :'<.%&y>:*/(#~1&=@(+.&y))1+i.y'

Это скорее просьба увидеть улучшение, чем что-либо еще. Сначала я попробовал молчаливое решение, но оно оказалось длиннее.

объяснение

Это довольно простой перевод решения мистера Xcoder на J.

Попробуйте онлайн!

05AB1E , 8 байтов

Lʒ¿}P>I÷

Попробуйте онлайн!

R , 82 байта

function(n)(prod((1:n)[g(n,1:n)<2])+1)%/%n
g=function(a,b)ifelse(o<-a%%b,g(b,o),b)

Использует целочисленное деление, а не выяснение, eкак многие ответы здесь, хотя я действительно работал, e=2*any((1:n)^2%%n==1%%n)-1включая крайний случай, n=1который я считал довольно аккуратным.

Использует векторизованную функцию GCD rturnbull .

Попробуйте онлайн!

Пари / ГП , 36 байт

n->(prod(i=1,n,i^(gcd(i,n)==1))+1)\n

Попробуйте онлайн!

JavaScript (ES6), 72 70 68 байт

f=(n,p=1,i=n,a=n,b=i)=>i?f(n,b|a-1?p:p*i,i-=!b,b||n,b?a%b:i):-~p/n|0

<input type=number min=1 oninput=o.textContent=f(+this.value)><pre id=o>

Целочисленное деление поражает снова. Изменить: Сохранено 2 байта благодаря @Shaggy. Сохраните еще 2 байта, сделав его гораздо более рекурсивным, поэтому он может потерпеть неудачу при меньших значениях, чем раньше.

Haskell , 42 байта

f n=div(product[x|x<-[1..n],gcd x n<2]+1)n

Попробуйте онлайн!

Использует трюк с целочисленным делением, как и все остальные ответы.
Использует индексы на основе 1.

объяснение

f n=                                       -- function
    div                                  n -- integer division of next arg by n
       (product                            -- multiply all entries in the following list
               [x|                         -- return all x with ...
                  x<-[1..n],               -- ... 1 <= x <= n and ...
                            gcd x n<2]     -- ... gcd(x,n)==1
                                      +1)  -- fix e=1

Japt , 11 байт

õ fjU ×Ä zU

Попытайся

объяснение

Неявный ввод целого числа U.

õ

Создайте массив целых чисел от 1 до U.

fjU

Filter ( f) сопряжения U.

×

Уменьшить умножением.

Ä

Добавьте 1.

zU

Разделите на U, дайте результат и неявно выводите.

Аксиома, 121 байт

f(n)==(e:=p:=1;for i in 1..n repeat(if gcd(i,n)=1 then p:=p*i;e=1 and i>1 and i<n-1 and(i*i)rem n=1=>(e:=-1));(p+e)quo n)

добавить какой-то тип, раскрутить это и результат

w(n:PI):PI==
   e:INT:=p:=1
   for i in 1..n repeat
       if gcd(i,n)=1 then p:=p*i
       e=1 and i>1 and i<n-1 and (i*i)rem n=1=>(e:=-1)
   (p+e)quo n

(5) -> [[i,f(i)] for i in 1..25]
   (5)
   [[1,2], [2,1], [3,1], [4,1], [5,5], [6,1], [7,103], [8,13], [9,249],
    [10,19], [11,329891], [12,32], [13,36846277], [14,1379], [15,59793],
    [16,126689], [17,1230752346353], [18,4727], [19,336967037143579],
    [20,436486], [21,2252263619], [22,56815333], [23,48869596859895986087],
    [24,1549256], [25,1654529071288638505]]
                                                  Type: List List Integer

(8) -> f 101
   (8)
  9240219350885559671455370183788782226803561214295210046395342959922534652795_
   041149400144948134308741213237417903685520618929228803649900990099009900990_
   09901
                                                    Type: PositiveInteger

JavaScript (ES6), 83 81 80 78 76 68 байт

Мой первый проход был на несколько байт длиннее решения Нейла, поэтому я изначально отказался от него в пользу решения по уменьшению массива ниже. С тех пор я играл в гольф, чтобы связать с Нилом.

n=>(g=s=>--x?g(s*(h=(y,z)=>z?h(z,y%z):--y?1:x)(n,x)):++s)(1,x=n)/n|0

Попытайся

o.innerText=(f=
n=>(g=s=>--x?g(s*(h=(y,z)=>z?h(z,y%z):--y?1:x)(n,x)):++s)(1,x=n)/n|0
)(i.value=8);oninput=_=>o.innerText=f(+i.value)

<input id=i type=number><pre id=o>

Нерекурсивный, 76 байт

Я хотел дать нерекурсивному решению попробовать, как оно получится - не так плохо, как я ожидал.

n=>-~[...Array(x=n)].reduce(s=>s*(g=(y,z)=>z?g(z,y%z):y<2?x:1)(--x,n),1)/n|0

Попытайся

o.innerText=(f=
n=>-~[...Array(x=n)].reduce(s=>s*(g=(y,z)=>z?g(z,y%z):y<2?x:1)(--x,n),1)/n|0
)(i.value=8);oninput=_=>o.innerText=f(+i.value)

<input id=i type=number><pre id=o>