Dado um número inteiro positivo n , calcular o n ^th Wilson número W (n) , onde

e e = 1 se n tiver um módulo raiz primitivo n , caso contrário, e = -1. Em outras palavras, n tem uma raiz primitiva se não existe um número inteiro x , onde 1 < x < n-1 e X ² = 1 mod n .

• Isso é código-golfe, portanto, crie o código mais curto para uma função ou programa que calcule o n- ^ésimo número de Wilson para um número inteiro de entrada n > 0.
• Você pode usar a indexação com base em 1 ou em 0. Você também pode optar por imprimir os primeiros n números Wilson.
• Essa é a sequência OEIS A157249 .

Casos de teste

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

Geléia , 8 7 bytes

1 byte graças a Dennis.

gRỊTP‘:

Experimente online!

Você realmente não precisa calcular, epois precisa dividir de qualquer maneira.

Casca , 11 bytes

S÷ȯ→Π§foε⌋ḣ

Experimente online!

Explicação

          ḣ   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 bytes

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

Pitão , 11 bytes

/h*Ff>2iTQS

Experimente aqui!

Quão?

• /h*Ff>2iTQS - programa completo.

• S- Gere a faixa inclusiva [1, entrada]

• f - Mantenha os filtros:

  • iTQ - cujo GCD com a entrada.

  • >2- é inferior a dois (pode ser substituído por um dos seguintes itens q1:, !t)

• *F- Aplique a multiplicação repetidamente. Em outras palavras, o produto da lista.

• h - Incremente o produto em 1.

• / - Divisão de piso com a entrada.

TL; DR : Pegue todos os coprimes da entrada no intervalo [1, entrada] , obtenha o produto, aumente e divida pela entrada.

Python 2 , 62 bytes

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

Experimente online!

J, 33 bytes

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

Este é mais um pedido para ver uma melhoria do que qualquer outra coisa. Tentei uma solução tácita primeiro, mas era mais longa do que isso.

explicação

Esta é uma tradução bastante direta da solução do Sr. Xcoder em J.

Experimente online!

05AB1E , 8 bytes

Lʒ¿}P>I÷

Experimente online!

R , 82 bytes

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

Usa divisão inteira em vez de descobrir ecomo muitas respostas aqui, embora eu tenha resolvido isso, e=2*any((1:n)^2%%n==1%%n)-1incluindo o caso extremo do n=1qual eu achava bem legal.

Usa a função GCD vetorizada do rturnbull .

Experimente online!

Pari / GP , 36 bytes

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

Experimente online!

JavaScript (ES6), 72 70 68 bytes

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>

A divisão inteira ataca novamente. Editar: salvou 2 bytes graças a @Shaggy. Salvou mais 2 bytes, tornando-o muito mais recursivo, para que ele falhe em valores menores do que costumava.

Haskell , 42 bytes

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

Experimente online!

Usa o truque de divisão inteira como todas as outras respostas.
Usa índices baseados em 1.

Explicação

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

Japonês , 11 bytes

õ fjU ×Ä zU

Tente

Explicação

Entrada implícita de número inteiro U.

õ

Gere uma matriz de números inteiros de 1 a U.

fjU

O filtro ( f) é primo de U.

×

Reduza pela multiplicação.

Ä

Adicione 1.

zU

Divida por U, classifique o resultado e a saída implicitamente.

Axioma, 121 bytes

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)

adicione algum tipo, ungolf isso e resultado

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 bytes

Minha primeira passagem para isso foi alguns bytes mais longa que a solução de Neil, e é por isso que originalmente a deixei em favor da solução de redução de matriz abaixo. Desde então, joguei golfe para amarrar 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

Tente

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>

Não recursivo, 76 bytes

Eu queria tentar uma solução não recursiva para ver como seria a solução - não tão ruim quanto eu esperava.

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

Tente

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>