Dado un número entero positivo n , calcular el n ^º Wilson número W (n) donde

y e = 1 si n tiene un módulo raíz primitivo n , de lo contrario e = -1. En otras palabras, n tiene una raíz primitiva si no existe un número entero x donde 1 < x < n-1 y x ² = 1 mod n .

• Esto es código de golf por lo que crear el código más corto para una función o programa que calcula el n ^º número Wilson por un número entero de entrada n > 0.
• Puede usar indexación basada en 1 o en 0. También puede optar por generar los primeros n números de Wilson.
• Esta es la secuencia OEIS A157249 .

Casos de prueba

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

Jalea , 8 7 bytes

1 byte gracias a Dennis.

gRỊTP‘:

Pruébalo en línea!

Realmente no tiene que calcular, eya que necesita dividir de todos modos.

Casco , 11 bytes

S÷ȯ→Π§foε⌋ḣ

Pruébalo en línea!

Explicación

          ḣ   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])/#]&

Pyth , 11 bytes

/h*Ff>2iTQS

Pruébalo aquí!

¿Cómo?

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

• S- Generar el rango inclusivo [1, entrada]

• f - Filtrar-guardar esos:

  • iTQ - cuyo GCD con la entrada.

  • >2- sea inferior a dos (se puede sustituir por cualquiera de las siguientes situaciones: q1, !t)

• *F- Aplicar multiplicación repetidamente. En otras palabras, el producto de la lista.

• h - Incrementar el producto en 1.

• / - División de piso con la entrada.

TL; DR : Lleve todos los coprimes a la entrada en el rango [1, entrada] , obtenga su producto, increméntelo y divídalo por la 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

Pruébalo en línea!

J, 33 bytes

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

Esta es más una solicitud para ver una mejora que cualquier otra cosa. Primero probé una solución tácita, pero fue más larga que esto.

explicación

Esta es una traducción bastante sencilla de la solución del Sr. Xcoder a J.

Pruébalo en línea!

05AB1E , 8 bytes

Lʒ¿}P>I÷

Pruébalo en línea!

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)

Utiliza la división de enteros en lugar de descubrir emuchas respuestas aquí, aunque sí resolví eso, e=2*any((1:n)^2%%n==1%%n)-1incluido el caso límite den=1 que pensé que era bastante bueno.

Utiliza la función GCD vectorizada de rturnbull .

Pruébalo en línea!

Pari / GP , 36 bytes

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

Pruébalo en línea!

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>

La división entera ataca de nuevo. Editar: Guardado 2 bytes gracias a @Shaggy. Ahorró otros 2 bytes haciéndolo mucho más recursivo, por lo que puede fallar para valores más pequeños de lo que solía.

Haskell , 42 bytes

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

Pruébalo en línea!

Utiliza el truco de la división de enteros como todas las otras respuestas.
Utiliza índices basados ​​en 1.

Explicación

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 bytes

õ fjU ×Ä zU

Intentalo

Explicación

Entrada implícita de entero U.

õ

Genere una matriz de enteros de 1 a U.

fjU

Filter ( f) co-primos de U.

×

Reducir por multiplicación.

Ä

Añadir 1.

zU

Dividir por U, piso el resultado y la salida implícita.

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)

agregar algún tipo, deshacer eso y 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

Mi primer paso en esto fue unos pocos bytes más largo que la solución de Neil, por lo que originalmente lo abandoné a favor de la solución de reducción de matriz a continuación. Desde entonces lo he jugado para empatar con 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

Intentalo

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>

No recursivo, 76 bytes

Quería probar una solución no recursiva para ver cómo resultaría, no tan mal como esperaba.

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

Intentalo

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>