Factorial primes: Difference between revisions
Content deleted Content added
m →{{header|ALGOL 68}}: Tweak |
No edit summary |
||
(85 intermediate revisions by 35 users not shown) | |||
Line 1:
{{
;Definition
A [[wp:Factorial_prime|'''factorial prime''']] is a prime number that is one less or one more than a [[wp:Factorial|factorial]].
Line 24:
;Reference
* [[oeis:A088054|OEIS:A088054 - Factorial primes]]
;Related task
* [[Sequence_of_primorial_primes|Sequence of primorial primes]]
<br><br>
=={{header|Ada}}==
<syntaxhighlight lang="ada">
-- Rosetta Code Task written in Ada
-- Factorial primes
-- https://rosettacode.org/wiki/Factorial_primes
-- August 2024, R. B. E.
-- Using GNAT Big Integers, GNAT version 14.1, MacOS 14.6.1, M1 chip
pragma Ada_2022;
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
with Ada.Numerics.Big_Numbers.Big_Integers; use Ada.Numerics.Big_Numbers.Big_Integers;
procedure Factorial_Primes is
function Is_Prime (N : in Big_Integer) return Boolean is
Big_0 : Big_Natural := To_Big_Integer (0);
Big_2 : Big_Natural := To_Big_Integer (2);
Big_3 : Big_Natural := To_Big_Integer (3);
Big_Temp : Big_Natural := To_Big_Integer (5);
begin
if N < Big_2 then
return False;
end if;
if N mod Big_2 = Big_0 then
return N = Big_2;
end if;
if N mod Big_3 = Big_0 then
return N = Big_3;
end if;
while Big_Temp * Big_Temp <= N loop
if N mod Big_Temp = Big_0 then
return False;
end if;
Big_Temp := Big_Temp + Big_2;
if N mod Big_Temp = Big_0 then
return False;
end if;
Big_Temp := Big_Temp + 4;
end loop;
return True;
end Is_Prime;
function Factorial (N : Positive) return Big_Integer is
type Factorial_Array is array (1..12) of Big_Integer;
First12_Facts : Factorial_Array;
Result : Big_Integer;
begin
First12_Facts (1) := To_Big_Integer (1);
for I in 2..12 loop
First12_Facts (I) := First12_Facts (I-1) * To_Big_Integer (I);
end loop;
if (N <= 12) then
return First12_Facts (N);
else
Result := First12_Facts (12);
for I in 13..N loop
Result := Result * To_Big_Integer (I);
end loop;
end if;
return Result;
end Factorial;
Fact : Big_Integer;
Fact_Plus_One : Big_Integer;
Fact_Minus_One : Big_Integer;
Big_One : constant Big_Integer := To_Big_Integer (1);
I, Count : Natural := 0;
Limit : constant Positive := 10;
begin
loop
I := I + 1;
Fact := Factorial (I);
if (is_Prime (Fact - Big_One)) then
Count := Count + 1;
Put (Count, 3);
Put (": ");
Put (I, 5);
Put ("! - 1 ");
Fact_Minus_One := Fact - Big_One;
Put (To_String (Arg => Fact_Minus_One, Width => 40));
New_Line;
end if;
if (is_Prime (Fact + Big_One)) then
Count := Count + 1;
Put (Count, 3);
Put (": ");
Put (I, 5);
Put ("! + 1 ");
Fact_Plus_One := Fact + Big_One;
Put (To_String (Arg => Fact_Plus_One, Width => 40));
New_Line;
end if;
exit when Count >= Limit;
end loop;
end Factorial_Primes;
</syntaxhighlight>
{{out}}
<pre>
1: 1! + 1 2
2: 2! + 1 3
3: 3! - 1 5
4: 3! + 1 7
5: 4! - 1 23
6: 6! - 1 719
7: 7! - 1 5039
8: 11! + 1 39916801
9: 12! - 1 479001599
10: 14! - 1 87178291199
</pre>
=={{header|ALGOL 68}}==
Basic task. Assumes LONG INT is at least 64 bits.
<syntaxhighlight lang="algol68">
# for some factorial f #
# is prime PROC based on the one in the primality by trial division task #
Line 39 ⟶ 156:
prime
FI;
# end of code
LONG INT f := 1;
INT
FOR n WHILE fp count < 10 DO
f *:= n;
IF LONG INT fp = f + offset;
print( ( whole( fp count +:= 1, -2 ), ":", whole( n, -4 )
, "! ", fp
OD
OD
END
</syntaxhighlight>
{{out}}
<pre>
Line 78 ⟶ 191:
10: 14! - 1 = 87178291199
</pre>
=={{header|ALGOL W}}==
Based on Algol 68, but using 64-bit floats as Algol W integers are 32-bit and so can't represent the 10th factorial prime.
<syntaxhighlight lang="algolw">
begin % find some factorial primes - primes that are f - 1 or f + 1 %
% for some factorial f %
% returns true if p is prime, false otherwise %
logical procedure isPrime ( integer value p ) ;
if p <= 1 or p rem 2 = 0 then p = 2
else begin
logical prime;
integer rootP, i;
prime := true;
i := 3;
rootP := entier( sqrt( p ) );
while i <= rootP and prime do begin
prime := p rem i not = 0;
i := i + 2
end;
prime
end isPrime ;
% returns true if p is prime, false otherwise %
logical procedure isPrimeLongReal ( long real value p ) ;
if p <= MAXINTEGER then begin
% p is small enough to test using integer arithmetic %
isPrime( entier( p ) )
end
else begin
% p is too large for integer primality testing %
logical prime;
integer rootP, i;
prime := true;
i := 2;
rootP := entier( longsqrt( p ) );
while i <= rootP and prime do begin
long real pOverI;
pOverI := p / i;
prime := roundToReal( pOverI ) not = pOverI;
i := if i < 3 then 3 else i + 2
end;
prime
end isPrime ;
begin
long real f;
integer fpCount, n;
fpCount := 0;
n := 0;
f := 1;
while fpCount < 10 do begin
long real fp;
string(1) fpOp;
n := n + 1;
f := f * n;
fpOp := "-";
for offset := -1 step 2 until 1 do begin
fp := f + offset;
if fp < MAXINTEGER then begin
if isPrime( entier( fp ) ) then begin
fpCount := fpCount + 1;
write( s_w := 0, i_w := 2, fpCount, ":" );
writeon( s_w := 0, i_w := 4, n, "! ", fpOp, " 1 = " );
writeon( s_w := 0, i_w := 1, entier( fp ) )
end if_isPrime__entier__fp
end
else if isPrimeLongReal( fp ) then begin
fpCount := fpCount + 1;
write( s_w := 0, i_w := 2, fpCount, ":" );
writeon( s_w := 0, i_w := 4, n, "! ", fpOp, " 1 = " );
writeon( r_format := "A", r_w := 1, r_d := 0, fp )
end if_isPrime__fp__isPrimeLongReal__fp ;
fpOp := "+"
end for_fp
end while_fpCount_lt_10
end
end.
</syntaxhighlight>
{{out}}
<pre>
1: 1! + 1 = 2
2: 2! + 1 = 3
3: 3! - 1 = 5
4: 3! + 1 = 7
5: 4! - 1 = 23
6: 6! - 1 = 719
7: 7! - 1 = 5039
8: 11! + 1 = 39916801
9: 12! - 1 = 479001599
10: 14! - 1 = 87178291199
</pre>
=={{header|Arturo}}==
<syntaxhighlight lang="arturo">found: 0
i: 1
while [found < 10][
fct: factorial i
if prime? dec fct [
found: found + 1
print [pad (to :string found) ++ ":" 4 (to :string i)++"! - 1 = " dec fct]
]
if prime? inc fct [
found: found + 1
print [pad (to :string found) ++ ":" 4 (to :string i)++"! + 1 = " inc fct]
]
i: i + 1
]</syntaxhighlight>
{{out}}
<pre> 1: 1! + 1 = 2
2: 2! + 1 = 3
3: 3! - 1 = 5
4: 3! + 1 = 7
5: 4! - 1 = 23
6: 6! - 1 = 719
7: 7! - 1 = 5039
8: 11! + 1 = 39916801
9: 12! - 1 = 479001599
10: 14! - 1 = 87178291199</pre>
=={{header|BASIC}}==
==={{header|BASIC256}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="basic">include "isprime.kbs"
include "factorial.kbs"
print "First 10 factorial primes:"
found = 0
i = 1
while found < 9
fct = factorial (i)
if isprime(fct-1) then
found += 1
print rjust(string(found),2); ": "; rjust(string(i),2); "! - 1 = "; fct-1
end if
if isprime(fct+1) then
found += 1
print rjust(string(found),2); ": "; rjust(string(i),2); "! + 1 = "; fct+1
end if
i += 1
end while
end</syntaxhighlight>
==={{header|Craft Basic}}===
<syntaxhighlight lang="basic">define found = 0, fct = 0, i = 1
do
if found < 10 then
let fct = factorial(i)
if prime(fct - 1) then
let found = found + 1
print found, ": ", i, "! - 1 = ", fct - 1
endif
if prime(fct + 1) then
let found = found + 1
print found, ": ", i, "! + 1 = ", fct + 1
endif
let i = i + 1
endif
wait
loop found < 10</syntaxhighlight>
==={{header|FreeBASIC}}===
<syntaxhighlight lang="vb">#include "isprime.bas"
#include "factorial.bas"
Print "First 10 factorial primes:"
Dim As Integer found = 0, i = 1
While found < 10
Dim As Integer fct = factorial (i)
If isprime(fct-1) Then
found += 1
Print Using "##: ##_! - 1 = &"; found; i; fct-1
End If
If isprime(fct+1) Then
found += 1
Print Using "##: ##_! + 1 = &"; found; i; fct+1
End If
i += 1
Wend
Sleep</syntaxhighlight>
{{out}}
<pre>First 10 factorial primes;
1: 1! + 1 = 2
2: 2! + 1 = 3
3: 3! - 1 = 5
4: 3! + 1 = 7
5: 4! - 1 = 23
6: 6! - 1 = 719
7: 7! - 1 = 5039
8: 11! + 1 = 39916801
9: 12! - 1 = 479001599
10: 14! - 1 = 87178291199</pre>
==={{header|Gambas}}===
<syntaxhighlight lang="vbnet">Public Sub Main()
Print "First 10 factorial primes:"
Dim found As Long = 0, i As Integer = 1
While found < 10 'más de 10 es ya BigInt
Dim fct As Long = factorial(i)
If isPrime(fct - 1) Then
found += 1
Print Format$(found, "##"); ": "; Format$(i, "##"); "! - 1 = "; fct - 1
End If
If isPrime(fct + 1) Then
found += 1
Print Format$(found, "##"); ": "; Format$(i, "##"); "! + 1 = "; fct + 1
End If
i += 1
Wend
End
Public Sub isPrime(ValorEval As Long) As Boolean
If ValorEval < 2 Then Return False
If ValorEval Mod 2 = 0 Then Return ValorEval = 2
If ValorEval Mod 3 = 0 Then Return ValorEval = 3
Dim d As Long = 5
While d * d <= ValorEval
If ValorEval Mod d = 0 Then Return False Else d += 2
Wend
Return True
End Function
Public Function factorial(num As Integer) As Long
Dim result As Long = 1
For i As Integer = 2 To num
result *= i
Next
Return result
End</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
==={{header|PureBasic}}===
<syntaxhighlight lang="vb">;XIncludeFile "isprime.pb"
;XIncludeFile "factorial.pb"
If OpenConsole()
PrintN("First 10 factorial primes:")
Define found.i = 0, i,i = 1, fct.i
While found < 10
fct = factorial (i)
If isprime(fct-1)
found + 1
PrintN(RSet(Str(found),2) + ": " + RSet(Str(i),2) + "! - 1 = " + Str(fct-1))
EndIf
If isprime(fct+1)
found + 1
PrintN(RSet(Str(found),2) + ": " + RSet(Str(i),2) + "! + 1 = " + Str(fct+1))
EndIf
i + 1
Wend
PrintN(#CRLF$ + "--- terminado, pulsa RETURN---"): Input()
CloseConsole()
EndIf</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
==={{header|Run BASIC}}===
<syntaxhighlight lang="vb">function isPrime(n)
if n < 2 then isPrime = 0 : goto [exit]
if n = 2 then isPrime = 1 : goto [exit]
if n mod 2 = 0 then isPrime = 0 : goto [exit]
isPrime = 1
for i = 3 to int(n^.5) step 2
if n mod i = 0 then isPrime = 0 : goto [exit]
next i
[exit]
end function
function factorial(n)
factorial = 1
if n > 1 then factorial = n * factorial(n -1)
end function
print "First 10 factorial primes:"
found = 0
i = 1
while found < 10
fct = factorial(i)
if isPrime(fct-1) then
found = found + 1
print using("##", found); ": "; using("##", i); "! - 1 = "; fct-1
end if
if isPrime(fct+1) then
found = found + 1
print using("##", found); ": "; using("##", i); "! + 1 = "; fct+1
end if
i = i + 1
wend</syntaxhighlight>
==={{header|Yabasic}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="basic">import isprime
import factorial
print "First 10 factorial primes:"
found = 0
i = 1
while found < 10
fct = factorial (i)
if isPrime(fct-1) then
found = found + 1
print found using("##"), ": ", i using("##"), "! - 1 = ", fct-1
fi
if isPrime(fct+1) then
found = found + 1
print found using("##"), ": ", i using("##"), "! + 1 = ", fct+1
fi
i = i + 1
end while</syntaxhighlight>
=={{header|C++}}==
<syntaxhighlight lang="cpp">#include <iomanip>
#include <iostream>
#include <gmpxx.h>
using big_int = mpz_class;
std::string to_string(const big_int& num, size_t max_digits) {
std::string str = num.get_str();
size_t len = str.size();
if (len > max_digits) {
str.replace(max_digits / 2, len - max_digits, "...");
str += " (";
str += std::to_string(len);
str += " digits)";
}
return str;
}
bool is_probably_prime(const big_int& n) {
return mpz_probab_prime_p(n.get_mpz_t(), 25) != 0;
}
int main() {
big_int f = 1;
for (int i = 0, n = 1; i < 31; ++n) {
f *= n;
if (is_probably_prime(f - 1)) {
++i;
std::cout << std::setw(2) << i << ": " << std::setw(3) << n
<< "! - 1 = " << to_string(f - 1, 40) << '\n';
}
if (is_probably_prime(f + 1)) {
++i;
std::cout << std::setw(2) << i << ": " << std::setw(3) << n
<< "! + 1 = " << to_string(f + 1, 40) << '\n';
}
}
}</syntaxhighlight>
{{out}}
<pre>
1: 1! + 1 = 2
2: 2! + 1 = 3
3: 3! - 1 = 5
4: 3! + 1 = 7
5: 4! - 1 = 23
6: 6! - 1 = 719
7: 7! - 1 = 5039
8: 11! + 1 = 39916801
9: 12! - 1 = 479001599
10: 14! - 1 = 87178291199
11: 27! + 1 = 10888869450418352160768000001
12: 30! - 1 = 265252859812191058636308479999999
13: 32! - 1 = 263130836933693530167218012159999999
14: 33! - 1 = 8683317618811886495518194401279999999
15: 37! + 1 = 13763753091226345046...79581580902400000001 (44 digits)
16: 38! - 1 = 52302261746660111176...24100074291199999999 (45 digits)
17: 41! + 1 = 33452526613163807108...40751665152000000001 (50 digits)
18: 73! + 1 = 44701154615126843408...03680000000000000001 (106 digits)
19: 77! + 1 = 14518309202828586963...48000000000000000001 (114 digits)
20: 94! - 1 = 10873661566567430802...99999999999999999999 (147 digits)
21: 116! + 1 = 33931086844518982011...00000000000000000001 (191 digits)
22: 154! + 1 = 30897696138473508879...00000000000000000001 (272 digits)
23: 166! - 1 = 90036917057784373664...99999999999999999999 (298 digits)
24: 320! + 1 = 21161033472192524829...00000000000000000001 (665 digits)
25: 324! - 1 = 22889974601791023211...99999999999999999999 (675 digits)
26: 340! + 1 = 51008644721037110809...00000000000000000001 (715 digits)
27: 379! - 1 = 24840307460964707050...99999999999999999999 (815 digits)
28: 399! + 1 = 16008630711655973815...00000000000000000001 (867 digits)
29: 427! + 1 = 29063471769607348411...00000000000000000001 (940 digits)
30: 469! - 1 = 67718096668149510900...99999999999999999999 (1051 digits)
31: 546! - 1 = 14130200926141832545...99999999999999999999 (1260 digits)
</pre>
=={{header|Common Lisp}}==
Simple implementation without using advanced primality testing.
<syntaxhighlight lang="lisp">
(defun factorial (x)
(if (= x 1)
x
(* x (factorial (- x 1)))))
(defun is-factor (x y)
(zerop (mod x y)))
(defun is-prime (n)
(cond ((< n 4) (or (= n 2) (= n 3)))
((or (zerop (mod n 2)) (zerop (mod n 3))) nil)
(t (loop for i from 5 to (floor (sqrt n)) by 6
never (or (is-factor n i)
(is-factor n (+ i 2)))))))
(defun main (&optional (limit 10))
(let ((n 0)
(f 0))
(loop while (< n limit)
for i from 1
do (setf f (factorial i))
(when (is-prime (+ f 1))
(incf n)
(format t "~2d: ~2d! + 1 = ~12d~%" n i (+ f 1)))
(when (is-prime (- f 1))
(incf n)
(format t "~2d: ~2d! - 1 = ~12d~%" n i (- f 1))))))
</syntaxhighlight>
{{out}}
<pre>
1: 1! + 1 = 2
2: 2! + 1 = 3
3: 3! + 1 = 7
4: 3! - 1 = 5
5: 4! - 1 = 23
6: 6! - 1 = 719
7: 7! - 1 = 5039
8: 11! + 1 = 39916801
9: 12! - 1 = 479001599
10: 14! - 1 = 87178291199
</pre>
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
<syntaxhighlight lang="Delphi">
function IsPrime(N: int64): boolean;
{Optimised prime test - about 40% faster than the naive approach}
var I,Stop: integer;
begin
if (N = 2) or (N=3) then Result:=true
else if (n <= 1) or ((n mod 2) = 0) or ((n mod 3) = 0) then Result:= false
else
begin
I:=5;
Stop:=Trunc(sqrt(N*1.0));
Result:=False;
while I<=Stop do
begin
if ((N mod I) = 0) or ((N mod (i + 2)) = 0) then exit;
Inc(I,6);
end;
Result:=True;
end;
end;
function Factorial(N: Word): int64;
var I: integer;
begin
Result:= 1;
for I := 2 to N do Result:=Result * I;
end;
procedure ShowFactorialPrimes(Memo: TMemo);
{Show factorials where F+1 or F-1 are prime}
var I,Cnt: integer;
var F: int64;
procedure DisplayItem(Minus: boolean);
var S: string;
var Sign: char;
var F1: int64;
begin
Inc(Cnt);
if Minus then F1:=F-1 else F1:=F+1;
if Minus then Sign:='-' else Sign:='+';
S:=Format('%2d: %3d! %s 1 = %d',[Cnt,I,Sign,F1]);
Memo.Lines.Add(S);
end;
begin
Cnt:=0;
for I:=1 to High(Integer) do
begin
F:=Factorial(I);
if IsPrime(F+1) then DisplayItem(False);
if IsPrime(F-1) then DisplayItem(True);
if Cnt>=10 then break;
end;
end;
</syntaxhighlight>
{{out}}
<pre>
1: 1! + 1 = 2
2: 2! + 1 = 3
3: 3! + 1 = 7
4: 3! - 1 = 5
5: 4! - 1 = 23
6: 6! - 1 = 719
7: 7! - 1 = 5039
8: 11! + 1 = 39916801
9: 12! - 1 = 479001599
10: 14! - 1 = 87178291199
</pre>
=={{header|EasyLang}}==
{{trans|Lua}}
<syntaxhighlight lang=text>
func isprim num .
if num < 2
return 0
.
i = 2
while i <= sqrt num
if num mod i = 0
return 0
.
i += 1
.
return 1
.
f = 1
while count < 10
n += 1
f *= n
op$ = "-"
for fp in [ f - 1 f + 1 ]
if isprim fp = 1
count += 1
print n & "! " & op$ & " 1 = " & fp
.
op$ = "+"
.
.
</syntaxhighlight>
=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">
// Factorial primes. Nigel Galloway: August 15th., 2022
let fN g=if Open.Numeric.Primes.MillerRabin.IsProbablePrime &g then Some(g) else None
let fp()=let rec fG n g=seq{let n=n*g in yield (fN(n-1I),-1,g); yield (fN(n+1I),1,g); yield! fG n (g+1I)} in fG 1I 1I|>Seq.filter(fun(n,_,_)->Option.isSome n)
fp()|>Seq.iteri(fun i (n,g,l)->printfn $"""%2d{i+1}: %3d{int l}!%+d{g} -> %s{let n=string(Option.get n) in if n.Length<41 then n else n[0..19]+".."+n[n.Length-20..]+" ["+string(n.Length)+" digits]"}""")
</syntaxhighlight>
{{out}}
<pre>
1: 1!+1 -> 2
2: 2!+1 -> 3
3: 3!-1 -> 5
4: 3!+1 -> 7
5: 4!-1 -> 23
6: 6!-1 -> 719
7: 7!-1 -> 5039
8: 11!+1 -> 39916801
9: 12!-1 -> 479001599
10: 14!-1 -> 87178291199
11: 27!+1 -> 10888869450418352160768000001
12: 30!-1 -> 265252859812191058636308479999999
13: 32!-1 -> 263130836933693530167218012159999999
14: 33!-1 -> 8683317618811886495518194401279999999
15: 37!+1 -> 13763753091226345046..79581580902400000001 [44 digits]
16: 38!-1 -> 52302261746660111176..24100074291199999999 [45 digits]
17: 41!+1 -> 33452526613163807108..40751665152000000001 [50 digits]
18: 73!+1 -> 44701154615126843408..03680000000000000001 [106 digits]
19: 77!+1 -> 14518309202828586963..48000000000000000001 [114 digits]
20: 94!-1 -> 10873661566567430802..99999999999999999999 [147 digits]
21: 116!+1 -> 33931086844518982011..00000000000000000001 [191 digits]
22: 154!+1 -> 30897696138473508879..00000000000000000001 [272 digits]
23: 166!-1 -> 90036917057784373664..99999999999999999999 [298 digits]
24: 320!+1 -> 21161033472192524829..00000000000000000001 [665 digits]
25: 324!-1 -> 22889974601791023211..99999999999999999999 [675 digits]
26: 340!+1 -> 51008644721037110809..00000000000000000001 [715 digits]
27: 379!-1 -> 24840307460964707050..99999999999999999999 [815 digits]
28: 399!+1 -> 16008630711655973815..00000000000000000001 [867 digits]
29: 427!+1 -> 29063471769607348411..00000000000000000001 [940 digits]
30: 469!-1 -> 67718096668149510900..99999999999999999999 [1051 digits]
31: 546!-1 -> 14130200926141832545..99999999999999999999 [1260 digits]
</pre>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
include "NSLog.incl"
local fn Factorial( n as NSUInteger ) as NSUInteger
NSUInteger factorial = 1
if n > 1 then factorial = n * fn Factorial( n -1 )
end fn = factorial
local fn IsPrime( n as NSUInteger ) as BOOL
BOOL isPrime = YES
NSUInteger i
if n < 2 then exit fn = NO
if n = 2 then exit fn = YES
if n mod 2 == 0 then exit fn = NO
for i = 3 to int(n^.5) step 2
if n mod i == 0 then exit fn = NO
next
end fn = isPrime
void local fn FactorialPrimes( n as long )
NSUInteger found = 0, i = 1
NSLog( @"First %lu factorial primes:", n )
while ( found < n )
NSUInteger fct = fn Factorial( i )
if ( fn IsPrime( fct - 1 ) )
found++
NSLog( @"%2lu: %3lu! - 1 = %-lu", found, i, fct - 1 )
end if
if ( fn IsPrime( fct + 1 ) )
found++
NSLog( @"%2lu: %3lu! + 1 = %-lu", found, i, fct + 1 )
end if
i++
wend
end fn
fn FactorialPrimes( 10 )
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
First 10 factorial primes:
1: 1! + 1 = 2
2: 2! + 1 = 3
3: 3! - 1 = 5
4: 3! + 1 = 7
5: 4! - 1 = 23
6: 6! - 1 = 719
7: 7! - 1 = 5039
8: 11! + 1 = 39916801
9: 12! - 1 = 479001599
10: 14! - 1 = 87178291199
</pre>
=={{header|J}}==
<syntaxhighlight lang="j"> (,. (-!)/"1)1>.(,. >.@(!inv)@<:) (#~ 1 p: ]) ~.,(!i.27x)+/1 _1
2 1 1
3 2 1
7 3 1
5 3 _1
23 4 _1
719 6 _1
5039 7 _1
39916801 11 1
479001599 12 _1
87178291199 14 _1</syntaxhighlight>
(i.28x here would have given us an eleventh prime, but the task asked for the first 10, and the stretch goal requires considerable patience.)
=={{header|Java}}==
[[User:Sjharper79|Sjharper79]] ([[User talk:Sjharper79|talk]])
<syntaxhighlight lang="java">
public class MainApp {
public static void main(String[] args) {
int countOfPrimes = 0;
final int targetCountOfPrimes = 10;
long f = 1;
while (countOfPrimes < targetCountOfPrimes) {
long factorialNum = getFactorial(f);
boolean primePlus = isPrime(factorialNum + 1);
boolean primeMinus = isPrime(factorialNum - 1);
if (primeMinus) {
countOfPrimes++;
System.out.println(countOfPrimes + ": " + factorialNum + "! - 1 = " + (factorialNum - 1));
}
if (primePlus && f > 1) {
countOfPrimes++;
System.out.println(countOfPrimes + ": " + factorialNum + "! + 1 = " + (factorialNum + 1));
}
f++;
}
}
private static long getFactorial(long f) {
long factorial = 1;
for (long i = 1; i < f; i++) {
factorial *= i;
}
return factorial;
}
private static boolean isPrime(long num) {
if (num < 2) {return false;}
for (long i = 2; i < num; i++) {
if (num % i == 0) {return false;}
}
return true;
}
}
</syntaxhighlight>
Results
<pre>
1: 1! + 1 = 2
2: 2! + 1 = 3
3: 6! - 1 = 5
4: 6! + 1 = 7
5: 24! - 1 = 23
6: 720! - 1 = 719
7: 5040! - 1 = 5039
8: 39916800! + 1 = 39916801
9: 479001600! - 1 = 479001599
10: 87178291200! - 1 = 87178291199
</pre>
=== Another Way with BigIntegers ===
<syntaxhighlight lang=java>
import java.math.BigInteger;
public class MainApp {
public static void main(String[] args) {
//Used to measure total runtime of program.
long starttime = System.nanoTime();
//How many primes found, how many primes wanted, loop counter.
int countOfPrimes = 0;
final int targetCountOfPrimes = 30;
long f = 1;
//Starting BigInteger at 1.
BigInteger biFactorial = BigInteger.ONE;
while (countOfPrimes < targetCountOfPrimes) {
//Each loop, multiply the number by the loop
//counter (f) to increase factorial much more quickly.
biFactorial = biFactorial.multiply(BigInteger.valueOf(f));
// one less than the factorial.
BigInteger biMinusOne = biFactorial.subtract(BigInteger.ONE);
// one more than the factorial.
BigInteger biPlusOne = biFactorial.add(BigInteger.ONE);
//Determine if the numbers are prime with a probability of 100
boolean primeMinus = biMinusOne.isProbablePrime(100);
boolean primePlus = biPlusOne.isProbablePrime(100);
//Make the big number look like a pretty string for output.
String biMinusOneString = convert(biMinusOne);
String biPlusOneString = convert(biPlusOne);
//If the number was prime, output and increment the primt counter.
if (primeMinus) {
countOfPrimes++;
System.out.println(
countOfPrimes + ": " + f + "! - 1 = " + biMinusOneString);
}
if (primePlus) {
countOfPrimes++;
System.out.println(countOfPrimes + ": " + f + "! + 1 = " + biPlusOneString);
}
//Increment loop counter.
f++;
}
//Calculate and display program runtime.
long stoptime = System.nanoTime();
long runtime = stoptime - starttime;
System.out.println("Program runtime: " + runtime + " ns (~" + runtime/1_000_000_000 + " seconds)");
}
//Method to make output pretty
private static String convert(BigInteger bi) {
String s = bi.toString();
int l = s.length();
String s2 = "";
if (l >= 40) {
s2 = s.substring(0, 19);
s2 += "..." + s.substring(s.length() - 20, s.length());
s2 += " : " + l + " digits";
} else {s2 = s;}
return s2;
}
}
</syntaxhighlight>
===output===
<pre>
1: 1! + 1 = 2
2: 2! + 1 = 3
3: 3! - 1 = 5
4: 3! + 1 = 7
5: 4! - 1 = 23
6: 6! - 1 = 719
7: 7! - 1 = 5039
8: 11! + 1 = 39916801
9: 12! - 1 = 479001599
10: 14! - 1 = 87178291199
11: 27! + 1 = 10888869450418352160768000001
12: 30! - 1 = 265252859812191058636308479999999
13: 32! - 1 = 263130836933693530167218012159999999
14: 33! - 1 = 8683317618811886495518194401279999999
15: 37! + 1 = 1376375309122634504...79581580902400000001 : 44 digits
16: 38! - 1 = 5230226174666011117...24100074291199999999 : 45 digits
17: 41! + 1 = 3345252661316380710...40751665152000000001 : 50 digits
18: 73! + 1 = 4470115461512684340...03680000000000000001 : 106 digits
19: 77! + 1 = 1451830920282858696...48000000000000000001 : 114 digits
20: 94! - 1 = 1087366156656743080...99999999999999999999 : 147 digits
21: 116! + 1 = 3393108684451898201...00000000000000000001 : 191 digits
22: 154! + 1 = 3089769613847350887...00000000000000000001 : 272 digits
23: 166! - 1 = 9003691705778437366...99999999999999999999 : 298 digits
24: 320! + 1 = 2116103347219252482...00000000000000000001 : 665 digits
25: 324! - 1 = 2288997460179102321...99999999999999999999 : 675 digits
26: 340! + 1 = 5100864472103711080...00000000000000000001 : 715 digits
27: 379! - 1 = 2484030746096470705...99999999999999999999 : 815 digits
28: 399! + 1 = 1600863071165597381...00000000000000000001 : 867 digits
29: 427! + 1 = 2906347176960734841...00000000000000000001 : 940 digits
30: 469! - 1 = 6771809666814951090...99999999999999999999 : 1051 digits
Program runtime: 6084297200 ns (~6 seconds)
</pre>
=={{header|jq}}==
The following jq program has been tested with both the C and Go implementations
of jq. The latter supports unbounded-precision arithmetic, but the former
has sufficient accuracy to compute the first 10 factorial primes.
However, the implementation of `is_prime` used here is not sufficiently
fast to compute more than the first 10 factorial primes in a reasonable amount of time.
<syntaxhighlight lang="jq">
# The algorithm is quite fast because the state of `until` is just a number and we skip by 2 or 4
def is_prime:
. as $n
| if ($n < 2) then false
elif ($n % 2 == 0) then $n == 2
elif ($n % 3 == 0) then $n == 3
else 5
| until( . <= 0;
if .*. > $n then -1
elif ($n % . == 0) then 0
else . + 2
| if ($n % . == 0) then 0
else . + 4
end
end)
| . == -1
end;
def factorial_primes:
foreach range(1; infinite) as $i (1; . * $i;
if ((.-1) | is_prime) then [($i|tostring) + "! - 1 = ", .-1] else empty end,
if ((.+1) | is_prime) then [($i|tostring) + "! + 1 = ", .+1] else empty end ) ;
limit(20; factorial_primes)
| .[1] |= (tostring | (if length > 40 then .[:20] + " .. " + .[-20:] else . end))
| add
</syntaxhighlight>
Invocation: jq -nr -f factorial-primes.jq
{{output}}
<pre>
1! + 1 = 2
2! + 1 = 3
3! - 1 = 5
3! + 1 = 7
4! - 1 = 23
6! - 1 = 719
7! - 1 = 5039
11! + 1 = 39916801
12! - 1 = 479001599
14! - 1 = 87178291199
# terminated
</pre>
=={{header|Julia}}==
<syntaxhighlight lang="julia">using Primes
limitedprint(n) = (s = string(n); n = length(s); return n <= 40 ? s : s[1:20] * "..." * s[end-19:end] * " ($n digits)")
function showfactorialprimes(N)
for i in big"1":N
f = factorial(i)
isprime(f - 1) && println(lpad(i, 3), "! - 1 -> ", limitedprint(f - 1))
isprime(f + 1) && println(lpad(i, 3), "! + 1 -> ", limitedprint(f + 1))
end
end
showfactorialprimes(1000)
</syntaxhighlight>{{out}}
<pre>
1! + 1 -> 2
2! + 1 -> 3
3! - 1 -> 5
3! + 1 -> 7
4! - 1 -> 23
6! - 1 -> 719
7! - 1 -> 5039
11! + 1 -> 39916801
12! - 1 -> 479001599
14! - 1 -> 87178291199
27! + 1 -> 10888869450418352160768000001
30! - 1 -> 265252859812191058636308479999999
32! - 1 -> 263130836933693530167218012159999999
33! - 1 -> 8683317618811886495518194401279999999
37! + 1 -> 13763753091226345046...79581580902400000001 (44 digits)
38! - 1 -> 52302261746660111176...24100074291199999999 (45 digits)
41! + 1 -> 33452526613163807108...40751665152000000001 (50 digits)
73! + 1 -> 44701154615126843408...03680000000000000001 (106 digits)
77! + 1 -> 14518309202828586963...48000000000000000001 (114 digits)
94! - 1 -> 10873661566567430802...99999999999999999999 (147 digits)
116! + 1 -> 33931086844518982011...00000000000000000001 (191 digits)
154! + 1 -> 30897696138473508879...00000000000000000001 (272 digits)
166! - 1 -> 90036917057784373664...99999999999999999999 (298 digits)
320! + 1 -> 21161033472192524829...00000000000000000001 (665 digits)
324! - 1 -> 22889974601791023211...99999999999999999999 (675 digits)
340! + 1 -> 51008644721037110809...00000000000000000001 (715 digits)
379! - 1 -> 24840307460964707050...99999999999999999999 (815 digits)
399! + 1 -> 16008630711655973815...00000000000000000001 (867 digits)
427! + 1 -> 29063471769607348411...00000000000000000001 (940 digits)
469! - 1 -> 67718096668149510900...99999999999999999999 (1051 digits)
546! - 1 -> 14130200926141832545...99999999999999999999 (1260 digits)
872! + 1 -> 19723152008295244962...00000000000000000001 (2188 digits)
974! - 1 -> 55847687633820181096...99999999999999999999 (2490 digits)
</pre>
=={{header|Kotlin}}==
Similar to Java implementation, but using Kotlin's String templates, overloaded BigInteger operators and an extension function to make the code easier to read:
<syntaxhighlight lang="kotlin">
import java.math.BigInteger
import java.math.BigInteger.ONE
enum class Difference(private val displayText: String) {
MINUS_ONE("- 1"), PLUS_ONE("+ 1");
override fun toString(): String {
return displayText
}
}
fun main() {
var currentFactorial = ONE
var highestFactor = 1L
var found = 0
while(found < 30) {
if ((currentFactorial - ONE).isProbablePrime(25)) {
printlnFactorialPrime(currentFactorial - ONE, highestFactor, Difference.MINUS_ONE)
found++
}
if ((currentFactorial + ONE).isProbablePrime(25)) {
printlnFactorialPrime(currentFactorial + ONE, highestFactor, Difference.PLUS_ONE)
found++
}
highestFactor++
currentFactorial *= BigInteger.valueOf(highestFactor)
}
}
fun printlnFactorialPrime(factorialPrime: BigInteger, base: Long, difference: Difference) =
println("${base}! $difference = ${factorialPrime.shortenIfNecessary()}")
fun BigInteger.shortenIfNecessary(): String {
val digits = toString()
val length = digits.length
return if (length <= 40) {
digits
} else {
"${digits.take(20)}...${digits.takeLast(20)} ($length digits)"
}
}
</syntaxhighlight>{{out}}
<pre>
1! + 1 = 2
2! + 1 = 3
3! - 1 = 5
3! + 1 = 7
4! - 1 = 23
6! - 1 = 719
7! - 1 = 5039
11! + 1 = 39916801
12! - 1 = 479001599
14! - 1 = 87178291199
27! + 1 = 10888869450418352160768000001
30! - 1 = 265252859812191058636308479999999
32! - 1 = 263130836933693530167218012159999999
33! - 1 = 8683317618811886495518194401279999999
37! + 1 = 13763753091226345046...79581580902400000001 (44 digits)
38! - 1 = 52302261746660111176...24100074291199999999 (45 digits)
41! + 1 = 33452526613163807108...40751665152000000001 (50 digits)
73! + 1 = 44701154615126843408...03680000000000000001 (106 digits)
77! + 1 = 14518309202828586963...48000000000000000001 (114 digits)
94! - 1 = 10873661566567430802...99999999999999999999 (147 digits)
116! + 1 = 33931086844518982011...00000000000000000001 (191 digits)
154! + 1 = 30897696138473508879...00000000000000000001 (272 digits)
166! - 1 = 90036917057784373664...99999999999999999999 (298 digits)
320! + 1 = 21161033472192524829...00000000000000000001 (665 digits)
324! - 1 = 22889974601791023211...99999999999999999999 (675 digits)
340! + 1 = 51008644721037110809...00000000000000000001 (715 digits)
379! - 1 = 24840307460964707050...99999999999999999999 (815 digits)
399! + 1 = 16008630711655973815...00000000000000000001 (867 digits)
427! + 1 = 29063471769607348411...00000000000000000001 (940 digits)
469! - 1 = 67718096668149510900...99999999999999999999 (1051 digits)
</pre>
=={{header|LOLCODE}}==
Basic task, based on the Algol 68 sample.
<syntaxhighlight lang="lolcode">OBTW find some factorial primes - primes that are f - 1 or f + 1
for some factorial f
TLDR
HAI 1.3
HOW IZ I TESTIN YR P BTW PRIMALITY TEST WITH TRIAL DIVISHUN
DIFFRINT 3 AN SMALLR OF 3 AN P, O RLY?
YA RLY
FOUND YR BOTH SAEM P AN 2
MEBBE BOTH SAEM 0 AN MOD OF P AN 2
FOUND YR FAIL
NO WAI
I HAS A IZPRIME ITZ WIN
I HAS A N ITZ 3
I HAS A NSKWARED ITZ 9
IM IN YR PRIMELOOP UPPIN YR I TIL DIFFRINT NSKWARED AN SMALLR OF P AN NSKWARED
DIFFRINT 0 AN MOD OF P AN N, O RLY?
YA RLY
N R SUM OF N AN 2
NSKWARED R PRODUKT OF N AN N
NO WAI
IZPRIME R FAIL
NSKWARED R SUM OF P AN 1
OIC
IM OUTTA YR PRIMELOOP
FOUND YR IZPRIME
OIC
IF U SAY SO
HOW IZ I PADDIN YR FPNUMBR
I HAS A PAD ITZ ""
BOTH SAEM FPNUMBR AN SMALLR OF FPNUMBR AN 9, O RLY?
YA RLY
PAD R " "
OIC
FOUND YR SMOOSH PAD AN FPNUMBR MKAY
IF U SAY SO
HOW IZ I SHOWIN YR FPNUMBR AN YR N AN YR HOWDIFF AN YR FP
VISIBLE SMOOSH I IZ PADDIN YR FPNUMBR MKAY ...
AN ":: " AN I IZ PADDIN YR N MKAY ...
AN "! " AN HOWDIFF AN " 1 = " AN FP ...
MKAY
IF U SAY SO
I HAS A F ITZ 1
I HAS A N ITZ 0
I HAS A KOWNT ITZ 0
IM IN YR FPLOOP UPPIN YR I TIL BOTH SAEM KOWNT AN 10
N R SUM OF N AN 1
F R PRODUKT OF F AN N
I IZ TESTIN YR DIFF OF F AN 1 MKAY, O RLY?
YA RLY
KOWNT R SUM OF KOWNT AN 1
I IZ SHOWIN YR KOWNT AN YR N AN YR "-" AN YR DIFF OF F AN 1 MKAY
OIC
I IZ TESTIN YR SUM OF F AN 1 MKAY, O RLY?
YA RLY
KOWNT R SUM OF KOWNT AN 1
I IZ SHOWIN YR KOWNT AN YR N AN YR "+" AN YR SUM OF F AN 1 MKAY
OIC
IM OUTTA YR FPLOOP
KTHXBYE
</syntaxhighlight>
{{out}}
<pre>
1: 1! + 1 = 2
2: 2! + 1 = 3
3: 3! - 1 = 5
4: 3! + 1 = 7
5: 4! - 1 = 23
6: 6! - 1 = 719
7: 7! - 1 = 5039
8: 11! + 1 = 39916801
9: 12! - 1 = 479001599
10: 14! - 1 = 87178291199
</pre>
=={{header|Lua}}==
{{Trans|ALGOL 68}}
<syntaxhighlight lang="lua">
do -- find some factorial primes - primes that are f - 1 or f + 1
-- for some factorial f
function isPrime( p )
if p <= 1 or p % 2 == 0 then
return p == 2
else
local prime = true
local i = 3
local rootP = math.floor( math.sqrt( p ) )
while i <= rootP and prime do
prime = p % i ~= 0
i = i + 2
end
return prime
end
end
local f = 1
local fpCount = 0
local n = 0
local fpOp = ""
while fpCount < 10 do
n = n + 1
f = f * n
fpOp = "-"
for fp = f - 1, f + 1, 2 do
if isPrime( fp ) then
fpCount = fpCount + 1
io.write( string.format( "%2d", fpCount ), ":"
, string.format( "%4d", n ), "! "
, fpOp, " 1 = ", fp, "\n"
)
end
fpOp = "+"
end
end
end
</syntaxhighlight>
{{out}}
<pre>
1: 1! + 1 = 2
2: 2! + 1 = 3
3: 3! - 1 = 5
4: 3! + 1 = 7
5: 4! - 1 = 23
6: 6! - 1 = 719
7: 7! - 1 = 5039
8: 11! + 1 = 39916801
9: 12! - 1 = 479001599
10: 14! - 1 = 87178291199
</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
{{trans|Julia}}
<syntaxhighlight lang="Mathematica">
LimitedPrint[n_] := Module[{s = IntegerString[n], len},
len = StringLength[s];
If[len <= 40, s, StringJoin[StringTake[s, 20], "...", StringTake[s, -20], " (", ToString[len], " digits)"]]
]
ShowFactorialPrimes[N_] := Module[{f},
Do[
f = Factorial[i];
If[PrimeQ[f - 1], Print[IntegerString[i, 10, 3], "! - 1 -> ", LimitedPrint[f - 1]]];
If[PrimeQ[f + 1], Print[IntegerString[i, 10, 3], "! + 1 -> ", LimitedPrint[f + 1]]],
{i, 1, N}
]
]
ShowFactorialPrimes[1000]
</syntaxhighlight>
{{out}}
<pre>
001! + 1 -> 2
002! + 1 -> 3
003! - 1 -> 5
003! + 1 -> 7
004! - 1 -> 23
006! - 1 -> 719
007! - 1 -> 5039
011! + 1 -> 39916801
012! - 1 -> 479001599
014! - 1 -> 87178291199
027! + 1 -> 10888869450418352160768000001
030! - 1 -> 265252859812191058636308479999999
032! - 1 -> 263130836933693530167218012159999999
033! - 1 -> 8683317618811886495518194401279999999
037! + 1 -> 13763753091226345046...79581580902400000001 (44 digits)
038! - 1 -> 52302261746660111176...24100074291199999999 (45 digits)
041! + 1 -> 33452526613163807108...40751665152000000001 (50 digits)
073! + 1 -> 44701154615126843408...03680000000000000001 (106 digits)
077! + 1 -> 14518309202828586963...48000000000000000001 (114 digits)
094! - 1 -> 10873661566567430802...99999999999999999999 (147 digits)
116! + 1 -> 33931086844518982011...00000000000000000001 (191 digits)
154! + 1 -> 30897696138473508879...00000000000000000001 (272 digits)
166! - 1 -> 90036917057784373664...99999999999999999999 (298 digits)
320! + 1 -> 21161033472192524829...00000000000000000001 (665 digits)
324! - 1 -> 22889974601791023211...99999999999999999999 (675 digits)
340! + 1 -> 51008644721037110809...00000000000000000001 (715 digits)
379! - 1 -> 24840307460964707050...99999999999999999999 (815 digits)
399! + 1 -> 16008630711655973815...00000000000000000001 (867 digits)
427! + 1 -> 29063471769607348411...00000000000000000001 (940 digits)
469! - 1 -> 67718096668149510900...99999999999999999999 (1051 digits)
546! - 1 -> 14130200926141832545...99999999999999999999 (1260 digits)
872! + 1 -> 19723152008295244962...00000000000000000001 (2188 digits)
974! - 1 -> 55847687633820181096...99999999999999999999 (2490 digits)
</pre>
=={{header|Maxima}}==
<syntaxhighlight lang="maxima">
block([i:1,count:0,result:[]],
while count<10 do (if primep(i!-1) or primep(i!+1) then (result:endcons(i,result),count:count+1),i:i+1),
result:map(lambda([x],[x,x!-1,x!+1]),result),
append(map(lambda([x],if primep(x[2]) then [x[1],x[2],"subtracted"]),result),map(lambda([x],if primep(x[3]) then [x[1],x[3],"added"]),result)),
unique(%%),
firstn(%%,10);
</syntaxhighlight>
{{out}}
<pre>
[[1,2,"added"],[2,3,"added"],[3,5,"subtracted"],[3,7,"added"],[4,23,"subtracted"],[6,719,"subtracted"],[7,5039,"subtracted"],[11,39916801,"added"],[12,479001599,"subtracted"],[14,87178291199,"subtracted"]]
</pre>
=={{header|Nim}}==
{{libheader|Nim-Integers}}
Nim standard integer types are limited to 64 bits. So we use an external library which provides arbitrary sized integers.
<syntaxhighlight lang="nim">import std/[math, strformat]
# Task.
func isPrime(n: int): bool =
if n < 2: return false
if n == 2 or n == 3: return true
if n mod 2 == 0: return false
if n mod 3 == 0: return false
var d = 5
var step = 2
while d * d <= n:
if n mod d == 0:
return false
inc d, step
step = 6 - step
return true
echo "First 10 factorial primes:\n"
var count = 0
var n = 1
while count < 10:
let f = fac(n)
if isPrime(f - 1):
inc count
echo &"{count:>2}: {n:>3}! - 1 = {f - 1}"
if count < 10 and isPrime(f + 1):
inc count
echo &"{count:>2}: {n:>3}! + 1 = {f + 1}"
inc n
# Stretch.
import integers
func str(n: Integer): string =
## Return the string representation of an Integer.
result = $n
if result.len > 40:
result = &"{result[0..19]}...{result[^20..^1]} ({result.len} digits)"
echo "\n\nNext 20 factorial primes:\n"
while count < 30:
let f: Integer = factorial(n)
if isPrime(f - 1):
inc count
echo &"{count:>2}: {n:>3}! - 1 = {str(f - 1)}"
if isPrime(f + 1):
inc count
echo &"{count:>2}: {n:>3}! - 1 = {str(f + 1)}"
inc n
</syntaxhighlight>
{{out}}
<pre>First 10 factorial primes:
1: 1! + 1 = 2
2: 2! + 1 = 3
3: 3! - 1 = 5
4: 3! + 1 = 7
5: 4! - 1 = 23
6: 6! - 1 = 719
7: 7! - 1 = 5039
8: 11! + 1 = 39916801
9: 12! - 1 = 479001599
10: 14! - 1 = 87178291199
Next 20 factorial primes:
11: 27! - 1 = 10888869450418352160768000001
12: 30! - 1 = 265252859812191058636308479999999
13: 32! - 1 = 263130836933693530167218012159999999
14: 33! - 1 = 8683317618811886495518194401279999999
15: 37! - 1 = 13763753091226345046...79581580902400000001 (44 digits)
16: 38! - 1 = 52302261746660111176...24100074291199999999 (45 digits)
17: 41! - 1 = 33452526613163807108...40751665152000000001 (50 digits)
18: 73! - 1 = 44701154615126843408...03680000000000000001 (106 digits)
19: 77! - 1 = 14518309202828586963...48000000000000000001 (114 digits)
20: 94! - 1 = 10873661566567430802...99999999999999999999 (147 digits)
21: 116! - 1 = 33931086844518982011...00000000000000000001 (191 digits)
22: 154! - 1 = 30897696138473508879...00000000000000000001 (272 digits)
23: 166! - 1 = 90036917057784373664...99999999999999999999 (298 digits)
24: 320! - 1 = 21161033472192524829...00000000000000000001 (665 digits)
25: 324! - 1 = 22889974601791023211...99999999999999999999 (675 digits)
26: 340! - 1 = 51008644721037110809...00000000000000000001 (715 digits)
27: 379! - 1 = 24840307460964707050...99999999999999999999 (815 digits)
28: 399! - 1 = 16008630711655973815...00000000000000000001 (867 digits)
29: 427! - 1 = 29063471769607348411...00000000000000000001 (940 digits)
30: 469! - 1 = 67718096668149510900...99999999999999999999 (1051 digits)
</pre>
=={{header|OCaml}}==
<syntaxhighlight lang="ocaml">let is_prime (_, n, _) =
let rec test x =
let d = n / x in x > d || x * d <> n && n mod (x + 2) <> 0 && test (x + 6)
in
if n < 5
then n lor 1 = 3
else n land 1 <> 0 && n mod 3 <> 0 && test 5
let factorials_plus_minus_one =
let rec next x y () =
Seq.Cons ((x, pred y, 0), Seq.cons (x, succ y, 1) (next (succ x) (succ x * y)))
in
next 1 1
let () =
let show (x, y, a) = Printf.printf "%3u! %c 1 = %u\n" x [|'-'; '+'|].(a) y in
factorials_plus_minus_one |> Seq.filter is_prime |> Seq.take 10 |> Seq.iter show</syntaxhighlight>
{{out}}
<pre>
1! + 1 = 2
2! + 1 = 3
3! - 1 = 5
3! + 1 = 7
4! - 1 = 23
6! - 1 = 719
7! - 1 = 5039
11! + 1 = 39916801
12! - 1 = 479001599
14! - 1 = 87178291199
</pre>
=={{header|Perl}}==
{{libheader|ntheory}}
<syntaxhighlight lang="perl" line>use v5.36;
use ntheory <is_prime factorial>;
sub show ($d) { my $l = length $d; $l < 41 ? $d : substr($d,0,20) . '..' . substr($d,-20) . " ($l digits)" }
my($cnt,$n);
my $fmt = "%2d: %3d! %s 1 = %s\n";
while () {
my $f = factorial ++$n;
if (is_prime $f-1) { printf $fmt, ++$cnt, $n, '-', show $f-1 }
if (is_prime $f+1) { printf $fmt, ++$cnt, $n, '+', show $f+1 }
last if $cnt == 30;
}</syntaxhighlight>
{{out}}
<pre> 1: 1! + 1 = 2
2: 2! + 1 = 3
3: 3! - 1 = 5
4: 3! + 1 = 7
5: 4! - 1 = 23
6: 6! - 1 = 719
7: 7! - 1 = 5039
8: 11! + 1 = 39916801
9: 12! - 1 = 479001599
10: 14! - 1 = 87178291199
11: 27! + 1 = 10888869450418352160768000001
12: 30! - 1 = 265252859812191058636308479999999
13: 32! - 1 = 263130836933693530167218012159999999
14: 33! - 1 = 8683317618811886495518194401279999999
15: 37! + 1 = 13763753091226345046..79581580902400000001 (44 digits)
16: 38! - 1 = 52302261746660111176..24100074291199999999 (45 digits)
17: 41! + 1 = 33452526613163807108..40751665152000000001 (50 digits)
18: 73! + 1 = 44701154615126843408..03680000000000000001 (106 digits)
19: 77! + 1 = 14518309202828586963..48000000000000000001 (114 digits)
20: 94! - 1 = 10873661566567430802..99999999999999999999 (147 digits)
21: 116! + 1 = 33931086844518982011..00000000000000000001 (191 digits)
22: 154! + 1 = 30897696138473508879..00000000000000000001 (272 digits)
23: 166! - 1 = 90036917057784373664..99999999999999999999 (298 digits)
24: 320! + 1 = 21161033472192524829..00000000000000000001 (665 digits)
25: 324! - 1 = 22889974601791023211..99999999999999999999 (675 digits)
26: 340! + 1 = 51008644721037110809..00000000000000000001 (715 digits)
27: 379! - 1 = 24840307460964707050..99999999999999999999 (815 digits)
28: 399! + 1 = 16008630711655973815..00000000000000000001 (867 digits)
29: 427! + 1 = 29063471769607348411..00000000000000000001 (940 digits)
30: 469! - 1 = 67718096668149510900..99999999999999999999 (1051 digits)</pre>
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">tp</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">(),</span> <span style="color: #000000;">tm</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()+</span><span style="color: #000000;">16</span> <span style="color: #000080;font-style:italic;">-- per, max 16s runtime</span>
<span style="color: #004080;">mpz</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">e</span><span style="color: #0000FF;">,</span><span style="color: #000000;">f</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_inits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">i</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">c</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
<span style="color: #008080;">while</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()<</span><span style="color: #000000;">tm</span> <span style="color: #008080;">do</span>
<span style="color: #7060A8;">mpz_mul_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">f</span><span style="color: #0000FF;">,</span><span style="color: #000000;">f</span><span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">k</span> <span style="color: #008080;">in</span> <span style="color: #0000FF;">{-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">}</span> <span style="color: #008080;">do</span>
<span style="color: #7060A8;">mpz_add_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">e</span><span style="color: #0000FF;">,</span><span style="color: #000000;">f</span><span style="color: #0000FF;">,</span><span style="color: #000000;">k</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">mpz_prime</span><span style="color: #0000FF;">(</span><span style="color: #000000;">e</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">c</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">k</span><span style="color: #0000FF;"><</span><span style="color: #000000;">0</span><span style="color: #0000FF;">?</span><span style="color: #008000;">"-"</span><span style="color: #0000FF;">:</span><span style="color: #008000;">"+"</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">es</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_get_short_str</span><span style="color: #0000FF;">(</span><span style="color: #000000;">e</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">et</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">tp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0.1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" (%s)"</span><span style="color: #0000FF;">)</span>
<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;">"%2d: %3d! %s %d = %s%s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">c</span><span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">abs</span><span style="color: #0000FF;">(</span><span style="color: #000000;">k</span><span style="color: #0000FF;">),</span><span style="color: #000000;">es</span><span style="color: #0000FF;">,</span><span style="color: #000000;">et</span><span style="color: #0000FF;">})</span>
<span style="color: #000000;">tp</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #000000;">i</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
1: 1! + 1 = 2
2: 2! + 1 = 3
3: 3! - 1 = 5
4: 3! + 1 = 7
5: 4! - 1 = 23
6: 6! - 1 = 719
7: 7! - 1 = 5039
8: 11! + 1 = 39916801
9: 12! - 1 = 479001599
10: 14! - 1 = 87178291199
11: 27! + 1 = 10888869450418352160768000001
12: 30! - 1 = 265252859812191058636308479999999
13: 32! - 1 = 263130836933693530167218012159999999
14: 33! - 1 = 8683317618811886495518194401279999999
15: 37! + 1 = 13763753091226345046315979581580902400000001
16: 38! - 1 = 523022617466601111760007224100074291199999999
17: 41! + 1 = 33452526613163807108170062053440751665152000000001
18: 73! + 1 = 44701154615126843408...03680000000000000001 (106 digits)
19: 77! + 1 = 14518309202828586963...48000000000000000001 (114 digits)
20: 94! - 1 = 10873661566567430802...99999999999999999999 (147 digits)
21: 116! + 1 = 33931086844518982011...00000000000000000001 (191 digits)
22: 154! + 1 = 30897696138473508879...00000000000000000001 (272 digits)
23: 166! - 1 = 90036917057784373664...99999999999999999999 (298 digits)
24: 320! + 1 = 21161033472192524829...00000000000000000001 (665 digits) (2.5s)
25: 324! - 1 = 22889974601791023211...99999999999999999999 (675 digits) (0.2s)
26: 340! + 1 = 51008644721037110809...00000000000000000001 (715 digits) (0.8s)
27: 379! - 1 = 24840307460964707050...99999999999999999999 (815 digits) (2.0s)
28: 399! + 1 = 16008630711655973815...00000000000000000001 (867 digits) (1.9s)
29: 427! + 1 = 29063471769607348411...00000000000000000001 (940 digits) (3.2s)
30: 469! - 1 = 67718096668149510900...99999999999999999999 (1,051 digits) (5.4s)
</pre>
<small>Items 15-17 are shown in full because that's still shorter than 20+length("...")+20+length(" (NN digits)").<br>
Aside: Unfortunately the relative performance falls off a cliff under pwa/p2js by the 320! mark, and it'd probably need a few minutes to get to the 30th.</small>
=={{header|Python}}==
{{libheader|gmpy2}}
This takes about 32 seconds to find the first 33 factorial primes on my machine (Ryzen 5 1500X).
<syntaxhighlight lang="python">
from itertools import count
from itertools import islice
from typing import Iterable
from typing import Tuple
import gmpy2
def factorials() -> Iterable[int]:
fact = 1
for i in count(1):
yield fact
fact *= i
def factorial_primes() -> Iterable[Tuple[int, int, str]]:
for n, fact in enumerate(factorials()):
if gmpy2.is_prime(fact - 1):
yield (n, fact - 1, "-")
if gmpy2.is_prime(fact + 1):
yield (n, fact + 1, "+")
def print_factorial_primes(limit=10) -> None:
print(f"First {limit} factorial primes.")
for n, fact_prime, op in islice(factorial_primes(), 1, limit + 1):
s = str(fact_prime)
if len(s) > 40:
s = f"{s[:20]}...{s[-20:]} ({len(s)} digits)"
print(f"{n}! {op} 1 = {s}")
if __name__ == "__main__":
import sys
print_factorial_primes(int(sys.argv[1]) if len(sys.argv) > 1 else 10)
</syntaxhighlight>
{{out}}
<pre>
First 33 factorial primes.
1! + 1 = 2
2! + 1 = 3
3! - 1 = 5
3! + 1 = 7
4! - 1 = 23
6! - 1 = 719
7! - 1 = 5039
11! + 1 = 39916801
12! - 1 = 479001599
14! - 1 = 87178291199
27! + 1 = 10888869450418352160768000001
30! - 1 = 265252859812191058636308479999999
32! - 1 = 263130836933693530167218012159999999
33! - 1 = 8683317618811886495518194401279999999
37! + 1 = 13763753091226345046...79581580902400000001 (44 digits)
38! - 1 = 52302261746660111176...24100074291199999999 (45 digits)
41! + 1 = 33452526613163807108...40751665152000000001 (50 digits)
73! + 1 = 44701154615126843408...03680000000000000001 (106 digits)
77! + 1 = 14518309202828586963...48000000000000000001 (114 digits)
94! - 1 = 10873661566567430802...99999999999999999999 (147 digits)
116! + 1 = 33931086844518982011...00000000000000000001 (191 digits)
154! + 1 = 30897696138473508879...00000000000000000001 (272 digits)
166! - 1 = 90036917057784373664...99999999999999999999 (298 digits)
320! + 1 = 21161033472192524829...00000000000000000001 (665 digits)
324! - 1 = 22889974601791023211...99999999999999999999 (675 digits)
340! + 1 = 51008644721037110809...00000000000000000001 (715 digits)
379! - 1 = 24840307460964707050...99999999999999999999 (815 digits)
399! + 1 = 16008630711655973815...00000000000000000001 (867 digits)
427! + 1 = 29063471769607348411...00000000000000000001 (940 digits)
469! - 1 = 67718096668149510900...99999999999999999999 (1051 digits)
546! - 1 = 14130200926141832545...99999999999999999999 (1260 digits)
872! + 1 = 19723152008295244962...00000000000000000001 (2188 digits)
974! - 1 = 55847687633820181096...99999999999999999999 (2490 digits)
</pre>
=={{header|Quackery}}==
<code>!</code> is defined at [[Factorial#Quackery]].
<code>isprime</code> is defined at [[Primality by trial division#Quackery]].
<syntaxhighlight lang="Quackery"> [ dup 10 < if sp echo ] is recho ( n --> )
[] 0
[ 1+ dup !
dup dip
[ 1 - isprime if
[ tuck negate join swap ] ]
1+ isprime if
[ tuck join swap ]
over size 9 > until ]
drop 10 split drop
witheach
[ i^ 1+
recho say ": "
dup abs tuck recho
0 < iff
[ say "! - 1 = " -1 ]
else
[ say "! + 1 = " 1 ]
swap ! + echo cr ]</syntaxhighlight>
{{out}}
<pre> 1: 1! + 1 = 2
2: 2! + 1 = 3
3: 3! - 1 = 5
4: 3! + 1 = 7
5: 4! - 1 = 23
6: 6! - 1 = 719
7: 7! - 1 = 5039
8: 11! + 1 = 39916801
9: 12! - 1 = 479001599
10: 14! - 1 = 87178291199
</pre>
=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket
(require gmp)
(define (factorial-boundary-stream)
(define (factorial-stream-iter n curr-fact)
(stream-cons `(- ,n ,(sub1 curr-fact))
(stream-cons `(+ ,n ,(add1 curr-fact))
(factorial-stream-iter (add1 n) (* curr-fact (+ n 1))))))
(factorial-stream-iter 1 1))
(define (format-large-number n)
(let* ([num-chars (number->string n)]
[num-len (string-length num-chars)])
(if (> num-len 40)
(string-append
(substring num-chars 0 19)
"..."
(substring num-chars (- num-len 19) num-len)
(format " (total ~a digits)" num-len))
n)))
(define (factorial-printer triple)
(let-values ([(op n fact) (apply values triple)])
(let ([fact (format-large-number fact)])
(displayln (format "~a! ~a 1 = ~a" n op fact)))))
(define (prime? n)
(not (zero? (mpz_probab_prime_p (mpz n) 10))))
(for ([i (in-stream
(stream-take
(stream-filter (λ (l) (prime? (third l))) (factorial-boundary-stream)) 30))]
[n (in-naturals 1)])
(begin
(display (format "~a:\t" n))
(factorial-printer i)))
;; time output of above code: 2.46 seconds
</syntaxhighlight>
<pre>
1: 1! + 1 = 2
2: 2! + 1 = 3
3: 3! - 1 = 5
4: 3! + 1 = 7
5: 4! - 1 = 23
6: 6! - 1 = 719
7: 7! - 1 = 5039
8: 11! + 1 = 39916801
9: 12! - 1 = 479001599
10: 14! - 1 = 87178291199
11: 27! + 1 = 10888869450418352160768000001
12: 30! - 1 = 265252859812191058636308479999999
13: 32! - 1 = 263130836933693530167218012159999999
14: 33! - 1 = 8683317618811886495518194401279999999
15: 37! + 1 = 1376375309122634504...9581580902400000001 (total 44 digits)
16: 38! - 1 = 5230226174666011117...4100074291199999999 (total 45 digits)
17: 41! + 1 = 3345252661316380710...0751665152000000001 (total 50 digits)
18: 73! + 1 = 4470115461512684340...3680000000000000001 (total 106 digits)
19: 77! + 1 = 1451830920282858696...8000000000000000001 (total 114 digits)
20: 94! - 1 = 1087366156656743080...9999999999999999999 (total 147 digits)
21: 116! + 1 = 3393108684451898201...0000000000000000001 (total 191 digits)
22: 154! + 1 = 3089769613847350887...0000000000000000001 (total 272 digits)
23: 166! - 1 = 9003691705778437366...9999999999999999999 (total 298 digits)
24: 320! + 1 = 2116103347219252482...0000000000000000001 (total 665 digits)
25: 324! - 1 = 2288997460179102321...9999999999999999999 (total 675 digits)
26: 340! + 1 = 5100864472103711080...0000000000000000001 (total 715 digits)
27: 379! - 1 = 2484030746096470705...9999999999999999999 (total 815 digits)
28: 399! + 1 = 1600863071165597381...0000000000000000001 (total 867 digits)
29: 427! + 1 = 2906347176960734841...0000000000000000001 (total 940 digits)
30: 469! - 1 = 6771809666814951090...9999999999999999999 (total 1051 digits)
cpu time: 2440 real time: 2440 gc time: 3</pre>
=={{header|Raku}}==
<syntaxhighlight lang="raku"
sub abr ($_) { .chars < 41 ?? $_ !! .substr(0,20) ~ '..' ~ .substr(*-20) ~ " ({.chars} digits)" }
Line 90 ⟶ 1,878:
++$limit and printf "%2d: %3d! + 1 = %s\n", $limit, $_, abr f +1 if (f +1).is-prime;
exit if $limit >= 30
}</
{{out}}
<pre> 1: 1! + 1 = 2
Line 122 ⟶ 1,910:
29: 427! + 1 = 29063471769607348411..00000000000000000001 (940 digits)
30: 469! - 1 = 67718096668149510900..99999999999999999999 (1051 digits)</pre>
=={{header|Ring}}==
<syntaxhighlight lang="ring">
see "working..." + nl
load "stdlibcore.ring"
n = 0
num = 0
while true
n++
n1 = factorial(n) - 1
if isPrime(n1)
num++
see "" + num + ": " + n + "! - 1 = " + n1 + nl
ok
n2 = factorial(n) + 1
if isPrime(n2)
num++
see "" + num + ": " + n + "! + 1 = " + n2 + nl
ok
if num = 10
exit
ok
end
see "done..." + nl
</syntaxhighlight>
{{out}}
<pre>
1: 1! + 1 = 2
2: 2! + 1 = 3
3: 3! - 1 = 5
4: 3! + 1 = 7
5: 4! - 1 = 23
6: 6! - 1 = 719
7: 7! - 1 = 5039
8: 11! + 1 = 39916801
9: 12! - 1 = 479001599
10: 14! - 1 = 87178291199
</pre>
=={{header|RPL}}==
≪ / LAST ROT * - #0 == ≫ ''''MODNOT'''' STO
≪ R→B
IF DUP #3 ≤ THEN #2 / B→R
ELSE
IF DUP #1 AND #1 ≠ OVER #3 '''MODNOT''' OR
THEN DROP 0
ELSE
DUP B→R √ R→B → maxd
≪ #5 1 SF
WHILE 1 FS? OVER maxd ≤ AND REPEAT
IF DUP2 '''MODNOT''' THEN 1 CF END
#2 + IF DUP2 '''MODNOT''' THEN 1 CF END
#4 + END
≫
DROP2 1 FS?
END
END
≫ ''''PRIM?'''' STO
≪
SWAP IP → d n
≪ n →STR "!" + d 0 > "+" "" IFTE +
d →STR + "=" + n FACT d + →STR +
≫ ≫ ''''WRITE'''' STO
≪ { } 1
WHILE OVER SIZE 10 ≤ REPEAT
DUP FACT
IF DUP 1 - '''PRIM?''' THEN OVER -1 '''WRITE''' 4 ROLL SWAP + ROT ROT END
IF 1 + '''PRIM?''' THEN DUP 1 '''WRITE''' ROT SWAP + SWAP END
1 +
END
≫ 'TASK' STO
{{out}}
<pre>
1: { "1!+1=2" "2!+1=3" "3!-1=5" "3!+1=7" "4!-1=23" "6!-1=719" "7!-1=5039" "11!+1=39916801" "12!-1=479001599" "14!-1=87178291199" }
</pre>
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">require 'openssl'
factorial_primes = Enumerator.new do |y|
fact = 1
(1..).each do |i|
fact *= i
y << [i, "- 1", fact - 1] if OpenSSL::BN.new(fact - 1).prime?
y << [i, "+ 1", fact + 1] if OpenSSL::BN.new(fact + 1).prime?
end
end
factorial_primes.first(30).each do |a|
s = a.last.to_s
if s.size > 40 then
puts "%d! %s = " % a.first(2) + "#{s[0,20]}...#{s[-20,20]}"
else
puts "%d! %s = %d" % a
end
end
</syntaxhighlight>
{{out}}
<pre>1! + 1 = 2
2! + 1 = 3
3! - 1 = 5
3! + 1 = 7
4! - 1 = 23
6! - 1 = 719
7! - 1 = 5039
11! + 1 = 39916801
12! - 1 = 479001599
14! - 1 = 87178291199
27! + 1 = 10888869450418352160768000001
30! - 1 = 265252859812191058636308479999999
32! - 1 = 263130836933693530167218012159999999
33! - 1 = 8683317618811886495518194401279999999
37! + 1 = 13763753091226345046...79581580902400000001
38! - 1 = 52302261746660111176...24100074291199999999
41! + 1 = 33452526613163807108...40751665152000000001
73! + 1 = 44701154615126843408...03680000000000000001
77! + 1 = 14518309202828586963...48000000000000000001
94! - 1 = 10873661566567430802...99999999999999999999
116! + 1 = 33931086844518982011...00000000000000000001
154! + 1 = 30897696138473508879...00000000000000000001
166! - 1 = 90036917057784373664...99999999999999999999
320! + 1 = 21161033472192524829...00000000000000000001
324! - 1 = 22889974601791023211...99999999999999999999
340! + 1 = 51008644721037110809...00000000000000000001
379! - 1 = 24840307460964707050...99999999999999999999
399! + 1 = 16008630711655973815...00000000000000000001
427! + 1 = 29063471769607348411...00000000000000000001
469! - 1 = 67718096668149510900...99999999999999999999
</pre>
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">var factorial_primes = Enumerator({|f|
for k in (1..Inf) {
if (k!-1 -> is_prime) { f([k, -1]) }
if (k!+1 -> is_prime) { f([k, +1]) }
}
})
func abr(v) {
v.len <= 40 ? v : (v.to_s.first(20) + '..' + v.to_s.last(20) + " (#{v.len} digits)")
}
factorial_primes.first(30).each_2d {|k,i|
printf("%3d! %s %d = %s\n", k, (i.sgn < 0 ? '-' : '+'), i.abs, abr(k! + i))
}</syntaxhighlight>
{{out}}
<pre> 1! + 1 = 2
2! + 1 = 3
3! - 1 = 5
3! + 1 = 7
4! - 1 = 23
6! - 1 = 719
7! - 1 = 5039
11! + 1 = 39916801
12! - 1 = 479001599
14! - 1 = 87178291199
27! + 1 = 10888869450418352160768000001
30! - 1 = 265252859812191058636308479999999
32! - 1 = 263130836933693530167218012159999999
33! - 1 = 8683317618811886495518194401279999999
37! + 1 = 13763753091226345046..79581580902400000001 (44 digits)
38! - 1 = 52302261746660111176..24100074291199999999 (45 digits)
41! + 1 = 33452526613163807108..40751665152000000001 (50 digits)
73! + 1 = 44701154615126843408..03680000000000000001 (106 digits)
77! + 1 = 14518309202828586963..48000000000000000001 (114 digits)
94! - 1 = 10873661566567430802..99999999999999999999 (147 digits)
116! + 1 = 33931086844518982011..00000000000000000001 (191 digits)
154! + 1 = 30897696138473508879..00000000000000000001 (272 digits)
166! - 1 = 90036917057784373664..99999999999999999999 (298 digits)
320! + 1 = 21161033472192524829..00000000000000000001 (665 digits)
324! - 1 = 22889974601791023211..99999999999999999999 (675 digits)
340! + 1 = 51008644721037110809..00000000000000000001 (715 digits)
379! - 1 = 24840307460964707050..99999999999999999999 (815 digits)
399! + 1 = 16008630711655973815..00000000000000000001 (867 digits)
427! + 1 = 29063471769607348411..00000000000000000001 (940 digits)
469! - 1 = 67718096668149510900..99999999999999999999 (1051 digits)</pre>
=={{header|V (Vlang)}}==
<syntaxhighlight lang="Zig">
import math
fn main() {
mut n, mut count := 0, 0
for count < 10 {
n++
f := math.factoriali(n)
if is_prime(f - 1) {
count++
println("${count}: ${n}! - 1 = ${f - 1}")
}
if is_prime(f + 1) {
count++
println("${count}: ${n}! + 1 = ${f + 1}")
}
}
}
fn is_prime(num i64) bool {
if num <= 1 {return false}
if num % 2 == 0 && num != 2 {return false}
for idx := 3; idx <= math.floor(num / 2) - 1; idx += 2 {
if num % idx == 0 {return false}
}
return true
}
</syntaxhighlight>
{{out}}
<pre>
1: 1! + 1 = 2
2: 2! + 1 = 3
3: 3! - 1 = 5
4: 3! + 1 = 7
5: 4! - 1 = 23
6: 6! - 1 = 719
7: 7! - 1 = 5039
8: 11! + 1 = 39916801
9: 12! - 1 = 479001599
10: 14! - 1 = 87178291199
</pre>
=={{header|Wren}}==
Line 127 ⟶ 2,139:
{{libheader|Wren-math}}
{{libheader|Wren-fmt}}
<
import "./fmt" for Fmt
Line 133 ⟶ 2,145:
var c = 0
var i = 1
var f = 1
while (true) {
for (gs in [[f-1, "-"], [f+1, "+"]]) {
if (Int.isPrime(
Fmt.print("$2d: $2d!
if (c == 10) return
}
}
i = i + 1
f = f * i
}</syntaxhighlight>
{{out}}
Line 163 ⟶ 2,174:
===Stretch===
{{libheader|Wren-gmp}}
This takes about 28.5 seconds to reach the 33rd factorial prime on my machine (Core i7) with the last two being
<
import "./fmt" for Fmt
Line 172 ⟶ 2,183:
var f = Mpz.one
System.print("First %(limit) factorial primes;")
while (true) {
f.mul(i)
var r = (i < 21) ? 1 : 0 // test for definite primeness below 2^64
var
Fmt.print("$2d: $3d! $s 1 = $20a $s", c = c + 1, i, gs[1], s, digs)
if (c == limit) return
}
i = i + 1
}</
{{out}}
Line 229 ⟶ 2,234:
32: 872! + 1 = 19723152008295244962...00000000000000000001 (2188 digits)
33: 974! - 1 = 55847687633820181096...99999999999999999999 (2490 digits)
</pre>
=={{header|XPL0}}==
<syntaxhighlight lang "XPL0">func IsPrime(N); \Return 'true' if N is prime
real N; int I;
[if N <= 2. then return N = 2.;
if Mod(N, 2.) = 0. then \even\ return false;
for I:= 3 to fix(sqrt(N)) do
[if Mod(N, float(I)) = 0. then return false;
I:= I+1;
];
return true;
];
func real Factorial(N); \Return N!
int N; real F;
[F:= float(N);
while N > 1 do
[N:= N-1;
F:= F * float(N);
];
return F;
];
int N, C; real F;
[N:= 1; C:= 0;
Format(1, 0);
repeat F:= Factorial(N);
if IsPrime(F-1.) then
[IntOut(0, N);
Text(0, "! - 1 = ");
RlOut(0, F-1.);
CrLf(0);
C:= C+1;
];
if IsPrime(F+1.) then
[IntOut(0, N);
Text(0, "! + 1 = ");
RlOut(0, F+1.);
CrLf(0);
C:= C+1;
];
N:= N+1;
until C >= 10;
]</syntaxhighlight>
{{out}}
<pre>
1! + 1 = 2
2! + 1 = 3
3! - 1 = 5
3! + 1 = 7
4! - 1 = 23
6! - 1 = 719
7! - 1 = 5039
11! + 1 = 39916801
12! - 1 = 479001599
14! - 1 = 87178291199
</pre>
=={{header|Go}}==
{{trans|V (Vlang)}}
<syntaxhighlight lang="go">
package main
import (
"fmt"
"math/big"
)
func main() {
n, count := 0, 0
for count < 10 {
n++
f := factorial(n)
if isPrime(f.Sub(f, big.NewInt(1))) {
count++
fmt.Printf("%2d: %2d! - 1 = %s\n", count, n, f.String())
}
if isPrime(f.Add(f, big.NewInt(2))) {
count++
fmt.Printf("%2d: %2d! + 1 = %s\n", count, n, f.String())
}
}
}
func factorial(n int) *big.Int {
result := big.NewInt(1)
for i := 2; i <= n; i++ {
result.Mul(result, big.NewInt(int64(i)))
}
return result
}
func isPrime(num *big.Int) bool {
if num.Cmp(big.NewInt(2)) < 0 {
return false
}
if num.Cmp(big.NewInt(2)) == 0 {
return true
}
if new(big.Int).Mod(num, big.NewInt(2)).Cmp(big.NewInt(0)) == 0 {
return false
}
sqrt := new(big.Int).Sqrt(num)
for i := big.NewInt(3); i.Cmp(sqrt) <= 0; i.Add(i, big.NewInt(2)) {
if new(big.Int).Mod(num, i).Cmp(big.NewInt(0)) == 0 {
return false
}
}
return true
}
</syntaxhighlight>
{{out}}
<pre>
1: 1! + 1 = 2
2: 2! + 1 = 3
3: 3! - 1 = 5
4: 3! + 1 = 7
5: 4! - 1 = 23
6: 6! - 1 = 719
7: 7! - 1 = 5039
8: 11! + 1 = 39916801
9: 12! - 1 = 479001599
10: 14! - 1 = 87178291199
</pre>
|