Wilson primes of order n: Difference between revisions
m
→{{header|RPL}}: removed a debug instruction
(→{{header|FreeBASIC}}: -disclaimer) |
m (→{{header|RPL}}: removed a debug instruction) |
||
| (21 intermediate revisions by 12 users not shown) | |||
Line 21:
=={{header|ALGOL 68}}==
{{Trans|Visual Basic .NET}}
... but using a sieve for primeallity checking.
<br>As with the various BASIC samples, all calculations are done MOD p2 so arbitrary precision integers are not needed.
<syntaxhighlight lang="algol68">
# ( ( n - 1 )! x ( p - n )! - (-1)^n ) mod p^2 = 0 #
[]BOOL primes = PRIMESIEVE 11 000; # sieve the primes to 11 500 #
# returns TRUE if p is an nth order Wilson prime #
PROC is wilson = ( INT n, p )BOOL:
ELSE
FOR i
OD;
FOR i TO p - n DO #
FI # is
# find the Wilson primes #
print( ( " n: Wilson primes", newline ) );
print( ( "-----------------", newline ) );
FOR n TO 11 DO
print( ( whole( n, -2 ), ":" ) );
FI
OD;
print( ( newline ) )
OD
END
</syntaxhighlight>
{{out}}
<pre>
Line 79 ⟶ 65:
2: 2 3 11 107 4931
3: 7
4: 10429
5: 5 7 47
6: 11
Line 87 ⟶ 73:
10: 11 1109
11: 17 2713
</pre>
=={{header|BASIC}}==
==={{header|Applesoft BASIC}}===
{{trans|Chipmunk Basic}}
<syntaxhighlight lang="qbasic">100 home
110 print "n: Wilson primes"
120 print "--------------------"
130 for n = 1 to 11
140 print n;chr$(9);
150 for p = 2 to 18
160 gosub 240
170 if pt = 0 then goto 200
180 gosub 340
190 if wnpt = 1 then print p,
200 next p
210 print
220 next n
230 end
240 rem tests if the number P is prime
250 rem result is stored in PT
260 pt = 1
270 if p = 2 then return
280 if p * 2 - int(p / 2) = 0 then pt = 0 : return
290 j = 3
300 if j*j > p then return
310 if p * j - int(p / j) = 0 then pt = 0 : return
320 j = j+2
330 goto 300
340 rem tests if the prime p is a Wilson prime of order n
350 rem make sure it actually is prime first
360 rem result is stored in wnpt
370 wnpt = 0
380 if p = 2 and n = 2 then wnpt = 1 : return
390 if n > p then wnpt = 0 : return
400 prod = 1 : p2 = p*p
410 for i = 1 to n-1
420 prod = (prod*i) : gosub 500
430 next i
440 for i = 1 to p-n
450 prod = (prod*i) : gosub 500
460 next i
470 prod = (p2+prod-(-1)^n) : gosub 500
480 if prod = 0 then wnpt = 1 : return
490 wnpt = 0 : return
500 rem prod mod p2 fails if prod > 32767 so brew our own modulus function
510 prod = prod-int(prod/p2)*p2
520 return</syntaxhighlight>
==={{header|BASIC256}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="basic256">function isPrime(v)
if v <= 1 then return False
for i = 2 To int(sqr(v))
if v % i = 0 then return False
next i
return True
end function
function isWilson(n, p)
if p < n then return false
prod = 1
p2 = p*p #p^2
for i = 1 to n-1
prod = (prod*i) mod p2
next i
for i = 1 to p-n
prod = (prod*i) mod p2
next i
prod = (p2 + prod - (-1)**n) mod p2
if prod = 0 then return true else return false
end function
print " n: Wilson primes"
print "----------------------"
for n = 1 to 11
print n;" : ";
for p = 3 to 10499 step 2
if isPrime(p) and isWilson(n, p) then print p; " ";
next p
print
next n
end</syntaxhighlight>
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
{{works with|GW-BASIC}}
{{works with|MSX_BASIC}}
{{works with|PC-BASIC|any}}
{{works with|QBasic}}
{{trans|GW-BASIC}}
<syntaxhighlight lang="qbasic">100 cls
110 print "n: Wilson primes"
120 print "--------------------"
130 for n = 1 to 11
140 print n;chr$(9);
150 for p = 2 to 18
160 gosub 240
170 if pt = 0 then goto 200
180 gosub 340
190 if wnpt = 1 then print p,
200 next p
210 print
220 next n
230 end
240 rem tests if the number P is prime
250 rem result is stored in PT
260 pt = 1
270 if p = 2 then return
280 if p mod 2 = 0 then pt = 0 : return
290 j = 3
300 if j*j > p then return
310 if p mod j = 0 then pt = 0 : return
320 j = j+2
330 goto 300
340 rem tests if the prime p is a Wilson prime of order n
350 rem make sure it actually is prime first
360 rem result is stored in wnpt
370 wnpt = 0
380 if p = 2 and n = 2 then wnpt = 1 : return
390 if n > p then wnpt = 0 : return
400 prod = 1 : p2 = p*p
410 for i = 1 to n-1
420 prod = (prod*i) : gosub 500
430 next i
440 for i = 1 to p-n
450 prod = (prod*i) : gosub 500
460 next i
470 prod = (p2+prod-(-1)^n) : gosub 500
480 if prod = 0 then wnpt = 1 : return
490 wnpt = 0 : return
500 rem prod mod p2 fails if prod > 32767 so brew our own modulus function
510 prod = prod-int(prod/p2)*p2
520 return</syntaxhighlight>
==={{header|QBasic}}===
{{works with|QBasic}}
{{works with|QuickBasic}}
{{trans|FreeBASIC}}
<syntaxhighlight lang="qbasic">FUNCTION isPrime (ValorEval)
IF ValorEval < 2 THEN isPrime = False
IF ValorEval MOD 2 = 0 THEN isPrime = 2
IF ValorEval MOD 3 = 0 THEN isPrime = 3
d = 5
WHILE d * d <= ValorEval
IF ValorEval MOD d = 0 THEN isPrime = False ELSE d = d + 2
WEND
isPrime = True
END FUNCTION
FUNCTION isWilson (n, p)
IF p < n THEN isWilson = False
prod = 1
p2 = p ^ 2
FOR i = 1 TO n - 1
prod = (prod * i) MOD p2
NEXT i
FOR i = 1 TO p - n
prod = (prod * i) MOD p2
NEXT i
prod = (p2 + prod - (-1) ^ n) MOD p2
IF prod = 0 THEN isWilson = True ELSE isWilson = False
END FUNCTION
PRINT " n: Wilson primes"
PRINT "----------------------"
FOR n = 1 TO 11
PRINT USING "##: "; n;
FOR p = 3 TO 10099 STEP 2
If isPrime(p) AND isWilson(n, p) Then Print p; " ";
NEXT p
PRINT
NEXT n
END</syntaxhighlight>
==={{header|MSX Basic}}===
Both the [[#GW-BASIC|GW-BASIC]] and [[#Chipmunk_Basic|Chipmunk Basic]] solutions work without change.
==={{header|Visual Basic .NET}}===
{{Trans|QBasic}}
...but includes 2 and the 4th order Wilson Prime.
<syntaxhighlight lang="vbnet">
Option Strict On
Option Explicit On
Module WilsonPrimes
Function isPrime(p As Integer) As Boolean
If p < 2 Then Return False
If p Mod 2 = 0 Then Return p = 2
IF p Mod 3 = 0 Then Return p = 3
Dim d As Integer = 5
Do While d * d <= p
If p Mod d = 0 Then
Return False
Else
d = d + 2
End If
Loop
Return True
End Function
Function isWilson(n As Integer, p As Integer) As Boolean
If p < n Then Return False
Dim prod As Long = 1
Dim p2 As Long = p * p
For i = 1 To n - 1
prod = (prod * i) Mod p2
Next i
For i = 1 To p - n
prod = (prod * i) Mod p2
Next i
prod = (p2 + prod - If(n Mod 2 = 0, 1, -1)) Mod p2
Return prod = 0
End Function
Sub Main()
Console.Out.WriteLine(" n: Wilson primes")
Console.Out.WriteLine("----------------------")
For n = 1 To 11
Console.Out.Write(n.ToString.PadLeft(2) & ": ")
If isWilson(n, 2) Then Console.Out.Write("2 ")
For p = 3 TO 10499 Step 2
If isPrime(p) And isWilson(n, p) Then Console.Out.Write(p & " ")
Next p
Console.Out.WriteLine()
Next n
End Sub
End Module
</syntaxhighlight>
{{out}}
<pre>
n: Wilson primes
----------------------
1: 5 13 563
2: 2 3 11 107 4931
3: 7
4: 10429
5: 5 7 47
6: 11
7: 17
8:
9: 541
10: 11 1109
11: 17 2713
</pre>
==={{header|Yabasic}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="yabasic">print "n: Wilson primes"
print "---------------------"
for n = 1 to 11
print n, ":",
for p = 3 to 10099 step 2
if isPrime(p) and isWilson(n, p) then print p, " ", : fi
next p
print
next n
end
sub isPrime(v)
if v < 2 then return False : fi
if mod(v, 2) = 0 then return v = 2 : fi
if mod(v, 3) = 0 then return v = 3 : fi
d = 5
while d * d <= v
if mod(v, d) = 0 then return False else d = d + 2 : fi
end while
return True
end sub
sub isWilson(n, p)
if p < n then return False : fi
prod = 1
p2 = p**2
for i = 1 to n-1
prod = mod((prod*i), p2)
next i
for i = 1 to p-n
prod = mod((prod*i), p2)
next i
prod = mod((p2 + prod - (-1)**n), p2)
if prod = 0 then return True else return False : fi
end sub</syntaxhighlight>
=={{header|C}}==
{{trans|Wren}}
{{libheader|GMP}}
<syntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <gmp.h>
bool *sieve(int limit) {
int i, p;
limit++;
// True denotes composite, false denotes prime.
bool *c = calloc(limit, sizeof(bool)); // all false by default
c[0] = true;
c[1] = true;
for (i = 4; i < limit; i += 2) c[i] = true;
p = 3; // Start from 3.
while (true) {
int p2 = p * p;
if (p2 >= limit) break;
for (i = p2; i < limit; i += 2 * p) c[i] = true;
while (true) {
p += 2;
if (!c[p]) break;
}
}
return c;
}
int main() {
const int limit = 11000;
int i, j, n, pc = 0;
unsigned long p;
bool *c = sieve(limit);
for (i = 0; i < limit; ++i) {
if (!c[i]) ++pc;
}
unsigned long *primes = (unsigned long *)malloc(pc * sizeof(unsigned long));
for (i = 0, j = 0; i < limit; ++i) {
if (!c[i]) primes[j++] = i;
}
mpz_t *facts = (mpz_t *)malloc(limit *sizeof(mpz_t));
for (i = 0; i < limit; ++i) mpz_init(facts[i]);
mpz_set_ui(facts[0], 1);
for (i = 1; i < limit; ++i) mpz_mul_ui(facts[i], facts[i-1], i);
mpz_t f, sign;
mpz_init(f);
mpz_init_set_ui(sign, 1);
printf(" n: Wilson primes\n");
printf("--------------------\n");
for (n = 1; n < 12; ++n) {
printf("%2d: ", n);
mpz_neg(sign, sign);
for (i = 0; i < pc; ++i) {
p = primes[i];
if (p < n) continue;
mpz_mul(f, facts[n-1], facts[p-n]);
mpz_sub(f, f, sign);
if (mpz_divisible_ui_p(f, p*p)) printf("%ld ", p);
}
printf("\n");
}
free(c);
free(primes);
for (i = 0; i < limit; ++i) mpz_clear(facts[i]);
free(facts);
return 0;
}</syntaxhighlight>
{{out}}
<pre>
n: Wilson primes
--------------------
1: 5 13 563
2: 2 3 11 107 4931
3: 7
4: 10429
5: 5 7 47
6: 11
7: 17
8:
9: 541
10: 11 1109
11: 17 2713
</pre>
=={{header|C++}}==
{{libheader|GMP}}
<
#include <iostream>
#include <vector>
Line 135 ⟶ 491:
std::cout << '\n';
}
}</
{{out}}
Line 153 ⟶ 509:
11 | 17 2713
</pre>
=={{header|EasyLang}}==
{{trans|FreeBASIC}}
<syntaxhighlight>
func isprim num .
i = 2
while i <= sqrt num
if num mod i = 0
return 0
.
i += 1
.
return 1
.
func is_wilson n p .
if p < n
return 0
.
prod = 1
p2 = p * p
for i = 1 to n - 1
prod = prod * i mod p2
.
for i = 1 to p - n
prod = prod * i mod p2
.
prod = (p2 + prod - pow -1 n) mod p2
if prod = 0
return 1
.
return 0
.
print "n: Wilson primes"
print "-----------------"
for n = 1 to 11
write n & " "
for p = 3 step 2 to 10099
if isprim p = 1 and is_wilson n p = 1
write p & " "
.
.
print ""
.
</syntaxhighlight>
=={{header|F_Sharp|F#}}==
This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_functions Extensible Prime Generator (F#)]
<
// Wilson primes. Nigel Galloway: July 31st., 2021
let rec fN g=function n when n<2I->g |n->fN(n*g)(n-1I)
let fG (n:int)(p:int)=let g,p=bigint n,bigint p in (((fN 1I (g-1I))*(fN 1I (p-g))-(-1I)**n)%(p*p))=0I
[1..11]|>List.iter(fun n->printf "%2d -> " n; let fG=fG n in pCache|>Seq.skipWhile((>)n)|>Seq.takeWhile((>)11000)|>Seq.filter fG|>Seq.iter(printf "%d "); printfn "")
</syntaxhighlight>
{{out}}
<pre>
Line 179 ⟶ 580:
=={{header|Factor}}==
{{works with|Factor|0.99 2021-06-02}}
<
math.primes math.ranges prettyprint sequences sequences.extras ;
Line 204 ⟶ 605:
" n: Wilson primes\n--------------------" print
11 [1,b] [ order. ] each</
{{out}}
<pre>
Line 224 ⟶ 625:
=={{header|FreeBASIC}}==
This excludes the trivial case p=n=2.
<
function is_wilson( n as uinteger, p as uinteger ) as boolean
Line 251 ⟶ 652:
print
next n
</syntaxhighlight>
{{out}}<pre>
n: Wilson primes
Line 271 ⟶ 672:
{{trans|Wren}}
{{libheader|Go-rcu}}
<
import (
Line 310 ⟶ 711:
fmt.Println()
}
}</
{{out}}
Line 328 ⟶ 729:
11: 17 2713
</pre>
=={{header|GW-BASIC}}==
<syntaxhighlight lang="gwbasic">10 PRINT "n: Wilson primes"
20 PRINT "--------------------"
30 FOR N = 1 TO 11
40 PRINT USING "##";N;
50 FOR P=2 TO 18
60 GOSUB 140
70 IF PT=0 THEN GOTO 100
80 GOSUB 230
90 IF WNPT=1 THEN PRINT P;
100 NEXT P
110 PRINT
120 NEXT N
130 END
140 REM tests if the number P is prime
150 REM result is stored in PT
160 PT = 1
170 IF P=2 THEN RETURN
175 IF P MOD 2 = 0 THEN PT=0:RETURN
180 J=3
190 IF J*J>P THEN RETURN
200 IF P MOD J = 0 THEN PT = 0: RETURN
210 J = J + 2
220 GOTO 190
230 REM tests if the prime P is a Wilson prime of order N
240 REM make sure it actually is prime first
250 REM RESULT is stored in WNPT
260 WNPT=0
270 IF P=2 AND N=2 THEN WNPT = 1: RETURN
280 IF N>P THEN WNPT=0: RETURN
290 PROD# = 1 : P2 = P*P
300 FOR I = 1 TO N-1
310 PROD# = (PROD#*I) : GOSUB 3000
320 NEXT I
330 FOR I = 1 TO P-N
340 PROD# = (PROD#*I) : GOSUB 3000
350 NEXT I
360 PROD# = (P2+PROD#-(-1)^N) : GOSUB 3000
370 IF PROD# = 0 THEN WNPT = 1: RETURN
380 WNPT = 0: RETURN
3000 REM PROD# MOD P2 fails if PROD#>32767 so brew our own modulus function
3010 PROD# = PROD# - INT(PROD#/P2)*P2
3020 RETURN</syntaxhighlight>
=={{header|J}}==
<syntaxhighlight lang="j"> wilson=. 0 = (*:@] | _1&^@[ -~ -~ *&! <:@[)^:<:
(>: i. 11x) ([ ;"0 wilson"0/ <@# ]) i.&.(p:inv) 11000
┌──┬───────────────┐
│1 │5 13 563 │
├──┼───────────────┤
│2 │2 3 11 107 4931│
├──┼───────────────┤
│3 │7 │
├──┼───────────────┤
│4 │10429 │
├──┼───────────────┤
│5 │5 7 47 │
├──┼───────────────┤
│6 │11 │
├──┼───────────────┤
│7 │17 │
├──┼───────────────┤
│8 │ │
├──┼───────────────┤
│9 │541 │
├──┼───────────────┤
│10│11 1109 │
├──┼───────────────┤
│11│17 2713 │
└──┴───────────────┘</syntaxhighlight>
=={{header|Java}}==
<
import java.util.*;
Line 378 ⟶ 851:
return primes;
}
}</
{{out}}
Line 408 ⟶ 881:
'''Preliminaries'''
<
# For 0 <= $n <= ., factorials[$n] is $n !
Line 417 ⟶ 890:
def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;
def primes: 2, (range(3; infinite; 2) | select(is_prime));</
'''Wilson primes'''
<
def wilson_primes:
def sgn: if . % 2 == 0 then 1 else -1 end;
Line 434 ⟶ 907:
% ($p*$p) == 0 )) ])" );
11000 | wilson_primes</
{{out}}
gojq -ncr -f rc-wilson-primes.jq
Line 455 ⟶ 928:
=={{header|Julia}}==
{{trans|Wren}}
<
function wilsonprimes(limit = 11000)
Line 473 ⟶ 946:
wilsonprimes()
</syntaxhighlight>
Output: Same as Wren example.
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
WilsonPrime[n_Integer] := Module[{primes, out},
primes = Prime[Range[PrimePi[11000]]];
Line 491 ⟶ 964:
,
{n, 1, 11}
]</
{{out}}
<pre>{5,13,563}
Line 509 ⟶ 982:
{{libheader|bignum}}
As in Nim there is not (not yet?) a standard module to deal with big numbers, we use the third party module “bignum”.
<
import bignum
Line 538 ⟶ 1,011:
if f mod (p * p) == 0:
wilson.add p
echo &"{n:2}: ", wilson.join(" ")</
{{out}}
Line 554 ⟶ 1,027:
10: 11 1109
11: 17 2713</pre>
=={{header|PARI/GP}}==
{{trans|Julia}}
<syntaxhighlight lang="PARI/GP">
default("parisizemax", "1024M");
\\ Define the function wilsonprimes with a default limit of 11000
wilsonprimes(limit) = {
\\ Set the default limit if not specified
my(limit = if(limit, limit, 11000));
\\ Precompute factorial values up to the limit to save time
my(facts = vector(limit, i, i!));
\\ Sign variable for adjustment in the formula
my(sgn = 1);
print(" n: Wilson primes\n--------------------");
\\ Loop over the specified range (1 to 11 in the original code)
for(n = 1, 11,
print1(Str(" ", n, ": "));
sgn = -sgn; \\ Toggle the sign
\\ Loop over all primes up to the limit
forprime(p = 2, limit,
\\ Check the Wilson prime condition modified for PARI/GP
index=1;
if(n<2,index=1,index=n-1);
if(p > n && Mod(facts[index] * facts[p - n] - sgn, p^2) == 0,
print1(Str(p, " "));
)
);
print1("\n");
);
}
\\ Execute the function with the default limit
wilsonprimes();
</syntaxhighlight>
{{out}}
<pre>
n: Wilson primes
--------------------
1: 5 13 563
2: 3 11 107 4931
3: 7
4: 10429
5: 7 47
6: 11
7: 17
8:
9: 541
10: 11 1109
11: 17 2713
</pre>
=={{header|Perl}}==
{{libheader|ntheory}}
<
use warnings;
use ntheory <primes factorial>;
Line 565 ⟶ 1,092:
for my $n (1..11) {
printf "%3d: %s\n", $n, join ' ', grep { $_ >= $n && 0 == (factorial($n-1) * factorial($_-$n) - (-1)**$n) % $_**2 } @primes
}</
{{out}}
<pre> 1: 5 13 563
Line 581 ⟶ 1,108:
=={{header|Phix}}==
{{trans|Wren}}
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">limit</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">11000</span>
Line 607 ⟶ 1,134:
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</
Output: Same as Wren example.
=={{header|Prolog}}==
{{works with|SWI Prolog}}
<
wilson_primes(11000).
Line 653 ⟶ 1,180:
M1 is M + 1,
F1 is F * M1,
make_factorials(N, M1, F1).</
Module for finding prime numbers up to some limit:
<
:- dynamic is_prime/1.
Line 697 ⟶ 1,224:
cross_out(S, N, P):-
Q is S + 2 * P,
cross_out(Q, N, P).</
{{out}}
Line 715 ⟶ 1,242:
11 | 17 2713
</pre>
=={{header|Python}}==
<syntaxhighlight lang="python">
# wilson_prime.py by xing216
def sieve(n):
multiples = []
for i in range(2, n+1):
if i not in multiples:
yield i
for j in range(i*i, n+1, i):
multiples.append(j)
def intListToString(list):
return " ".join([str(i) for i in list])
limit = 11000
primes = list(sieve(limit))
facs = [1]
for i in range(1,limit):
facs.append(facs[-1]*i)
sign = 1
print(" n: Wilson primes")
print("—————————————————")
for n in range(1,12):
sign = -sign
wilson = []
for p in primes:
if p < n: continue
f = facs[n-1] * facs[p-n] - sign
if f % p**2 == 0: wilson.append(p)
print(f"{n:2d}: {intListToString(wilson)}")
</syntaxhighlight>
{{out}}
<pre>
n: Wilson primes
—————————————————
1: 5 13 563
2: 2 3 11 107 4931
3: 7
4: 10429
5: 5 7 47
6: 11
7: 17
8:
9: 541
10: 11 1109
11: 17 2713
</pre>
=={{header|Racket}}==
<syntaxhighlight lang="racket">#lang racket
(require math/number-theory)
(define ((wilson-prime? n) p)
(and (>= p n)
(prime? p)
(divides? (sqr p)
(- (* (factorial (- n 1))
(factorial (- p n)))
(expt -1 n)))))
(define primes<11000 (filter prime? (range 1 11000)))
(for ((n (in-range 1 (add1 11))))
(printf "~a: ~a~%" n (filter (wilson-prime? n) primes<11000)))</syntaxhighlight>
{{out}}
<pre>1: (5 13 563)
2: (2 3 11 107 4931)
3: (7)
4: (10429)
5: (5 7 47)
6: (11)
7: (17)
8: ()
9: (541)
10: (11 1109)
11: (17 2713)</pre>
=={{header|Raku}}==
<syntaxhighlight lang="raku"
sub postfix:<!> (Int $n) { (constant f = 1, |[\×] 1..*)[$n] }
Line 734 ⟶ 1,339:
.say for (1..40).hyper(:1batch).map: -> \𝒏 {
sprintf "%3d: %s", 𝒏, @primes.grep( -> \𝒑 { (𝒑 ≥ 𝒏) && ((𝒏 - 1)!(𝒑 - 𝒏)! - (-1) ** 𝒏) %% 𝒑² } ).Str
}</
{{out}}
<pre> n: Wilson primes
Line 781 ⟶ 1,386:
=={{header|REXX}}==
For more (extended) results, see this task's discussion page.
<
/*────────────────── (n-1)! * (P-n)! - (-1)**n where n is 1 ──◄ 11, and P < 18.*/
parse arg oLO oHI hip . /*obtain optional argument from the CL.*/
Line 827 ⟶ 1,432:
end /*k*/ /* [↑] only process numbers ≤ √ J */
#= #+1; @.#= j; sq.#= j*j; !.j= 1 /*bump # of Ps; assign next P; P²; P# */
end /*j*/; return</
{{out|output|text= when using the default inputs:}}
<pre>
Line 844 ⟶ 1,449:
11 │ 17 2,713
───────┴─────────────────────────────────────────────────────────────
</pre>
=={{header|RPL}}==
{{works with|RPL|HP-49C}}
« → maxp
« { }
1 11 '''FOR''' n
{ } n
'''IF''' DUP ISPRIME? NOT '''THEN''' NEXTPRIME '''END'''
'''WHILE''' DUP maxp < '''REPEAT'''
n 1 - FACT OVER n - FACT * -1 n ^ -
'''IF''' OVER SQ MOD NOT '''THEN''' SWAP OVER + SWAP '''END'''
NEXTPRIME
'''END'''
DROP 1 →LIST +
'''NEXT'''
» » '<span style="color:blue">TASK</span>' STO
{{out}}
<pre>
1: { { 5 13 } { 2 3 11 } { 7 } { } { 5 7 } { 11 } { 17 } { } { } { 11 } { 17 } }
</pre>
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">require "prime"
module Modulo
refine Integer do
def factorial_mod(m) = (1..self).inject(1){|prod, n| (prod *= n) % m }
end
end
using Modulo
primes = Prime.each(11000).to_a
(1..11).each do |n|
res = primes.select do |pr|
prpr = pr*pr
((n-1).factorial_mod(prpr) * (pr-n).factorial_mod(prpr) - (-1)**n) % (prpr) == 0
end
puts "#{n.to_s.rjust(2)}: #{res.inspect}"
end
</syntaxhighlight>
{{out}}
<pre> 1: [5, 13, 563]
2: [2, 3, 11, 107, 4931]
3: [7]
4: [10429]
5: [5, 7, 47]
6: [11]
7: [17]
8: []
9: [541]
10: [11, 1109]
11: [17, 2713]
</pre>
=={{header|Rust}}==
<
// rug = "1.13.0"
Line 910 ⟶ 1,570:
s = -s;
}
}</
{{out}}
Line 930 ⟶ 1,590:
=={{header|Sidef}}==
<
var m = p*p
(factorialmod(n-1, m) * factorialmod(p-n, m) - (-1)**n) % m == 0
Line 941 ⟶ 1,601:
for n in (1..11) {
printf("%3d: %s\n", n, primes.grep {|p| is_wilson_prime(p, n) })
}</
{{out}}
<pre>
Line 963 ⟶ 1,623:
{{libheader|Wren-big}}
{{libheader|Wren-fmt}}
<
import "./big" for BigInt
import "./fmt" for Fmt
var limit = 11000
Line 984 ⟶ 1,644:
}
System.print()
}</
{{out}}
| |||