Iccanobif primes: Difference between revisions
Added Sidef
m (→{{header|J}}: discard f3 as unnecessary, and include some comments) |
(Added Sidef) |
||
| (19 intermediate revisions by 11 users not shown) | |||
Line 29:
v OVERAB 10
OD;
IF n < 0 THEN - reverse
END # REVERSE # ;
# returns TRUE if n is prime, FALSE otherwise - uses trial division #
Line 65:
OD
END
</syntaxhighlight>
{{out}}
<pre>
2 3 5 31 43 773 7951 64901 52057 393121
</pre>
=={{header|ALGOL W}}==
{{Trans|ALGOL 68}}
<syntaxhighlight lang="algolw">
begin % show the first 10 prime Iccanobif (reversed Fibonacci) numbers %
% returns n with the digits reversed %
integer procedure reverse ( integer value n ) ;
begin
integer rev, v;
rev := 0;
v := abs n;
while v > 0 do begin
rev := ( rev * 10 ) + ( v rem 10 );
v := v div 10
end while_v_gt_0 ;
if n < 0 then - rev else rev
end reverse ;
% returns true if n is prime, false otherwise, uses trial division %
logical procedure isPrime ( integer value n ) ;
if n < 3 then n = 2
else if n rem 3 = 0 then n = 3
else if not odd( n ) then false
else begin
logical prime;
integer f, f2, toNext;
prime := true;
f := 5;
f2 := 25;
toNext := 24; % note: ( 2n + 1 )^2 - ( 2n - 1 )^2 = 8n %
while f2 <= n and prime do begin
prime := n rem f not = 0;
f := f + 2;
f2 := toNext;
toNext := toNext + 8
end while_f2_le_n_and_prime ;
prime
end isPrime ;
begin % task %
integer pCount, curr, prev, next, rev;
pCount := 0;
prev := 0;
curr := 1;
while pCount < 10 do begin
next := prev + curr;
prev := curr;
curr := next;
rev := reverse( curr );
if isPrime( rev ) then begin
% have a prime iccanobif number %
pCount := pCount + 1;
writeon( i_w := 1, s_w := 0, " ", rev )
end if_isPrime_rev
end while_pCount_lt_10
end
end.
</syntaxhighlight>
{{out}}
Line 76 ⟶ 139:
;; description: « returns a summary of a numeric string
s: size n
if s > 20 -> n: ((take n 10)++"...")++drop
n ++ ~" (|s| digits)"
]
Line 412 ⟶ 475:
</pre>
=={{header|
{{libheader|GMP}}
<syntaxhighlight lang="cpp">#include <algorithm>
#include <iomanip>
#include <iostream>
#include <string>
#include <gmpxx.h>
using big_int = mpz_class;
bool is_probably_prime(const big_int& n) {
return mpz_probab_prime_p(n.get_mpz_t(), 15) != 0;
}
big_int reverse(const big_int& n) {
auto str = n.get_str();
std::reverse(str.begin(), str.end());
return big_int(str, 10);
}
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;
}
int main() {
big_int f0 = 0, f1 = 1;
std::cout << "First 30 Iccanobif primes:\n";
for (int count = 0; count < 30;) {
big_int f = f0 + f1;
auto p = reverse(f);
if (is_probably_prime(p)) {
++count;
std::cout << std::setw(2) << count << ": " << to_string(p, 40)
<< '\n';
}
f0 = f1;
f1 = f;
}
}</syntaxhighlight>
{{out}}
<pre>
First 30 Iccanobif primes:
1: 2
2: 3
3: 5
4: 31
5: 43
6: 773
7: 7951
8: 64901
9: 52057
10: 393121
11: 56577108676171
12: 940647607443258103531
13: 5237879497657222310489731409575442761
14: 9026258083384996860449366072142307801963
15: 19900335674812302969...34431012073266446403 (80 digits)
16: 77841137362967479985...52312097783685331923 (104 digits)
17: 37722585901567604188...29174997072830756131 (137 digits)
18: 75736193894876131595...50767238644714305761 (330 digits)
19: 17890336847332837620...13175300695235035913 (406 digits)
20: 92327163101729115305...27061468856047302507 (409 digits)
21: 50420157810698056253...67335124247362214481 (503 digits)
22: 30511012474739380092...69296158361330018201 (888 digits)
23: 46818547042693694555...08664543144645856321 (1020 digits)
24: 87101347853037819884...20128396998865227391 (1122 digits)
25: 17451656022543765336...20100243761843652461 (1911 digits)
26: 48989340566288399474...02930339234215909399 (1947 digits)
27: 12746927684958209654...53436989647994940101 (2283 digits)
28: 35746826582658751012...25010735912438195633 (3727 digits)
29: 87987175281297657706...48748727893681871587 (4270 digits)
30: 81807376367113798363...13687506007959668569 (10527 digits)
</pre>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
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
local fn ReverseInteger( n as NSUInteger )
NSUInteger reverse = 0, r
while (n != 0)
r = n mod 10
reverse = reverse * 10 + r
n /= 10
wend
end fn = reverse
local fn IccanobifPrimes( limit as NSUInteger )
NSUInteger cnt = 0, prev = 0, curr = 1, sgte, rev
printf @"First 11 IccanobiF primes:"
while (cnt < limit)
sgte = prev + curr
prev = curr
curr = sgte
rev = fn ReverseInteger(curr)
if fn IsPrime(rev)
// Iccanobif prime found
cnt++
printf @"%2lu. %lu", cnt, rev
end if
wend
end fn
fn IccanobifPrimes( 11 )
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
First 11 Iccanobif primes:
1. 2
2. 3
3, 5
4. 31
5. 43
6, 773
7. 7951
8. 64901
9. 52057
10. 393121
11. 56577108676171
</pre>
=={{header|J}}==
Implementation:
<syntaxhighlight lang="j"> (#~ 1&p:) |.&.":"0 (, _2 +/@{. ])^:(70) 1
2 3 5 31 43 773 7951 64901 52057 393121 56577108676171</syntaxhighlight>
In other words: 70 numbers from the Fibonacci sequence, reverse their digits, and keep those which are prime.
Stretch:
<syntaxhighlight lang="j"> #@":@> 10}. (#~ 1&p:) |.&.(10&#.inv)"0 (, _2 +/@{. ])^:20000]1x
14 21 37 40 80 104 137 330 406 409 503 888 1020 1122 1911 1947 2283 3727</syntaxhighlight>
For the stretch goal we use extended precision integers instead of the usual fixed width representation, and reverse the digits numerically rather than relying on the character representation of the numbers (though it's simplest to rely on the character representation for counting the digits of the resulting primes).
=={{header|jq}}==
Line 563 ⟶ 765:
879871752812976577066489068488 ... 466056251048748727893681871587 (4270 digits)
818073763671137983636050093057 ... 882798314213687506007959668569 (10527 digits)
</pre>
=={{header|Lua}}==
isPrime routine from the [[Primality by trial division]] task.
<syntaxhighlight lang="lua">
function isPrime( n )
if n <= 1 or ( n ~= 2 and n % 2 == 0 ) then
return false
end
for i = 3, math.sqrt(n), 2 do
if n % i == 0 then
return false
end
end
return true
end
function reverseDigits( n )
return tonumber( string.reverse( tostring( n ) ) )
end
do
local pCount = 0
local prev = 0
local curr = 1
while pCount < 10 do
local nextF = prev + curr
prev = curr
curr = nextF
local rev = reverseDigits( curr )
if isPrime( rev ) then
pCount = pCount + 1
io.write( " ", rev )
end
end
end
</syntaxhighlight>
{{out}}
<pre>
2 3 5 31 43 773 7951 64901 52057 393121
</pre>
=={{header|MiniScript}}==
{{Trans|Lua}}
Using code frommthe [[Reverse a string]] task.
<syntaxhighlight lang="miniscript">
isPrime = function ( n )
if n <= 1 or ( n != 2 and n % 2 == 0 ) then
return false
end if
for i in range(3, sqrt(n), 2)
if n % i == 0 then
return false
end if
end for
return true
end function
reverseString = function( str )
revStr = ""
for i in range(str.len-1, 0)
revStr = revStr + str[i]
end for
return revStr
end function
reverseDigits = function( n )
return val( reverseString( str( n ) ) )
end function
pCount = 0
prev = 0
curr = 1
out = []
while pCount < 10
nextF = prev + curr
prev = curr
curr = nextF
rev = reverseDigits( curr )
if isPrime( rev ) then
pCount = pCount + 1
out.push( rev )
end if
end while
print out.join
</syntaxhighlight>
{{out}}
<pre>
2 3 5 31 43 773 7951 64901 52057 393121
</pre>
=={{header|Nim}}==
{{libheader|Nim-Integers}}
<syntaxhighlight lang="Nim">import std/strformat
import integers
func reversed(n: Integer): Integer =
## Return the "reversed" value of "n".
result = newInteger()
var n = n
while n != 0:
result = 10 * result + n mod 10
n = n div 10
iterator fib(): Integer =
## Yield the successive values of Fibonacci sequence.
var prev, curr = newInteger(1)
yield prev
while true:
yield curr
swap curr, prev
curr += prev
func compressed(str: string; size: int): string =
## Return a compressed value for long strings of digits.
if str.len <= 2 * size: str
else: &"{str[0..<size]}...{str[^size..^1]}"
func digitCount(s: string): string =
## Return the string which describes the number of digits.
result = $s.len & " digit"
if s.len > 1: result.add 's'
echo "First 25 Iccanobif primes:"
var count = 0
for n in fib():
let r = reversed(n)
if r.isPrime:
inc count
let s = $r
echo &"{count:>2}: {s.compressed(20)} ({s.digitCount()})"
if count == 25: break
</syntaxhighlight>
{{out}}
<pre>First 25 Iccanobif primes:
1: 2 (1 digit)
2: 3 (1 digit)
3: 5 (1 digit)
4: 31 (2 digits)
5: 43 (2 digits)
6: 773 (3 digits)
7: 7951 (4 digits)
8: 64901 (5 digits)
9: 52057 (5 digits)
10: 393121 (6 digits)
11: 56577108676171 (14 digits)
12: 940647607443258103531 (21 digits)
13: 5237879497657222310489731409575442761 (37 digits)
14: 9026258083384996860449366072142307801963 (40 digits)
15: 19900335674812302969...34431012073266446403 (80 digits)
16: 77841137362967479985...52312097783685331923 (104 digits)
17: 37722585901567604188...29174997072830756131 (137 digits)
18: 75736193894876131595...50767238644714305761 (330 digits)
19: 17890336847332837620...13175300695235035913 (406 digits)
20: 92327163101729115305...27061468856047302507 (409 digits)
21: 50420157810698056253...67335124247362214481 (503 digits)
22: 30511012474739380092...69296158361330018201 (888 digits)
23: 46818547042693694555...08664543144645856321 (1020 digits)
24: 87101347853037819884...20128396998865227391 (1122 digits)
25: 17451656022543765336...20100243761843652461 (1911 digits)
</pre>
=={{header|Perl}}==
{{libheader|ntheory}}
<syntaxhighlight lang="perl" line>use
use ntheory qw<is_prime lucasu>;
Line 663 ⟶ 1,029:
</pre>
Very slow, that's as far as I was prepared to listen to it whine away...
=={{header|PL/M}}==
{{works with|8080 PL/M Compiler}} ... under CP/M (or an emulator)
As 8080 PL/M only handles 8 and 16 bit unsigned integers, this stops when the reversed number would be over 65530 and so finds only 8 Iccanobif primes.
<syntaxhighlight lang="plm">
100H: /* SHOW SOME PRIME ICCANOBIF (REVERSED FIBONACCI) NUMBERS */
/* CP/M BDOS SYSTEM CALL AND I/O ROUTINES */
BDOS: PROCEDURE( FN, ARG ); DECLARE FN BYTE, ARG ADDRESS; GOTO 5; END;
PR$CHAR: PROCEDURE( C ); DECLARE C BYTE; CALL BDOS( 2, C ); END;
PR$STRING: PROCEDURE( S ); DECLARE S ADDRESS; CALL BDOS( 9, S ); END;
PR$NL: PROCEDURE; CALL PR$CHAR( 0DH ); CALL PR$CHAR( 0AH ); END;
PR$NUMBER: PROCEDURE( N ); /* PRINTS A NUMBER IN THE MINIMUN FIELD WIDTH */
DECLARE N ADDRESS;
DECLARE V ADDRESS, N$STR ( 6 )BYTE, W BYTE;
V = N;
W = LAST( N$STR );
N$STR( W ) = '$';
N$STR( W := W - 1 ) = '0' + ( V MOD 10 );
DO WHILE( ( V := V / 10 ) > 0 );
N$STR( W := W - 1 ) = '0' + ( V MOD 10 );
END;
CALL PR$STRING( .N$STR( W ) );
END PR$NUMBER;
/* RETURNS TRUE IF N IS PRIME, FALSE OTHERWISE, USES TRIAL DIVISION */
IS$PRIME: PROCEDURE( N )BYTE;
DECLARE N ADDRESS;
DECLARE PRIME BYTE;
IF N < 3 THEN PRIME = N = 2;
ELSE IF N MOD 3 = 0 THEN PRIME = N = 3;
ELSE IF N MOD 2 = 0 THEN PRIME = 0;
ELSE DO;
DECLARE ( F, F2, TO$NEXT ) ADDRESS;
PRIME = 1;
F = 5;
F2 = 25;
TO$NEXT = 24; /* NOTE: ( 2N + 1 )^2 - ( 2N - 1 )^2 = 8N */
DO WHILE F2 <= N AND PRIME;
PRIME = N MOD F <> 0;
F = F + 2;
F2 = F2 + TO$NEXT;
TO$NEXT = TO$NEXT + 8;
END;
END;
RETURN PRIME;
END IS$PRIME;
/* TASK */
DECLARE ( PREV, CURR, NEXT, V, R ) ADDRESS;
DECLARE MORE BYTE;
PREV = 0;
CURR = 1;
MORE = 1;
DO WHILE MORE;
NEXT = PREV + CURR;
/* REVERSE THE DIGITS OF NEXT, STOP IF THE RESULT WOULD BE > 65530 */
R = 0;
V = NEXT;
DO WHILE V > 0 AND MORE;
R = ( R * 10 ) + V MOD 10;
V = V / 10;
IF R > 6553 AND V <> 0 THEN MORE = 0;
END;
IF MORE THEN DO;
/* THE REVERSE OF N WILL FIT 16 BITS */
PREV = CURR;
CURR = NEXT;
IF IS$PRIME( R ) THEN DO;
CALL PR$CHAR( ' ' );CALL PR$NUMBER( R );
END;
END;
END;
EOF
</syntaxhighlight>
{{out}}
<pre>
2 3 5 31 43 773 7951 64901
</pre>
=={{header|Python}}==
Line 726 ⟶ 1,174:
^C (took too long)
</pre>
=={{header|Quackery}}==
As with the other solutions, finds Fibonacci emirps (Fibonacci numbers which are primes when reversed) and reverses them.
<code>isprime</code> is defined at [[Primality by trial division#Quackery]].
<code>from</code>, <code>incr</code> and <code>end</code> are defined at [[Loops/Increment loop index within loop body#Quackery]].
<syntaxhighlight lang="Quackery"> [ 0
[ swap 10 /mod
rot 10 * +
over 0 = until ]
nip ] is revnum ( n --> n )
[] 1 1 from
[ dup revnum isprime if
[ tuck revnum
join swap ]
index swap incr
over size 10 = if end ]
drop echo</syntaxhighlight>
{{out}}
<pre>[ 2 3 5 31 43 773 7951 64901 52057 393121 ]</pre>
=={{header|Raku}}==
Line 762 ⟶ 1,236:
29: 87987175281297657706..48748727893681871587 (digits: 4270)
30: 81807376367113798363..13687506007959668569 (digits: 10527)</pre>
=={{header|RPL}}==
{{works with|HP|49}}
≪ 0
'''WHILE''' OVER '''REPEAT'''
SWAP 10 IDIV2
ROT 10 * +
'''END''' NIP
≫ '<span style="color:blue">REVINT</span>' STO
≪ 2 * → max
≪ { } 0 1
DO
SWAP OVER +
DUP <span style="color:blue">REVINT</span>
'''IF''' DUP ISPRIME? '''THEN'''
DUP →STR SIZE 5 ROLL ROT + SWAP + UNROT
'''ELSE''' DROP '''END'''
'''UNTIL''' 3 PICK SIZE max ≥ '''END''' DROP2
≫ ≫ '<span style="color:blue">ICCAN</span>' STO
15 <span style="color:blue">ICCAN</span>
{{out}}
<pre>
1: {2 1. 3 1. 5 1. 31 2. 43 2. 773 3. 7951 4. 64901 5. 52057 5. 393121 6. 56577108676171 14. 940647607443258103531 21. 5237879497657222310489731409575442761 37. 9026258083384996860449366072142307801963 40. 19900335674812302969315720344396951060628175943800862267761734431012073266446403 80.}
</pre>
Runs in 30 minutes on a HP-50g.
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">var count = 25
var index = 0
for n in (1..Inf) {
var t = n.fib.flip -> is_prob_prime || next
var s = Str(t)
s = "#{s.first(20)}..#{s.last(20)} (#{s.len} digits)" if (s.len>50)
say "#{'%2d' % ++index}: #{s}"
count == index && break
}</syntaxhighlight>
{{out}}
<pre>
1: 2
2: 3
3: 5
4: 31
5: 43
6: 773
7: 7951
8: 64901
9: 52057
10: 393121
11: 56577108676171
12: 940647607443258103531
13: 5237879497657222310489731409575442761
14: 9026258083384996860449366072142307801963
15: 19900335674812302969..34431012073266446403 (80 digits)
16: 77841137362967479985..52312097783685331923 (104 digits)
17: 37722585901567604188..29174997072830756131 (137 digits)
18: 75736193894876131595..50767238644714305761 (330 digits)
19: 17890336847332837620..13175300695235035913 (406 digits)
20: 92327163101729115305..27061468856047302507 (409 digits)
21: 50420157810698056253..67335124247362214481 (503 digits)
22: 30511012474739380092..69296158361330018201 (888 digits)
23: 46818547042693694555..08664543144645856321 (1020 digits)
24: 87101347853037819884..20128396998865227391 (1122 digits)
25: 17451656022543765336..20100243761843652461 (1911 digits)
</pre>
=={{header|Wren}}==
{{libheader|Wren-gmp}}
{{libheader|Wren-fmt}}
<syntaxhighlight lang="
import "./fmt" for Fmt
| |||