给定正整数n，计算第n ^个 威尔逊数 W（n），其中

威尔逊数公式

和ë = 1，如果Ñ具有原根Ñ，否则ê = -1。换句话说，如果不存在1 < x < n-1和x ² = 1 mod n的整数x，则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

— 英里
source

此外，Oeis之后还会除以n

— H.PWiz

@EriktheOutgolfer我添加了具有原始根的含义。

— 英里

1

我们应该除以n吗？

— Leaky Nun

据我所知，如果k = 1和e = -1，产品的结果将是0。（很抱歉，我问了很多问题，但我需要对我的回答进行说明：p）

— Egg the Outgolfer

2

这些数字称为Wilson商。甲威尔逊数是整除其威尔逊商的整数。例如，13是威尔逊数，因为13 | 36846277。同样，W（n）通常不包括分母。

— 丹尼斯

8

果冻，8 7字节

1字节感谢丹尼斯。

gRỊTP‘:

在线尝试！

您实际上不必进行计算，e因为无论如何您都需要进行除法。

— 漏尼姑
source

gRỊT保存一个字节。

— 丹尼斯

丹尼斯（Dennis）深入gRỊT了解果冻（Jelly）的细节……

— corsiKa

6

外壳，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

— 普维兹
source

请添加说明？我认为您那里有一个很漂亮的算法……

— Outgolfer的Erik

3

Mathematica，91个字节

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

— J42161217
source

@BillSteihn请不要直接编辑其他人的答案（相关的元讨论）。如果您有高尔夫建议，请发表评论！

— JungHwan Min'9

@JungHwanMin是的，我注意到该编辑！感谢您为新用户提供规则方面的帮助

— J42161217 '17

3

Pyth，11个字节

/h*Ff>2iTQS

在这里尝试！

怎么样？

/h*Ff>2iTQS -完整程序。
S-生成包含范围[1，输入]
f -过滤保留以下内容：
- iTQ -其GCD与输入。
- >2-少于两个（可以用以下任意一种代替：q1，!t）
*F-重复应用乘法。换句话说，列表的乘积。
h -将产品加1。
/ -通过输入进行楼层划分。

TL; DR：在[1，input]范围内获得输入的所有互质数，得到它们的乘积，将其乘以除以输入。

— Xcoder先生
source

2

Python 2，62个字节

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

在线尝试！

— 丹尼斯
source

2

J，33个字节

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

比起其他任何事情，这更是一种要求改进的要求。我先尝试了一个默认解决方案，但是比这更长。

说明

这是Xcoder先生的解决方案到J的相当简单的翻译。

在线尝试！

— 约拿
source

2

05AB1E，8个字节

Lʒ¿}P>I÷

在线尝试！

— 艾米尼亚
source

2

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我认为很整齐的边缘情况。

使用rturnbull的向量化GCD函数。

在线尝试！

— 朱塞佩
source

2

Pari / GP，36字节

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

在线尝试！

— Alephalpha
source

2

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>

展开摘要

整数除法再次发生。编辑：由于@Shaggy，节省了2个字节。通过使其更具递归性又节省了2个字节，因此它可能无法使用比以前小的值。

— 尼尔
source

70个字节（尽管我还没有机会对其进行全套测试）：f=(n,i=n,p=1,g=(a,b)=>b?g(b,a%b):a)=>--i?f(n,i,g(n,i)-1?p:p*i):-~p/n|0

— 粗野的

在决定尝试映射数组并将其也减小到70个字节之前，我回到了我正在研究的递归解决方案。有点混乱，但是您可以从中解救一些东西，以帮助您将解决方案降低到70以下：(n,x=n)=>(g=s=>--x?g(s*(h=(y,z)=>z?h(z,y%z):--y?1:x)(n,x)):++s)(1)/n|0

— Shaggy

@Shaggy好吧，我很受鼓舞，希望能再进行一次研究，但是我不确定这就是您所期望的...

— Neil

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

— SEJPM
source

1

Japt，11个字节

õ fjU ×Ä zU

尝试一下

说明

整数的隐式输入U。

õ

生成一个从1到的整数数组U。

fjU

过滤（f）的互素数U。

×

通过乘法减少。

Ä

加1。

zU

除以U，将结果取底并隐式输出。

— 毛茸茸
source

对于n = 25，它返回1654529071288638400，这是错误的，因为它将是1654529071288638505

— RosLuP

@RosLuP：挑战作者确认，我们不需要处理超过32位的数字。

— 毛茸茸的

1

公理，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

— 罗斯鲁普
source

1

JavaScript（ES6），83 81 80 78 76 68字节

我的第一遍测试比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

尝试一下

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>

展开摘要

— 毛茸茸
source

计算威尔逊数

测试用例

果冻，8 7字节

外壳，11个字节

说明

Mathematica，91个字节

Pyth，11个字节

怎么样？

Python 2，62个字节

J，33个字节

说明

05AB1E，8个字节

R，82字节

Pari / GP，36字节

JavaScript（ES6），72 70 68字节

Haskell，42个字节

Japt，11个字节

说明

公理，121字节

JavaScript（ES6），83 81 80 78 76 68字节

尝试一下

非递归，76字节

尝试一下