Dato un intero positivo n , calcolare il n ^esimo numero Wilson W (n) dove

ed e = 1 se n ha una radice primitiva modulo n , altrimenti e = -1. In altre parole, n ha una radice primitiva se non esiste un numero intero x dove 1 < x < n-1 e x ² = 1 mod n .

• Questo è codice-golf così creare il codice breve per una funzione o un programma che calcola il n ^esimo numero Wilson per un intero ingresso n > 0.
• È possibile utilizzare l'indicizzazione basata su 1 o su base 0. Puoi anche scegliere di produrre i primi n numeri Wilson.
• Questa è la sequenza OEIS A157249 .

Casi test

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

Gelatina , 8 7 byte

1 byte grazie a Dennis.

gRỊTP‘:

Provalo online!

Non devi davvero calcolare epoiché devi dividere comunque.

Buccia , 11 byte

S÷ȯ→Π§foε⌋ḣ

Provalo online!

Spiegazione

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

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

Pyth , 11 byte

/h*Ff>2iTQS

Provalo qui!

Come?

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

• S- Genera l'intervallo inclusivo [1, input]

• f - Filtra-conserva quelli:

  • iTQ - di cui GCD con l'ingresso.

  • >2- è inferiore a due (possono essere sostituiti da una delle seguenti: q1, !t)

• *F- Applica ripetutamente la moltiplicazione. In altre parole, il prodotto dell'elenco.

• h - Incrementa il prodotto di 1.

• / - Divisione del pavimento con l'ingresso.

TL; DR : ottieni tutti i coprimi nell'input nell'intervallo [1, input] , ottieni il loro prodotto, incrementalo e dividilo per l'input.

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

Provalo online!

J, 33 byte

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

Questo è più una richiesta di vedere un miglioramento che altro. Ho provato prima una soluzione tacita, ma è stata più lunga di così.

spiegazione

Questa è una traduzione abbastanza semplice della soluzione di Mr. Xcoder in J.

Provalo online!

05AB1E , 8 byte

Lʒ¿}P>I÷

Provalo online!

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)

Usa la divisione intera piuttosto che capire ecome molte risposte qui, anche se ho capito che e=2*any((1:n)^2%%n==1%%n)-1includendo il caso limite di n=1cui pensavo fosse abbastanza pulito.

Utilizza la funzione GCD vettoriale di rturnbull .

Provalo online!

Pari / GP , 36 byte

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

Provalo online!

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>

La divisione intera colpisce ancora. Modifica: salvato 2 byte grazie a @Shaggy. Ha salvato altri 2 byte rendendolo molto più ricorsivo, quindi potrebbe non riuscire per valori più piccoli rispetto al passato.

Haskell , 42 byte

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

Provalo online!

Usa il trucco di divisione intera come tutte le altre risposte.
Utilizza indici basati su 1.

Spiegazione

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

Provalo

Spiegazione

Input implicito di numero intero U.

õ

Genera un array di numeri interi da 1 a U.

fjU

Filter ( f) co-primes di U.

×

Ridurre per moltiplicazione.

Ä

Aggiungi 1

zU

Dividi per U, piano il risultato e implicitamente l'output.

Assioma, 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)

aggiungi qualche tipo, deseleziona quello e il risultato

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

Il mio primo passaggio in questo caso è stato di qualche byte in più rispetto alla soluzione di Neil, motivo per cui inizialmente l'ho abbandonato a favore della soluzione di riduzione dell'array di seguito. Da allora ho giocato a golf per legare 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

Provalo

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 non ricorsivi, 76 byte

Volevo provare una soluzione non ricorsiva per vedere come sarebbe andata a finire, non male come mi aspettavo.

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

Provalo

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>