Cho số nguyên dương n , tính số Wilson ^thứ n W (n) trong đó

và e = 1 nếu n có gốc modulo n , nếu không thì e = -1. Nói cách khác, n có gốc nguyên thủy nếu không tồn tại số nguyên x trong đó 1 < x < n-1 và x ² = 1 mod n .

• Đây là mã golf, vì vậy hãy tạo mã ngắn nhất cho hàm hoặc chương trình tính số Wilson ^thứ n cho số nguyên đầu vào n > 0.
• Bạn có thể sử dụng lập chỉ mục dựa trên 1 hoặc 0. Bạn cũng có thể chọn xuất số n Wilson đầu tiên .
• Đây là trình tự OEIS A157249 .

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

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

Thạch , 8 7 byte

1 byte nhờ Dennis.

gRỊTP‘:

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

Bạn không thực sự phải tính toán evì dù sao bạn cũng cần phải phân chia.

Husk , 11 byte

S÷ȯ→Π§foε⌋ḣ

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

Giải trình

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

Toán học, 91 byte

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

Bình thường , 11 byte

/h*Ff>2iTQS

Hãy thử nó ở đây!

Làm sao?

• /h*Ff>2iTQS - Chương trình đầy đủ.

• S- Tạo phạm vi bao gồm [1, đầu vào]

• f - Lọc-giữ những cái đó:

  • iTQ - có GCD với đầu vào.

  • >2- Có ít hơn hai (có thể được thay thế bằng một trong các cách sau : q1, !t)

• *F- Áp dụng phép nhân nhiều lần. Nói cách khác, sản phẩm của danh sách.

• h - Tăng sản phẩm thêm 1.

• / - Phân chia tầng với đầu vào.

TL; DR : Nhận tất cả các số nguyên tố cho đầu vào trong phạm vi [1, đầu vào] , nhận sản phẩm của họ, tăng nó và chia cho đầu vào.

Python 2 , 62 byte

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

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

J, 33 byte

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

Đây là một yêu cầu để thấy một sự cải thiện hơn bất cứ điều gì khác. Tôi đã thử một giải pháp ngầm trước tiên, nhưng nó dài hơn thế này.

giải trình

Đây là bản dịch khá đơn giản về giải pháp của ông Xcoder thành J.

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

05AB1E , 8 byte

Lʒ¿}P>I÷

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

R , 82 byte

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

Sử dụng phân chia số nguyên thay vì tìm ra enhư nhiều câu trả lời ở đây, mặc dù tôi đã làm việc e=2*any((1:n)^2%%n==1%%n)-1bao gồm cả trường hợp cạnh n=1mà tôi nghĩ là khá gọn gàng.

Sử dụng chức năng GCD vector hóa của rturnbull .

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

Pari / GP , 36 byte

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

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

JavaScript (ES6), 72 70 68 byte

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>

Bộ phận nguyên lại đình công. Chỉnh sửa: Đã lưu 2 byte nhờ @Shaggy. Đã lưu thêm 2 byte bằng cách làm cho nó đệ quy hơn nhiều, do đó có thể thất bại đối với các giá trị nhỏ hơn so với trước đây.

Haskell , 42 byte

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

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

Sử dụng thủ thuật chia số nguyên như tất cả các câu trả lời khác.
Sử dụng các chỉ số dựa trên 1.

Giải trình

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 byte

õ fjU ×Ä zU

Thử nó

Giải trình

Đầu vào ngầm định của số nguyên U.

õ

Tạo một mảng các số nguyên từ 1 đến U.

fjU

Bộ lọc ( f) đồng nguyên tố của U.

×

Giảm bằng cách nhân.

Ä

Thêm 1.

zU

Chia cho U, kết quả sàn và đầu ra ngầm.

Tiên đề, 121 byte

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)

thêm một số loại, ungolf đó và kết quả

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 byte

Lần đầu tiên tôi vượt qua điều này dài hơn một vài byte so với giải pháp của Neil, đó là lý do tại sao ban đầu tôi đã bỏ qua nó để ủng hộ giải pháp giảm mảng bên dưới. Kể từ khi tôi đánh gôn nó để trói với Neil.

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

Thử nó

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>

Không đệ quy, 76 byte

Tôi muốn đưa ra một giải pháp không đệ quy để thử xem nó sẽ diễn ra như thế nào - không tệ như tôi mong đợi.

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

Thử nó

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>