Initial data commit
This commit is contained in:
Ingy döt Net
parent
72d218235f
commit
f23f22d71c
199087 changed files with 3378941 additions and 0 deletions
3
Task/Cyclops-numbers/00-META.yaml
Normal file
3
Task/Cyclops-numbers/00-META.yaml
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
---
|
||||
from: http://rosettacode.org/wiki/Cyclops_numbers
|
||||
note: Prime Numbers
|
||||
41
Task/Cyclops-numbers/00-TASK.txt
Normal file
41
Task/Cyclops-numbers/00-TASK.txt
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
A '''cyclops number''' is a number with an odd number of digits that has a zero in the center, but nowhere else. They are named so in tribute to the one eyed giants Cyclops from Greek mythology.
|
||||
|
||||
Cyclops numbers can be found in any base. This task strictly is looking for cyclops numbers in base 10.
|
||||
|
||||
There are many different classifications of cyclops numbers with minor differences in characteristics. In an effort to head off a whole series of tasks with tiny variations, we will cover several variants here.
|
||||
|
||||
|
||||
;Task
|
||||
* Find and display here on this page the first 50 '''cyclops numbers''' in base 10 (all of the sub tasks are restricted to base 10).
|
||||
|
||||
* Find and display here on this page the first 50 '''prime cyclops numbers'''. (cyclops numbers that are prime.)
|
||||
|
||||
* Find and display here on this page the first 50 '''blind prime cyclops numbers'''. (prime cyclops numbers that remain prime when "blinded"; the zero is removed from the center.)
|
||||
|
||||
* Find and display here on this page the first 50 '''palindromic prime cyclops numbers'''. (prime cyclops numbers that are palindromes.)
|
||||
|
||||
|
||||
;Stretch
|
||||
* Find and display the first '''cyclops number''' greater than '''ten million''' (10,000,000) and the index (place) in the series where it is found.
|
||||
|
||||
* Find and display the first '''prime cyclops number''' greater than '''ten million''' (10,000,000) and the index (place) in the series where it is found.
|
||||
|
||||
* Find and display the first '''blind prime cyclops number''' greater than '''ten million''' (10,000,000) and the index (place) in the series where it is found.
|
||||
|
||||
* Find and display the first '''palindromic prime cyclops number''' greater than '''ten million''' (10,000,000) and the index (place) in the series where it is found.
|
||||
|
||||
('''Note:''' there '''''are''''' no cyclops numbers between ten million and one hundred million, they need to have an odd number of digits)
|
||||
|
||||
|
||||
;See also
|
||||
*; [[oeis:A134808|OEIS A134808 - Cyclops numbers]]
|
||||
|
||||
*; [[oeis:A134809|OEIS A134809 - Cyclops primes]]
|
||||
|
||||
*; [[oeis:A329737|OEIS A329737 - Cyclops primes that remain prime after being "blinded"]]
|
||||
|
||||
*; [[oeis:A136098|OEIS A136098 - Prime palindromic cyclops numbers]]
|
||||
<br>
|
||||
|
||||
|
||||
|
||||
71
Task/Cyclops-numbers/11l/cyclops-numbers.11l
Normal file
71
Task/Cyclops-numbers/11l/cyclops-numbers.11l
Normal file
|
|
@ -0,0 +1,71 @@
|
|||
F print50(arr, width = 8)
|
||||
L(n) arr
|
||||
print(commatize(n).rjust(width), end' I (L.index + 1) % 10 == 0 {"\n"} E ‘’)
|
||||
|
||||
F is_cyclops(=n)
|
||||
I n == 0
|
||||
R 1B
|
||||
V m = n % 10
|
||||
V count = 0
|
||||
L m != 0
|
||||
count++
|
||||
n I/= 10
|
||||
m = n % 10
|
||||
n I/= 10
|
||||
m = n % 10
|
||||
L m != 0
|
||||
count--
|
||||
n I/= 10
|
||||
m = n % 10
|
||||
R n == 0 & count == 0
|
||||
|
||||
F is_prime(p)
|
||||
I p < 2 | p % 2 == 0
|
||||
R p == 2
|
||||
L(i) (3 .. Int(sqrt(p))).step(2)
|
||||
I p % i == 0
|
||||
R 0B
|
||||
R 1B
|
||||
|
||||
F is_palindromic(d)
|
||||
R String(d) == reversed(String(d))
|
||||
|
||||
[Int] arr
|
||||
|
||||
print(‘The first 50 cyclops numbers are:’)
|
||||
L(i) 0..
|
||||
I is_cyclops(i)
|
||||
arr.append(i)
|
||||
I arr.len == 50
|
||||
L.break
|
||||
print50(arr)
|
||||
|
||||
print("\nThe first 50 prime cyclops numbers are:")
|
||||
arr.clear()
|
||||
L(i) 0..
|
||||
I is_cyclops(i) & is_prime(i)
|
||||
arr.append(i)
|
||||
I arr.len == 50
|
||||
L.break
|
||||
print50(arr)
|
||||
|
||||
print("\nThe first 50 blind prime cyclops numbers are:")
|
||||
arr.clear()
|
||||
L(i) 0..
|
||||
I is_cyclops(i) & is_prime(i)
|
||||
V istr = String(i)
|
||||
V mid = istr.len I/ 2
|
||||
I is_prime(Int(istr[0 .< mid]‘’istr[mid + 1 ..]))
|
||||
arr.append(i)
|
||||
I arr.len == 50
|
||||
L.break
|
||||
print50(arr)
|
||||
|
||||
print("\nThe first 50 palindromic prime cyclops numbers are:")
|
||||
arr.clear()
|
||||
L(i) 0..
|
||||
I is_cyclops(i) & is_prime(i) & is_palindromic(i)
|
||||
arr.append(i)
|
||||
I arr.len == 50
|
||||
L.break
|
||||
print50(arr, 11)
|
||||
115
Task/Cyclops-numbers/ALGOL-68/cyclops-numbers.alg
Normal file
115
Task/Cyclops-numbers/ALGOL-68/cyclops-numbers.alg
Normal file
|
|
@ -0,0 +1,115 @@
|
|||
BEGIN # show cyclops numbers - numbers with a 0 in the middle and no other 0 digits #
|
||||
INT max prime = 100 000;
|
||||
# sieve the primes to max prime #
|
||||
PR read "primes.incl.a68" PR
|
||||
[]BOOL prime = PRIMESIEVE max prime;
|
||||
# returns TRUE if c is prime, FALSE otherwise #
|
||||
PROC have a prime = ( INT c )BOOL:
|
||||
IF c < 2 THEN FALSE
|
||||
ELIF c < max prime
|
||||
THEN prime[ c ]
|
||||
ELSE # the cyclops number is too large for the sieve, use trial division #
|
||||
BOOL possibly prime := ODD c;
|
||||
FOR d FROM 3 BY 2 WHILE d * d <= c AND possibly prime DO possibly prime := c MOD d /= 0 OD;
|
||||
possibly prime
|
||||
FI # have a prime # ;
|
||||
# arrays of the cyclops numbers we must show #
|
||||
[ 1 : 50 ]INT first cyclops; INT cyclops count := 0;
|
||||
[ 1 : 50 ]INT first prime cyclops; INT prime cyclops count := 0;
|
||||
[ 1 : 50 ]INT first palindromic prime cyclops; INT palindromic prime cyclops count := 0;
|
||||
[ 1 : 50 ]INT first blind prime cyclops; INT blind prime cyclops count := 0;
|
||||
# notes c is a cyclops number, palindromic indicates whether it is palindromic or not #
|
||||
# bc should be c c with the middle 0 removed #
|
||||
# if c is one of the first 50 of various classifications, #
|
||||
# it is stored in the appropriate array #
|
||||
PROC have cyclops = ( INT c, BOOL palindromic, INT bc )VOID:
|
||||
BEGIN
|
||||
cyclops count +:= 1;
|
||||
IF cyclops count <= UPB first cyclops THEN first cyclops[ cyclops count ] := c FI;
|
||||
IF prime cyclops count < UPB first prime cyclops
|
||||
OR ( palindromic prime cyclops count < UPB first palindromic prime cyclops AND palindromic )
|
||||
OR blind prime cyclops count < UPB first blind prime cyclops
|
||||
THEN
|
||||
IF have a prime( c ) THEN
|
||||
# have a prime cyclops #
|
||||
IF prime cyclops count < UPB first prime cyclops THEN
|
||||
first prime cyclops[ prime cyclops count +:= 1 ] := c
|
||||
FI;
|
||||
IF palindromic prime cyclops count < UPB first palindromic prime cyclops AND palindromic THEN
|
||||
first palindromic prime cyclops[ palindromic prime cyclops count +:= 1 ] := c
|
||||
FI;
|
||||
IF blind prime cyclops count < UPB first blind prime cyclops THEN
|
||||
IF have a prime( bc ) THEN
|
||||
first blind prime cyclops[ blind prime cyclops count +:= 1 ] := c
|
||||
FI
|
||||
FI
|
||||
FI
|
||||
FI
|
||||
END # have cyclops # ;
|
||||
# prints a cyclops sequence #
|
||||
PROC print cyclops = ( []INT seq, STRING legend, INT elements per line )VOID:
|
||||
BEGIN
|
||||
print( ( "The first ", whole( ( UPB seq - LWB seq ) + 1, 0 ), " ", legend, ":", newline, " " ) );
|
||||
FOR i FROM LWB seq TO UPB seq DO
|
||||
print( ( " ", whole( seq[ i ], -7 ) ) );
|
||||
IF i MOD elements per line = 0 THEN print( ( newline, " " ) ) FI
|
||||
OD;
|
||||
print( ( newline ) )
|
||||
END # print cyclops # ;
|
||||
# generate the cyclops numbers #
|
||||
# 0 is the first and only cyclops number with less than three digits #
|
||||
have cyclops( 0, TRUE, 0 );
|
||||
# generate the 3 digit cyclops numbers #
|
||||
FOR f TO 9 DO
|
||||
FOR b TO 9 DO
|
||||
have cyclops( ( f * 100 ) + b
|
||||
, f = b
|
||||
, ( f * 10 ) + b
|
||||
)
|
||||
OD
|
||||
OD;
|
||||
# generate the 5 digit cyclops numbers #
|
||||
FOR d1 TO 9 DO
|
||||
FOR d2 TO 9 DO
|
||||
INT d1200 = ( ( d1 * 10 ) + d2 ) * 100;
|
||||
INT d12000 = d1200 * 10;
|
||||
FOR d4 TO 9 DO
|
||||
INT d40 = d4 * 10;
|
||||
FOR d5 TO 9 DO
|
||||
INT d45 = d40 + d5;
|
||||
have cyclops( d12000 + d45
|
||||
, d1 = d5 AND d2 = d4
|
||||
, d1200 + d45
|
||||
)
|
||||
OD
|
||||
OD
|
||||
OD
|
||||
OD;
|
||||
# generate the 7 digit cyclops numbers #
|
||||
FOR d1 TO 9 DO
|
||||
FOR d2 TO 9 DO
|
||||
FOR d3 TO 9 DO
|
||||
INT d123000 = ( ( ( ( d1 * 10 ) + d2 ) * 10 ) + d3 ) * 1000;
|
||||
INT d1230000 = d123000 * 10;
|
||||
FOR d5 TO 9 DO
|
||||
INT d500 = d5 * 100;
|
||||
FOR d6 TO 9 DO
|
||||
INT d560 = d500 + ( d6 * 10 );
|
||||
FOR d7 TO 9 DO
|
||||
INT d567 = d560 + d7;
|
||||
have cyclops( d1230000 + d567
|
||||
, d1 = d7 AND d2 = d6 AND d3 = d5
|
||||
, d123000 + d567
|
||||
)
|
||||
OD
|
||||
OD
|
||||
OD
|
||||
OD
|
||||
OD
|
||||
OD;
|
||||
# show parts of the sequence #
|
||||
print cyclops( first cyclops, "cyclops numbers", 10 );
|
||||
print cyclops( first prime cyclops, "prime cyclops numbers", 10 );
|
||||
print cyclops( first blind prime cyclops, "blind prime cyclops numbers", 10 );
|
||||
print cyclops( first palindromic prime cyclops, "palindromic prime cyclops numbers", 10 )
|
||||
END
|
||||
56
Task/Cyclops-numbers/AWK/cyclops-numbers.awk
Normal file
56
Task/Cyclops-numbers/AWK/cyclops-numbers.awk
Normal file
|
|
@ -0,0 +1,56 @@
|
|||
# syntax: GAWK -f CYCLOPS_NUMBERS.AWK
|
||||
BEGIN {
|
||||
n = 0
|
||||
limit = 50
|
||||
while (A134808_cnt < limit || A134809_cnt < limit || A329737_cnt < limit || A136098_cnt < limit) {
|
||||
leng = length(n)
|
||||
if (leng ~ /[13579]$/) {
|
||||
middle_col = int(leng/2)+1
|
||||
if (substr(n,middle_col,1) == 0 && gsub(/0/,"&",n) == 1) {
|
||||
A134808_arr[++A134808_cnt] = n
|
||||
if (is_prime(n)) {
|
||||
A134809_arr[++A134809_cnt] = n
|
||||
tmp = n
|
||||
sub(/0/,"",tmp)
|
||||
if (is_prime(tmp)) {
|
||||
A329737_arr[++A329737_cnt] = n
|
||||
}
|
||||
if (reverse(n) == n) {
|
||||
A136098_arr[++A136098_cnt] = n
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
n++
|
||||
}
|
||||
printf("Range: 0-%d\n\n",n-1)
|
||||
show_array(A134808_arr,A134808_cnt,"A134808: Cyclops numbers")
|
||||
show_array(A134809_arr,A134809_cnt,"A134809: Cyclops primes")
|
||||
show_array(A329737_arr,A329737_cnt,"A329737: Cyclops primes that remain prime after being 'blinded'")
|
||||
show_array(A136098_arr,A136098_cnt,"A136098: Prime palindromic cyclops numbers")
|
||||
exit(0)
|
||||
}
|
||||
function is_prime(x, i) {
|
||||
if (x <= 1) {
|
||||
return(0)
|
||||
}
|
||||
for (i=2; i<=int(sqrt(x)); i++) {
|
||||
if (x % i == 0) {
|
||||
return(0)
|
||||
}
|
||||
}
|
||||
return(1)
|
||||
}
|
||||
function reverse(str, i,rts) {
|
||||
for (i=length(str); i>=1; i--) {
|
||||
rts = rts substr(str,i,1)
|
||||
}
|
||||
return(rts)
|
||||
}
|
||||
function show_array(arr,cnt,desc, count,i) {
|
||||
printf("%s Found %d numbers within range\n",desc,cnt)
|
||||
for (i=1; i<=limit; i++) {
|
||||
printf("%7d%1s",arr[i],++count%10?"":"\n")
|
||||
}
|
||||
printf("\n")
|
||||
}
|
||||
121
Task/Cyclops-numbers/AppleScript/cyclops-numbers-1.applescript
Normal file
121
Task/Cyclops-numbers/AppleScript/cyclops-numbers-1.applescript
Normal file
|
|
@ -0,0 +1,121 @@
|
|||
on task()
|
||||
script o
|
||||
property cyclopses : {}
|
||||
property primeCyclopses : {}
|
||||
property blindPrimeCyclopses : {}
|
||||
property palindromicPrimeCyclopses : {}
|
||||
|
||||
on add1(digitList)
|
||||
set carry to 1
|
||||
repeat with i from (count digitList) to 1 by -1
|
||||
set columnSum to (digitList's item i) + carry
|
||||
if (columnSum < 10) then
|
||||
set digitList's item i to columnSum
|
||||
return false -- Finish and indicate "no carry".
|
||||
end if
|
||||
-- Otherwise set this digit to 1 instead of to 0 and "carry" on. ;)
|
||||
set digitList's item i to 1
|
||||
end repeat
|
||||
return true
|
||||
end add1
|
||||
|
||||
on intFromDigits(digitList)
|
||||
if (digitList = {}) then return 0
|
||||
set n to digitList's beginning
|
||||
repeat with i from 2 to (count digitList)
|
||||
set n to n * 10 + (digitList's item i)
|
||||
end repeat
|
||||
return n
|
||||
end intFromDigits
|
||||
|
||||
on store(cyclops, lst, counter)
|
||||
if (counter < 51) then
|
||||
set lst's end to cyclops
|
||||
else if (cyclops > 10000000) then
|
||||
set lst's end to {cyclops, counter}
|
||||
return false -- No more for this list, thanks.
|
||||
end if
|
||||
return true
|
||||
end store
|
||||
end script
|
||||
|
||||
set {leftDigits, rightDigits, rightless, shiftFactor} to {{}, {}, 0, 10}
|
||||
set {cRef, pcRef, bpcRef, ppcRef} to {a reference to o's cyclopses, ¬
|
||||
a reference to o's primeCyclopses, a reference to o's blindPrimeCyclopses, ¬
|
||||
a reference to o's palindromicPrimeCyclopses}
|
||||
set {cCount, pcCount, bpcCount, ppcCount} to {0, 0, 0, 0}
|
||||
set {cActive, pcActive, bpcActive, ppcActive} to {true, true, true, true}
|
||||
repeat while ((bpcActive) or (ppcActive))
|
||||
set |right| to o's intFromDigits(rightDigits)
|
||||
set cyclops to rightless + |right|
|
||||
if (cActive) then
|
||||
set cCount to cCount + 1
|
||||
set cActive to o's store(cyclops, cRef, cCount)
|
||||
end if
|
||||
if (isPrime(cyclops)) then
|
||||
if (pcActive) then
|
||||
set pcCount to pcCount + 1
|
||||
set pcActive to o's store(cyclops, pcRef, pcCount)
|
||||
end if
|
||||
if (bpcActive) then
|
||||
set blinded to rightless div 10 + |right|
|
||||
if (isPrime(blinded)) then
|
||||
set bpcCount to bpcCount + 1
|
||||
set bpcActive to o's store(cyclops, bpcRef, bpcCount)
|
||||
end if
|
||||
end if
|
||||
if ((ppcActive) and (rightDigits = stigiDtfel)) then
|
||||
set ppcCount to ppcCount + 1
|
||||
set ppcActive to o's store(cyclops, ppcRef, ppcCount)
|
||||
end if
|
||||
end if
|
||||
if (o's add1(rightDigits)) then
|
||||
-- Adding 1 to rightDigits produced a carry. Add 1 to leftDigits too.
|
||||
if (o's add1(leftDigits)) then
|
||||
-- Also carried. Extend both lists by 1 digit.
|
||||
set {leftDigits's beginning, rightDigits's beginning} to {1, 1}
|
||||
set shiftFactor to shiftFactor * 10
|
||||
end if
|
||||
set rightless to (o's intFromDigits(leftDigits)) * shiftFactor
|
||||
set stigiDtfel to leftDigits's reverse
|
||||
end if
|
||||
end repeat
|
||||
|
||||
set output to {}
|
||||
repeat with this in {{"", o's cyclopses}, {"prime ", o's primeCyclopses}, ¬
|
||||
{"blind prime ", o's blindPrimeCyclopses}, ¬
|
||||
{"palindromic prime ", o's palindromicPrimeCyclopses}}
|
||||
set {type, cyclopses} to this
|
||||
set output's end to linefeed & "First 50 " & type & "cyclops numbers:"
|
||||
repeat with i from 1 to 50 by 10
|
||||
set row to {}
|
||||
repeat with j from i to (i + 9)
|
||||
set row's end to (" " & cyclopses's item j)'s text -7 thru -1
|
||||
end repeat
|
||||
set output's end to join(row, " ")
|
||||
end repeat
|
||||
set {nth, n} to cyclopses's end
|
||||
set output's end to "The first such number > ten million is the " & n & "th: " & nth
|
||||
end repeat
|
||||
join(output, linefeed)
|
||||
end task
|
||||
|
||||
on isPrime(n)
|
||||
if (n < 4) then return (n > 1)
|
||||
if ((n mod 2 is 0) or (n mod 3 is 0)) then return false
|
||||
repeat with i from 5 to (n ^ 0.5) div 1 by 6
|
||||
if ((n mod i is 0) or (n mod (i + 2) is 0)) then return false
|
||||
end repeat
|
||||
|
||||
return true
|
||||
end isPrime
|
||||
|
||||
on join(lst, delim)
|
||||
set astid to AppleScript's text item delimiters
|
||||
set AppleScript's text item delimiters to delim
|
||||
set txt to lst as text
|
||||
set AppleScript's text item delimiters to astid
|
||||
return txt
|
||||
end join
|
||||
|
||||
task()
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
"
|
||||
First 50 cyclops numbers:
|
||||
0 101 102 103 104 105 106 107 108 109
|
||||
201 202 203 204 205 206 207 208 209 301
|
||||
302 303 304 305 306 307 308 309 401 402
|
||||
403 404 405 406 407 408 409 501 502 503
|
||||
504 505 506 507 508 509 601 602 603 604
|
||||
The first such number > ten million is the 538085th: 111101111
|
||||
|
||||
First 50 prime cyclops numbers:
|
||||
101 103 107 109 307 401 409 503 509 601
|
||||
607 701 709 809 907 11027 11047 11057 11059 11069
|
||||
11071 11083 11087 11093 12011 12037 12041 12043 12049 12071
|
||||
12073 12097 13033 13037 13043 13049 13063 13093 13099 14011
|
||||
14029 14033 14051 14057 14071 14081 14083 14087 15013 15017
|
||||
The first such number > ten million is the 39320th: 111101129
|
||||
|
||||
First 50 blind prime cyclops numbers:
|
||||
101 103 107 109 307 401 503 509 601 607
|
||||
701 709 809 907 11071 11087 11093 12037 12049 12097
|
||||
13099 14029 14033 14051 14071 14081 14083 14087 15031 15053
|
||||
15083 16057 16063 16067 16069 16097 17021 17033 17041 17047
|
||||
17053 17077 18047 18061 18077 18089 19013 19031 19051 19073
|
||||
The first such number > ten million is the 11394th: 111101161
|
||||
|
||||
First 50 palindromic prime cyclops numbers:
|
||||
101 16061 31013 35053 38083 73037 74047 91019 94049 1120211
|
||||
1150511 1160611 1180811 1190911 1250521 1280821 1360631 1390931 1490941 1520251
|
||||
1550551 1580851 1630361 1640461 1660661 1670761 1730371 1820281 1880881 1930391
|
||||
1970791 3140413 3160613 3260623 3310133 3380833 3460643 3470743 3590953 3670763
|
||||
3680863 3970793 7190917 7250527 7310137 7540457 7630367 7690967 7750577 7820287
|
||||
The first such number > ten million is the 67th: 114808411"
|
||||
45
Task/Cyclops-numbers/Arturo/cyclops-numbers.arturo
Normal file
45
Task/Cyclops-numbers/Arturo/cyclops-numbers.arturo
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
cyclops?: function [n][
|
||||
digs: digits n
|
||||
all? @[
|
||||
-> odd? size digs
|
||||
-> zero? digs\[(size digs)/2]
|
||||
-> 1 = size match to :string n "0"
|
||||
]
|
||||
]
|
||||
|
||||
blind: function [x][
|
||||
s: to :string x
|
||||
half: (size s)/2
|
||||
to :integer (slice s 0 dec half)++(slice s inc half dec size s)
|
||||
]
|
||||
|
||||
findFirst50: function [what, start, predicate][
|
||||
print ["First 50" what++"cyclops numbers:"]
|
||||
first50: new start
|
||||
i: 100
|
||||
while [50 > size first50][
|
||||
if do predicate -> 'first50 ++ i
|
||||
i: i + 1
|
||||
]
|
||||
|
||||
loop split.every:10 first50 'row [
|
||||
print map to [:string] row 'item -> pad item 7
|
||||
]
|
||||
print ""
|
||||
]
|
||||
|
||||
findFirst50 "" [0] -> cyclops? i
|
||||
findFirst50 "prime " [] -> and? [prime? i][cyclops? i]
|
||||
findFirst50 "blind prime " [] -> all? @[
|
||||
-> prime? i
|
||||
-> cyclops? i
|
||||
-> prime? blind i
|
||||
]
|
||||
|
||||
candidates: map 1..999 'x ->
|
||||
to :integer (to :string x)++"0"++(reverse to :string x)
|
||||
|
||||
print "First 50 palindromic prime cyclops numbers:"
|
||||
loop split.every:10 first.n: 50 select candidates 'x -> and? [prime? x][cyclops? x] 'row [
|
||||
print map to [:string] row 'item -> pad item 7
|
||||
]
|
||||
158
Task/Cyclops-numbers/C++/cyclops-numbers.cpp
Normal file
158
Task/Cyclops-numbers/C++/cyclops-numbers.cpp
Normal file
|
|
@ -0,0 +1,158 @@
|
|||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <iomanip>
|
||||
#include <cmath>
|
||||
|
||||
template <class T>
|
||||
void print(std::vector< T >, size_t);
|
||||
|
||||
bool isCyclopsNumber(int);
|
||||
std::vector< int > firstCyclops(int);
|
||||
bool isPrime(int);
|
||||
std::vector< int > firstCyclopsPrimes(int);
|
||||
int blindCyclops(int);
|
||||
std::vector< int > firstBlindCyclopsPrimes(int);
|
||||
bool isPalindrome(int);
|
||||
std::vector< int > firstPalindromeCyclopsPrimes(int);
|
||||
|
||||
int main(void) {
|
||||
auto first50 = firstCyclops(50);
|
||||
|
||||
std::cout << "First 50 cyclops numbers:" << std::endl;
|
||||
print< int >(first50, 10);
|
||||
|
||||
auto prime50 = firstCyclopsPrimes(50);
|
||||
|
||||
std::cout << std::endl << "First 50 prime cyclops numbers:" << std::endl;
|
||||
print< int >(prime50, 10);
|
||||
|
||||
auto blind50 = firstBlindCyclopsPrimes(50);
|
||||
|
||||
std::cout << std::endl << "First 50 blind prime cyclops numbers:" << std::endl;
|
||||
print< int >(blind50, 10);
|
||||
|
||||
auto palindrome50 = firstPalindromeCyclopsPrimes(50);
|
||||
|
||||
std::cout << std::endl << "First 50 palindromic prime cyclops numbers:" << std::endl;
|
||||
print< int >(palindrome50, 10);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void print(std::vector< T > v, size_t nc) {
|
||||
size_t col = 0;
|
||||
for (auto e : v) {
|
||||
std::cout << std::setw(8) << e << " ";
|
||||
col++;
|
||||
if (col == nc) {
|
||||
std::cout << std::endl;
|
||||
col = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool isCyclopsNumber(int n) {
|
||||
if (n == 0) {
|
||||
return true;
|
||||
}
|
||||
int m = n % 10;
|
||||
int count = 0;
|
||||
while (m != 0) {
|
||||
count++;
|
||||
n /= 10;
|
||||
m = n % 10;
|
||||
}
|
||||
n /= 10;
|
||||
m = n % 10;
|
||||
while (m != 0) {
|
||||
count--;
|
||||
n /= 10;
|
||||
m = n % 10;
|
||||
}
|
||||
return n == 0 && count == 0;
|
||||
}
|
||||
|
||||
std::vector< int > firstCyclops(int n) {
|
||||
std::vector< int > result;
|
||||
int i = 0;
|
||||
while (result.size() < n) {
|
||||
if (isCyclopsNumber(i)) result.push_back(i);
|
||||
i++;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
bool isPrime(int n) {
|
||||
if (n < 2) return false;
|
||||
double s = std::sqrt(n);
|
||||
for (int i = 2; i <= s; i++) {
|
||||
if (n % i == 0) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
std::vector< int > firstCyclopsPrimes(int n) {
|
||||
std::vector< int > result;
|
||||
int i = 0;
|
||||
while (result.size() < n) {
|
||||
if (isCyclopsNumber(i) && isPrime(i)) result.push_back(i);
|
||||
i++;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
int blindCyclops(int n) {
|
||||
int m = n % 10;
|
||||
int k = 0;
|
||||
while (m != 0) {
|
||||
k = 10 * k + m;
|
||||
n /= 10;
|
||||
m = n % 10;
|
||||
}
|
||||
n /= 10;
|
||||
while (k != 0) {
|
||||
m = k % 10;
|
||||
n = 10 * n + m;
|
||||
k /= 10;
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
std::vector< int > firstBlindCyclopsPrimes(int n) {
|
||||
std::vector< int > result;
|
||||
int i = 0;
|
||||
while (result.size() < n) {
|
||||
if (isCyclopsNumber(i) && isPrime(i)) {
|
||||
int j = blindCyclops(i);
|
||||
if (isPrime(j)) result.push_back(i);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
bool isPalindrome(int n) {
|
||||
int k = 0;
|
||||
int l = n;
|
||||
while (l != 0) {
|
||||
int m = l % 10;
|
||||
k = 10 * k + m;
|
||||
l /= 10;
|
||||
}
|
||||
return n == k;
|
||||
}
|
||||
|
||||
std::vector< int > firstPalindromeCyclopsPrimes(int n) {
|
||||
std::vector< int > result;
|
||||
int i = 0;
|
||||
while (result.size() < n) {
|
||||
if (isCyclopsNumber(i) && isPrime(i) && isPalindrome(i)) result.push_back(i);
|
||||
i++;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
173
Task/Cyclops-numbers/Delphi/cyclops-numbers.delphi
Normal file
173
Task/Cyclops-numbers/Delphi/cyclops-numbers.delphi
Normal file
|
|
@ -0,0 +1,173 @@
|
|||
var Base: integer; {Base value for iterating through cyclops numbers}
|
||||
var OutStr: string; {Hold accumulating output data}
|
||||
|
||||
|
||||
function NumberOfDigits(N: integer): integer;
|
||||
{Find the number of digits in an integer}
|
||||
begin
|
||||
if N<1 then Result:=0
|
||||
else Result:=Trunc(Log10(N))+1;
|
||||
end;
|
||||
|
||||
|
||||
procedure OutputNumber(Memo: TMemo; N: integer);
|
||||
{Output number, grouping them 10 items per line}
|
||||
begin
|
||||
OutStr:=OutStr+Format('%8D',[N]);
|
||||
if ((Length(OutStr) div 8) mod 10)=0 then
|
||||
begin
|
||||
Memo.Lines.Add(OutStr);
|
||||
OutStr:='';
|
||||
end;
|
||||
end;
|
||||
|
||||
function IsPrime(N: integer): 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));
|
||||
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 NonZeroIncrement(N: integer): integer;
|
||||
{Find next number with no zero digits}
|
||||
begin
|
||||
repeat Inc(N)
|
||||
until Pos('0',IntToStr(N))<1;
|
||||
Result:=N;
|
||||
end;
|
||||
|
||||
|
||||
function GetNonZeroEvenDigits(N: integer): integer;
|
||||
{Get next number with no zeros that has even number of digits}
|
||||
begin
|
||||
repeat N:=NonZeroIncrement(N)
|
||||
until (NumberOfDigits(N) and 1)=0;
|
||||
Result:=N;
|
||||
end;
|
||||
|
||||
|
||||
|
||||
function InsertCenterZero(N: integer): integer;
|
||||
{Insert a zero in the centers of a number}
|
||||
{assumes the number is an even number digits long}
|
||||
var S: string;
|
||||
begin
|
||||
S:=IntToStr(N);
|
||||
Insert('0',S,(Length(S) div 2)+1);
|
||||
Result:=StrToInt(S);
|
||||
end;
|
||||
|
||||
|
||||
function GetNextCyclops: integer;
|
||||
{Get next cyclops number}
|
||||
begin
|
||||
Base:=GetNonZeroEvenDigits(Base);
|
||||
Result:=InsertCenterZero(Base);
|
||||
end;
|
||||
|
||||
|
||||
|
||||
function GetPalindromeCyclops: integer;
|
||||
{Get next palindromic cyclops number}
|
||||
var S1,S2: string;
|
||||
begin
|
||||
Base:=NonZeroIncrement(Base);
|
||||
S1:=IntToStr(Base);
|
||||
S2:=ReverseString(S1);
|
||||
Result:=StrToInt(S1+'0'+S2);
|
||||
end;
|
||||
|
||||
|
||||
{--------------- Top level routines -------------------------------------------}
|
||||
|
||||
procedure GetCyclopsNumbers(Memo: TMemo);
|
||||
{find first 50 Prime Cyclcops Numbers}
|
||||
var I,C: integer;
|
||||
var S: string;
|
||||
begin
|
||||
Memo.Lines.Add('First 50 Cyclops Numbers');
|
||||
Base:=0;
|
||||
OutputNumber(Memo,0);
|
||||
for I:=1 to 50-1 do
|
||||
begin
|
||||
C:=GetNextCyclops;
|
||||
OutputNumber(Memo,C);
|
||||
end;
|
||||
if OutStr<>'' then Memo.Lines.Add(OutStr);
|
||||
end;
|
||||
|
||||
|
||||
procedure GetPrimeCyclops(Memo: TMemo);
|
||||
{find first 50 Prime Cyclcops Numbers}
|
||||
var I,C: integer;
|
||||
var S: string;
|
||||
begin
|
||||
Memo.Lines.Add('First 50 Prime Cyclops Numbers');
|
||||
Base:=0;
|
||||
for I:=1 to 50 do
|
||||
begin
|
||||
repeat C:=GetNextCyclops;
|
||||
until IsPrime(C);
|
||||
OutputNumber(Memo,C);
|
||||
end;
|
||||
if OutStr<>'' then Memo.Lines.Add(OutStr);
|
||||
end;
|
||||
|
||||
|
||||
procedure GetBlindPrimeCyclops(Memo: TMemo);
|
||||
{find first 50 Blind Prime Cyclcops Numbers}
|
||||
var I,C,CB: integer;
|
||||
var S: string;
|
||||
begin
|
||||
Memo.Lines.Add('First 50 Blind Prime Cyclops Numbers');
|
||||
Base:=0;
|
||||
for I:=1 to 50 do
|
||||
begin
|
||||
repeat C:=GetNextCyclops;
|
||||
until IsPrime(Base);
|
||||
OutputNumber(Memo,C);
|
||||
end;
|
||||
if OutStr<>'' then Memo.Lines.Add(OutStr);
|
||||
end;
|
||||
|
||||
|
||||
procedure GetPalindromicPrimeCyclops(Memo: TMemo);
|
||||
{find first 50 Palindromic Prime Cyclcops Numbers}
|
||||
var I,C,CB: integer;
|
||||
var S: string;
|
||||
begin
|
||||
Memo.Lines.Add('First 50 Palindromic Prime Cyclops Numbers');
|
||||
Base:=0;
|
||||
for I:=1 to 50 do
|
||||
begin
|
||||
repeat C:=GetPalindromeCyclops;
|
||||
until IsPrime(C);
|
||||
OutputNumber(Memo,C);
|
||||
end;
|
||||
if OutStr<>'' then Memo.Lines.Add(OutStr);
|
||||
end;
|
||||
|
||||
|
||||
|
||||
|
||||
procedure DisplayCyclopsNumbers(Memo: TMemo);
|
||||
{Do full suite of Cyclops tasks}
|
||||
begin
|
||||
GetCyclopsNumbers(Memo);
|
||||
GetPrimeCyclops(Memo);
|
||||
GetBlindPrimeCyclops(Memo);
|
||||
GetPalindromicPrimeCyclops(Memo);
|
||||
end;
|
||||
5
Task/Cyclops-numbers/F-Sharp/cyclops-numbers-1.fs
Normal file
5
Task/Cyclops-numbers/F-Sharp/cyclops-numbers-1.fs
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
// Cyclop numbers. Nigel Galloway: June 25th., 2021
|
||||
let rec fG n g=seq{yield! g|>Seq.collect(fun i->g|>Seq.map(fun g->n*i+g)); yield! fG(n*10)(fN g)}
|
||||
let cyclops=seq{yield 0; yield! fG 100 [1..9]}
|
||||
let primeCyclops,blindCyclops=cyclops|>Seq.filter isPrime,Seq.zip(fG 100 [1..9])(fG 10 [1..9])|>Seq.filter(fun(n,g)->isPrime n && isPrime g)|>Seq.map fst
|
||||
let palindromicCyclops=let fN g=let rec fN g=[yield g%10; if g>9 then yield! fN(g/10)] in let n=fN g in n=List.rev n in primeCyclops|>Seq.filter fN
|
||||
1
Task/Cyclops-numbers/F-Sharp/cyclops-numbers-2.fs
Normal file
1
Task/Cyclops-numbers/F-Sharp/cyclops-numbers-2.fs
Normal file
|
|
@ -0,0 +1 @@
|
|||
cyclops|>Seq.take 50|>Seq.iter(printf "%d "); printfn ""
|
||||
1
Task/Cyclops-numbers/F-Sharp/cyclops-numbers-3.fs
Normal file
1
Task/Cyclops-numbers/F-Sharp/cyclops-numbers-3.fs
Normal file
|
|
@ -0,0 +1 @@
|
|||
primeCyclops|>Seq.take 50|>Seq.iter(printf "%d "); printfn ""
|
||||
1
Task/Cyclops-numbers/F-Sharp/cyclops-numbers-4.fs
Normal file
1
Task/Cyclops-numbers/F-Sharp/cyclops-numbers-4.fs
Normal file
|
|
@ -0,0 +1 @@
|
|||
blindCyclops|>Seq.take 50|>Seq.iter(printf "%d "); printfn ""
|
||||
1
Task/Cyclops-numbers/F-Sharp/cyclops-numbers-5.fs
Normal file
1
Task/Cyclops-numbers/F-Sharp/cyclops-numbers-5.fs
Normal file
|
|
@ -0,0 +1 @@
|
|||
palindromicCyclops|>Seq.take 50|>Seq.iter(printf "%d "); printfn ""
|
||||
1
Task/Cyclops-numbers/F-Sharp/cyclops-numbers-6.fs
Normal file
1
Task/Cyclops-numbers/F-Sharp/cyclops-numbers-6.fs
Normal file
|
|
@ -0,0 +1 @@
|
|||
let n=cyclops|>Seq.findIndex(fun n->n>10000000) in printfn "First Cyclop number > 10,000,000 is %d at index %d" (Seq.item n (cyclops)) n
|
||||
1
Task/Cyclops-numbers/F-Sharp/cyclops-numbers-7.fs
Normal file
1
Task/Cyclops-numbers/F-Sharp/cyclops-numbers-7.fs
Normal file
|
|
@ -0,0 +1 @@
|
|||
let n=primeCyclops|>Seq.findIndex(fun n->n>10000000) in printfn "First prime Cyclop number > 10,000,000 is %d at index %d" (Seq.item n (primeCyclops)) n
|
||||
1
Task/Cyclops-numbers/F-Sharp/cyclops-numbers-8.fs
Normal file
1
Task/Cyclops-numbers/F-Sharp/cyclops-numbers-8.fs
Normal file
|
|
@ -0,0 +1 @@
|
|||
let n=blindCyclops|>Seq.findIndex(fun n->n>10000000) in printfn "First blind Cyclop number > 10,000,000 is %d at index %d" (Seq.item n (blindCyclops)) n
|
||||
1
Task/Cyclops-numbers/F-Sharp/cyclops-numbers-9.fs
Normal file
1
Task/Cyclops-numbers/F-Sharp/cyclops-numbers-9.fs
Normal file
|
|
@ -0,0 +1 @@
|
|||
let n=palindromicCyclops|>Seq.findIndex(fun n->n>10000000) in printfn "First palindromic prime Cyclop number > 10,000,000 is %d at index %d" (Seq.item n (palindromicCyclops)) n
|
||||
92
Task/Cyclops-numbers/Factor/cyclops-numbers.factor
Normal file
92
Task/Cyclops-numbers/Factor/cyclops-numbers.factor
Normal file
|
|
@ -0,0 +1,92 @@
|
|||
USING: accessors formatting grouping io kernel lists lists.lazy
|
||||
math math.functions math.primes prettyprint sequences
|
||||
tools.memory.private tools.time ;
|
||||
|
||||
|
||||
|
||||
! ==========={[ Cyclops data type and operations ]}=============
|
||||
|
||||
TUPLE: cyclops left right n max ;
|
||||
|
||||
: <cyclops> ( -- cyclops ) 1 1 1 9 cyclops boa ;
|
||||
|
||||
: >cyclops< ( cyclops -- right left n )
|
||||
[ right>> ] [ left>> ] [ n>> ] tri ;
|
||||
|
||||
M: cyclops >integer >cyclops< 1 + 10^ * + ;
|
||||
|
||||
: >blind ( cyclops -- n ) >cyclops< 10^ * + ;
|
||||
|
||||
: next-zeroless ( 9199 -- 9211 )
|
||||
dup 10 mod 9 < [ 10 /i next-zeroless 10 * ] unless 1 + ;
|
||||
|
||||
: right++ ( cyclops -- cyclops' )
|
||||
[ next-zeroless ] change-right ; inline
|
||||
|
||||
: left++ ( cyclops -- cyclops' )
|
||||
[ next-zeroless ] change-left [ 9 /i ] change-right ;
|
||||
|
||||
: n++ ( cyclops -- cyclops' )
|
||||
[ 1 + ] change-n [ 10 * 9 + ] change-max ;
|
||||
|
||||
: change-both ( cyclops quot -- cyclops' )
|
||||
[ change-left ] keep change-right ; inline
|
||||
|
||||
: expand ( cyclops -- cyclops' )
|
||||
dup max>> 9 /i 1 + '[ _ + ] change-both n++ ;
|
||||
|
||||
: carry ( cyclops -- cyclops' )
|
||||
dup [ left>> ] [ max>> ] bi < [ left++ ] [ expand ] if ;
|
||||
|
||||
: succ ( cyclops -- next-cyclops )
|
||||
dup [ right>> ] [ max>> ] bi < [ right++ ] [ carry ] if ;
|
||||
|
||||
|
||||
|
||||
! ============{[ List definitions & operations ]}===============
|
||||
|
||||
: lcyclops ( -- list ) <cyclops> [ succ ] lfrom-by ;
|
||||
|
||||
: lcyclops-int ( -- list ) lcyclops [ >integer ] lmap-lazy ;
|
||||
|
||||
: lprime-cyclops ( -- list )
|
||||
lcyclops-int [ prime? ] lfilter ;
|
||||
|
||||
: lblind-prime-cyclops ( -- list )
|
||||
lcyclops [ >integer prime? ] lfilter
|
||||
[ >blind prime? ] lfilter ;
|
||||
|
||||
: reverse-digits ( 123 -- 321 )
|
||||
0 swap [ 10 /mod rot 10 * + swap ] until-zero ;
|
||||
|
||||
: lpalindromic-prime-cyclops ( -- list )
|
||||
lcyclops [ [ left>> ] [ right>> ] bi reverse-digits = ]
|
||||
lfilter [ >integer prime? ] lfilter ;
|
||||
|
||||
: first>1e7 ( list -- elt index )
|
||||
0 lfrom lzip [ first >integer 10,000,000 > ] lfilter car
|
||||
first2 [ >integer ] dip [ commas ] bi@ ;
|
||||
|
||||
|
||||
|
||||
! ====================={[ OUTPUT ]}=============================
|
||||
|
||||
: first50 ( list -- )
|
||||
50 swap ltake [ >integer ] lmap list>array 10 group
|
||||
simple-table. ;
|
||||
|
||||
:: show ( desc list -- )
|
||||
desc desc "First 50 %s numbers:\n" printf
|
||||
list [ first50 nl ] [
|
||||
first>1e7
|
||||
"First %s number > 10,000,000: %s - at (zero based) index: %s.\n\n\n" printf
|
||||
] bi ;
|
||||
|
||||
"cyclops" lcyclops-int show
|
||||
"prime cyclops" lprime-cyclops show
|
||||
"blind prime cyclops" lblind-prime-cyclops show
|
||||
"palindromic prime cyclops" lpalindromic-prime-cyclops show
|
||||
|
||||
! Extra stretch?
|
||||
"One billionth cyclops number:" print
|
||||
999,999,999 lcyclops lnth >integer commas print
|
||||
113
Task/Cyclops-numbers/Go/cyclops-numbers.go
Normal file
113
Task/Cyclops-numbers/Go/cyclops-numbers.go
Normal file
|
|
@ -0,0 +1,113 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"rcu"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
func findFirst(list []int) (int, int) {
|
||||
for i, n := range list {
|
||||
if n > 1e7 {
|
||||
return n, i
|
||||
}
|
||||
}
|
||||
return -1, -1
|
||||
}
|
||||
|
||||
func reverse(s string) string {
|
||||
chars := []rune(s)
|
||||
for i, j := 0, len(chars)-1; i < j; i, j = i+1, j-1 {
|
||||
chars[i], chars[j] = chars[j], chars[i]
|
||||
}
|
||||
return string(chars)
|
||||
}
|
||||
|
||||
func main() {
|
||||
ranges := [][2]int{
|
||||
{0, 0}, {101, 909}, {11011, 99099}, {1110111, 9990999}, {111101111, 119101111},
|
||||
}
|
||||
var cyclops []int
|
||||
for _, r := range ranges {
|
||||
numDigits := len(fmt.Sprint(r[0]))
|
||||
center := numDigits / 2
|
||||
for i := r[0]; i <= r[1]; i++ {
|
||||
digits := rcu.Digits(i, 10)
|
||||
if digits[center] == 0 {
|
||||
count := 0
|
||||
for _, d := range digits {
|
||||
if d == 0 {
|
||||
count++
|
||||
}
|
||||
}
|
||||
if count == 1 {
|
||||
cyclops = append(cyclops, i)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
fmt.Println("The first 50 cyclops numbers are:")
|
||||
for i, n := range cyclops[0:50] {
|
||||
fmt.Printf("%6s ", rcu.Commatize(n))
|
||||
if (i+1)%10 == 0 {
|
||||
fmt.Println()
|
||||
}
|
||||
}
|
||||
n, i := findFirst(cyclops)
|
||||
ns, is := rcu.Commatize(n), rcu.Commatize(i)
|
||||
fmt.Printf("\nFirst such number > 10 million is %s at zero-based index %s\n", ns, is)
|
||||
|
||||
var primes []int
|
||||
for _, n := range cyclops {
|
||||
if rcu.IsPrime(n) {
|
||||
primes = append(primes, n)
|
||||
}
|
||||
}
|
||||
fmt.Println("\n\nThe first 50 prime cyclops numbers are:")
|
||||
for i, n := range primes[0:50] {
|
||||
fmt.Printf("%6s ", rcu.Commatize(n))
|
||||
if (i+1)%10 == 0 {
|
||||
fmt.Println()
|
||||
}
|
||||
}
|
||||
n, i = findFirst(primes)
|
||||
ns, is = rcu.Commatize(n), rcu.Commatize(i)
|
||||
fmt.Printf("\nFirst such number > 10 million is %s at zero-based index %s\n", ns, is)
|
||||
|
||||
var bpcyclops []int
|
||||
var ppcyclops []int
|
||||
for _, p := range primes {
|
||||
ps := fmt.Sprint(p)
|
||||
split := strings.Split(ps, "0")
|
||||
noMiddle, _ := strconv.Atoi(split[0] + split[1])
|
||||
if rcu.IsPrime(noMiddle) {
|
||||
bpcyclops = append(bpcyclops, p)
|
||||
}
|
||||
if ps == reverse(ps) {
|
||||
ppcyclops = append(ppcyclops, p)
|
||||
}
|
||||
}
|
||||
|
||||
fmt.Println("\n\nThe first 50 blind prime cyclops numbers are:")
|
||||
for i, n := range bpcyclops[0:50] {
|
||||
fmt.Printf("%6s ", rcu.Commatize(n))
|
||||
if (i+1)%10 == 0 {
|
||||
fmt.Println()
|
||||
}
|
||||
}
|
||||
n, i = findFirst(bpcyclops)
|
||||
ns, is = rcu.Commatize(n), rcu.Commatize(i)
|
||||
fmt.Printf("\nFirst such number > 10 million is %s at zero-based index %s\n", ns, is)
|
||||
|
||||
fmt.Println("\n\nThe first 50 palindromic prime cyclops numbers are:\n")
|
||||
for i, n := range ppcyclops[0:50] {
|
||||
fmt.Printf("%9s ", rcu.Commatize(n))
|
||||
if (i+1)%8 == 0 {
|
||||
fmt.Println()
|
||||
}
|
||||
}
|
||||
n, i = findFirst(ppcyclops)
|
||||
ns, is = rcu.Commatize(n), rcu.Commatize(i)
|
||||
fmt.Printf("\n\nFirst such number > 10 million is %s at zero-based index %s\n", ns, is)
|
||||
}
|
||||
47
Task/Cyclops-numbers/Haskell/cyclops-numbers.hs
Normal file
47
Task/Cyclops-numbers/Haskell/cyclops-numbers.hs
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
import Control.Monad (replicateM)
|
||||
import Data.Numbers.Primes (isPrime)
|
||||
|
||||
--------------------- CYCLOPS NUMBERS --------------------
|
||||
|
||||
cyclops :: [Integer]
|
||||
cyclops = [0 ..] >>= go
|
||||
where
|
||||
go 0 = [0]
|
||||
go n =
|
||||
(\s -> read s :: Integer)
|
||||
<$> (fmap ((<>) . (<> "0")) >>= (<*>))
|
||||
(replicateM n ['1' .. '9'])
|
||||
|
||||
blindPrime :: Integer -> Bool
|
||||
blindPrime n =
|
||||
let s = show n
|
||||
m = quot (length s) 2
|
||||
in isPrime $
|
||||
(\t -> read t :: Integer)
|
||||
(take m s <> drop (succ m) s)
|
||||
|
||||
palindromic :: Integer -> Bool
|
||||
palindromic = ((==) =<< reverse) . show
|
||||
|
||||
-------------------------- TESTS -------------------------
|
||||
main :: IO ()
|
||||
main =
|
||||
(putStrLn . unlines)
|
||||
[ "First 50 Cyclops numbers – A134808:",
|
||||
unwords (show <$> take 50 cyclops),
|
||||
"",
|
||||
"First 50 Cyclops primes – A134809:",
|
||||
unwords $ take 50 [show n | n <- cyclops, isPrime n],
|
||||
"",
|
||||
"First 50 blind prime Cyclops numbers – A329737:",
|
||||
unwords $
|
||||
take
|
||||
50
|
||||
[show n | n <- cyclops, isPrime n, blindPrime n],
|
||||
"",
|
||||
"First 50 prime palindromic cyclops numbers – A136098:",
|
||||
unwords $
|
||||
take
|
||||
50
|
||||
[show n | n <- cyclops, isPrime n, palindromic n]
|
||||
]
|
||||
13
Task/Cyclops-numbers/J/cyclops-numbers.j
Normal file
13
Task/Cyclops-numbers/J/cyclops-numbers.j
Normal file
|
|
@ -0,0 +1,13 @@
|
|||
makecyclops =: 3 : 0
|
||||
NB. y Number of digits (must be odd, greater than 2)
|
||||
side =. nums #~ -. '0' +./@:="1 nums =: ":"0 (0.1 * base) }. i. base =. 10 ^ <. -: y
|
||||
, /:~ ". ,/ (side ,"1 0 '0') ,"1"2 1 side
|
||||
)
|
||||
|
||||
go =: 3 : 0
|
||||
cyclops =. 0 , ; <@:makecyclops"0 (3 5 7)
|
||||
('First 50 Cyclops numbers:' , ": 5 10 $ cyclops) (1!:2) 2
|
||||
((LF , 'First 50 prime Cyclops numbers:') , ": 5 10 $ primes =. cyclops ([ #~ e.) p: i.600000) (1!:2) 2
|
||||
((LF , 'First 50 blind prime Cyclops numbers:') , ": 5 10 $ (primes #~ (, ". '0' -.~"0 1 ": ,. primes) e. p: i.10000)) (1!:2) 2
|
||||
(LF , 'First 50 palindromic prime Cyclops numbers:') , ": 5 10 $ primes #~ > (-: |.) &. > <@:":"1 ,. primes
|
||||
)
|
||||
68
Task/Cyclops-numbers/Jq/cyclops-numbers-1.jq
Normal file
68
Task/Cyclops-numbers/Jq/cyclops-numbers-1.jq
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
## Generic helper functions
|
||||
|
||||
def count(s): reduce s as $x (0; .+1);
|
||||
|
||||
# counting from 0
|
||||
def enumerate(s): foreach s as $x (-1; .+1; [., $x]);
|
||||
|
||||
def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;
|
||||
|
||||
## Prime numbers
|
||||
def is_prime:
|
||||
if . == 2 then true
|
||||
else
|
||||
2 < . and . % 2 == 1 and
|
||||
(. as $in
|
||||
| (($in + 1) | sqrt) as $m
|
||||
| [false, 3] | until( .[0] or .[1] > $m; [$in % .[1] == 0, .[1] + 2])
|
||||
| .[0]
|
||||
| not)
|
||||
end ;
|
||||
|
||||
## Cyclops numbers
|
||||
|
||||
def iscyclops:
|
||||
(tostring | explode) as $d
|
||||
| ($d|length) as $l
|
||||
| (($l + 1) / 2 - 1) as $m
|
||||
| ($l % 2 == 1) and $d[$m] == 48 and count($d[] | select(.== 48)) == 1 # "0"
|
||||
;
|
||||
|
||||
# Generate a stream of cyclops numbers, in increasing numeric order, from 0
|
||||
def cyclops:
|
||||
# generate a stream of cyclops numbers with $n digits on each side of the central 0
|
||||
def w:
|
||||
if . == 0 then ""
|
||||
else (.-1)|w as $left
|
||||
| $left + (range(1;10)|tostring)
|
||||
end;
|
||||
def c: w as $left | $left + "0" + w;
|
||||
range(0; infinite) | c | tonumber;
|
||||
|
||||
# Generate a stream of palindromic cyclops numbers, in increasing numeric order, from 0
|
||||
def palindromiccyclops:
|
||||
def r: explode|reverse|implode;
|
||||
def c: . as $n
|
||||
| if $n == 0 then "0"
|
||||
elif $n == 1
|
||||
then (range(1;10)|tostring) as $base
|
||||
| $base + "0" + ($base | r)
|
||||
else (range(pow(10;$n-1); pow(10; $n))|tostring|select(test("0")|not)) as $base
|
||||
| $base + "0" + ($base | r)
|
||||
end;
|
||||
range(0; infinite) | c | tonumber;
|
||||
|
||||
# check that a cyclops number minus the 0 is prime
|
||||
def cyclops_isblind:
|
||||
(tostring | explode) as $d
|
||||
| ($d|length) as $l
|
||||
| (($l + 1) / 2 - 1) as $m
|
||||
| ((( $d[:$m] + $d[$m+1:] ) | implode | tonumber) | is_prime);
|
||||
|
||||
# check that a cyclops number is a palindrome
|
||||
def cyclops_ispalindromic:
|
||||
. as $in
|
||||
| (tostring | explode) as $d
|
||||
| ($d|length) as $l
|
||||
| (($l + 1) / 2 - 1) as $m
|
||||
| $d[:$m] == ( $d[$m+1:] | reverse) ;
|
||||
34
Task/Cyclops-numbers/Jq/cyclops-numbers-2.jq
Normal file
34
Task/Cyclops-numbers/Jq/cyclops-numbers-2.jq
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
def print5x10($width):
|
||||
. as $a
|
||||
| range(0;5) as $i
|
||||
| reduce range(0;10) as $j (""; . + ($a[10*$i + $j] | lpad($width)));
|
||||
|
||||
def main_task($n):
|
||||
"The first \($n) cyclops numbers are:",
|
||||
([limit($n; cyclops)] | print5x10(7)),
|
||||
|
||||
"\nThe first \($n) prime cyclops numbers are:",
|
||||
([limit($n; cyclops | select(is_prime))] | print5x10(7)),
|
||||
|
||||
"\nThe first \($n) blind prime cyclops numbers are:",
|
||||
([limit($n; cyclops | select(is_prime and cyclops_isblind))] | print5x10(7)),
|
||||
|
||||
"\nThe first \($n) palindromic prime cyclops numbers are:",
|
||||
([limit($n; cyclops | select(cyclops_ispalindromic and is_prime))] | print5x10(8)) ;
|
||||
|
||||
def stretch_task($big):
|
||||
def pp: " \(.[1]) at index \(.[0]).";
|
||||
"\nFirst cyclops greater than \($big):" +
|
||||
(first(enumerate(cyclops) | select(.[1] > $big))|pp),
|
||||
|
||||
"\nThe next prime cyclops number after \($big):" +
|
||||
(first(enumerate(cyclops | select(is_prime)) | select(.[1] | (. > $big)) ) | pp),
|
||||
|
||||
"\nThe first blind prime cyclops number greater than \($big):" +
|
||||
(first(enumerate(cyclops | select(is_prime and cyclops_isblind)) | select(.[1] > $big) )|pp),
|
||||
|
||||
"\nThe first palindromic prime cyclops number greater than \($big):" +
|
||||
(first(enumerate(palindromiccyclops | select(is_prime)) | select(.[1] > $big) ) | pp) ;
|
||||
|
||||
main_task(50),
|
||||
stretch_task(pow(10;7))
|
||||
66
Task/Cyclops-numbers/Julia/cyclops-numbers.julia
Normal file
66
Task/Cyclops-numbers/Julia/cyclops-numbers.julia
Normal file
|
|
@ -0,0 +1,66 @@
|
|||
print5x10(a, w = 8) = for i in 0:4, j in 1:10 print(lpad(a[10i + j], w), j == 10 ? "\n" : "") end
|
||||
|
||||
function iscyclops(n)
|
||||
d = digits(n)
|
||||
l = length(d)
|
||||
return isodd(l) && d[l ÷ 2 + 1] == 0 && count(x -> x == 0, d) == 1
|
||||
end
|
||||
|
||||
function isblindprimecyclops(n)
|
||||
d = digits(n)
|
||||
l = length(d)
|
||||
m = l ÷ 2 + 1
|
||||
(n == 0 || iseven(l) || d[m] != 0 || count(x -> x == 0, d) != 1) && return false
|
||||
return isprime(evalpoly(10, [d[1:m-1]; d[m+1:end]]))
|
||||
end
|
||||
|
||||
function ispalindromicprimecyclops(n)
|
||||
d = digits(n)
|
||||
l = length(d)
|
||||
return n > 0 && isodd(l) && d[l ÷ 2 + 1] == 0 && count(x -> x == 0, d) == 1 && d == reverse(d)
|
||||
end
|
||||
|
||||
function findcyclops(N, iscycs, nextcandidate)
|
||||
i, list = nextcandidate(-1), Int[]
|
||||
while length(list) < N
|
||||
iscycs(i) && push!(list, i)
|
||||
i = nextcandidate(i)
|
||||
end
|
||||
return list
|
||||
end
|
||||
|
||||
function nthcyclopsfirstafter(lowerlimit, iscycs, nextcandidate)
|
||||
i, found = 0, 0
|
||||
while true
|
||||
if iscycs(i)
|
||||
found += 1
|
||||
i >= lowerlimit && break
|
||||
end
|
||||
i = nextcandidate(i)
|
||||
end
|
||||
return i, found
|
||||
end
|
||||
|
||||
function testcyclops()
|
||||
println("The first 50 cyclops numbers are:")
|
||||
print5x10(findcyclops(50, iscyclops, x -> x + 1))
|
||||
n, c = nthcyclopsfirstafter(10000000, iscyclops, x -> x + 1)
|
||||
println("\nThe next cyclops number after 10,000,000 is $n at position $c.")
|
||||
|
||||
println("\nThe first 50 prime cyclops numbers are:")
|
||||
print5x10(findcyclops(50, iscyclops, x -> nextprime(x + 1)))
|
||||
n, c = nthcyclopsfirstafter(10000000, iscyclops, x -> nextprime(x + 1))
|
||||
println("\nThe next prime cyclops number after 10,000,000 is $n at position $c.")
|
||||
|
||||
println("\nThe first 50 blind prime cyclops numbers are:")
|
||||
print5x10(findcyclops(50, isblindprimecyclops, x -> nextprime(x + 1)))
|
||||
n, c = nthcyclopsfirstafter(10000000, isblindprimecyclops, x -> nextprime(x + 1))
|
||||
println("\nThe next prime cyclops number after 10,000,000 is $n at position $c.")
|
||||
|
||||
println("\nThe first 50 palindromic prime cyclops numbers are:")
|
||||
print5x10(findcyclops(50, ispalindromicprimecyclops, x -> nextprime(x + 1)))
|
||||
n, c = nthcyclopsfirstafter(10000000, ispalindromicprimecyclops, x -> nextprime(x + 1))
|
||||
println("\nThe next prime cyclops number after 10,000,000 is $n at position $c.")
|
||||
end
|
||||
|
||||
testcyclops()
|
||||
109
Task/Cyclops-numbers/Ksh/cyclops-numbers.ksh
Normal file
109
Task/Cyclops-numbers/Ksh/cyclops-numbers.ksh
Normal file
|
|
@ -0,0 +1,109 @@
|
|||
#!/bin/ksh
|
||||
|
||||
# Cyclops numbers (odd number of digits that has a zero in the center)
|
||||
# - first 50 cyclops numbers
|
||||
# - first 50 prime cyclops numbers
|
||||
# - first 50 blind prime cyclops numbers
|
||||
# - first 50 palindromic prime cyclops numbers
|
||||
|
||||
# # Variables:
|
||||
#
|
||||
integer MAXN=50
|
||||
|
||||
# # Functions:
|
||||
#
|
||||
|
||||
# # Function _isprime(n) return 1 for prime, 0 for not prime
|
||||
#
|
||||
function _isprime {
|
||||
typeset _n ; integer _n=$1
|
||||
typeset _i ; integer _i
|
||||
|
||||
(( _n < 2 )) && return 0
|
||||
for (( _i=2 ; _i*_i<=_n ; _i++ )); do
|
||||
(( ! ( _n % _i ) )) && return 0
|
||||
done
|
||||
return 1
|
||||
}
|
||||
|
||||
# # Function _iscyclops(n) - return 1 for cyclops number
|
||||
#
|
||||
function _iscyclops {
|
||||
typeset _n ; integer _n=$1
|
||||
|
||||
(( ! ${#_n}&1 )) && return 0 # must have odd number of digits
|
||||
(( ${_n:$((${#_n}/2)):1} )) && return 0 # must have center zero
|
||||
[[ $(_blind ${_n}) == *0* ]] && return 0 # No other zeros
|
||||
|
||||
return 1
|
||||
}
|
||||
|
||||
# # Function _blind(n) - return a "blinded" cyclops number
|
||||
#
|
||||
function _blind {
|
||||
typeset _n ; _n="$1"
|
||||
|
||||
echo "${_n:0:$((${#_n}/2))}${_n:$((${#_n}/2+1)):$((${#_n}/2))}"
|
||||
}
|
||||
|
||||
# # Function _ispalindrome(n) - return 1 for palindromic number
|
||||
#
|
||||
function _ispalindrome {
|
||||
typeset _n ; _n="$1"
|
||||
typeset _flippedn
|
||||
|
||||
_flippedn=$(_flipit ${_n:$((${#_n}/2+1)):$((${#_n}/2))})
|
||||
[[ ${_n:0:$((${#_n}/2))} != ${_flippedn} ]] && return 0
|
||||
return 1
|
||||
}
|
||||
|
||||
# # Function _flipit(string) - return flipped string
|
||||
#
|
||||
function _flipit {
|
||||
typeset _buf ; _buf="$1"
|
||||
typeset _tmp ; unset _tmp
|
||||
|
||||
for (( _i=$(( ${#_buf}-1 )); _i>=0; _i-- )); do
|
||||
_tmp="${_tmp}${_buf:${_i}:1}"
|
||||
done
|
||||
|
||||
echo "${_tmp}"
|
||||
}
|
||||
######
|
||||
# main #
|
||||
######
|
||||
|
||||
integer cy=prcy=blprcy=palprcy=0 # counters
|
||||
typeset -a cyarr prcyarr blprcyarr palprcyarr
|
||||
|
||||
for i in {101..909} {11011..99099} {1110111..9990999}; do
|
||||
_iscyclops ${i} ; (( ! $? )) && continue
|
||||
(( ++cy <= MAXN )) && cyarr+=( ${i} )
|
||||
|
||||
_isprime ${i} ; (( ! $? )) && continue
|
||||
(( ++prcy <= MAXN )) && prcyarr+=( ${i} )
|
||||
|
||||
if (( blprcy < MAXN )); then
|
||||
_isprime $(_blind ${i})
|
||||
(( $? )) && { (( blprcy++ )) ; blprcyarr+=( ${i} ) }
|
||||
fi
|
||||
|
||||
if (( palprcy < MAXN )); then
|
||||
_ispalindrome ${i}
|
||||
(( $? )) && { (( palprcy++ )) ; palprcyarr+=( ${i} ) }
|
||||
fi
|
||||
|
||||
(( palprcy >= MAXN && blprcy >= MAXN && prcy >= MAXN && cy >= MAXN )) && break
|
||||
done
|
||||
|
||||
print "First $MAXN cyclops numbers:"
|
||||
print ${cyarr[@]}
|
||||
|
||||
print "\nFirst $MAXN prime cyclops numbers:"
|
||||
print ${prcyarr[@]}
|
||||
|
||||
print "\nFirst $MAXN blind prime cyclops numbers:"
|
||||
print ${blprcyarr[@]}
|
||||
|
||||
print "\nFirst $MAXN palindromic prime cyclops numbers:"
|
||||
print ${palprcyarr[@]}
|
||||
48
Task/Cyclops-numbers/Mathematica/cyclops-numbers.math
Normal file
48
Task/Cyclops-numbers/Mathematica/cyclops-numbers.math
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
a = Flatten[Table[FromDigits[{i, 0, j}], {i, 9}, {j, 9}], 1];
|
||||
b = Flatten@Table[FromDigits@{i, j}, {i, 9}, {j, 9}];
|
||||
c = Flatten@Table[FromDigits@{i, j, k}, {i, 9}, {j, 9}, {k, 9}];
|
||||
|
||||
blindPrimeQ[n_] :=
|
||||
Block[{digits = IntegerDigits@n, m},
|
||||
m = Floor[Length[digits]/2];
|
||||
PrimeQ[FromDigits@Join[digits[[;; m]], digits[[-m ;;]]]]]
|
||||
|
||||
palindromeQ[n_] :=
|
||||
Block[{digits = IntegerDigits@n}, digits === Reverse[digits]]
|
||||
|
||||
cyclopsQ[n_] :=
|
||||
Block[{digits = IntegerDigits@n, len, ctr},
|
||||
len = Length[digits];
|
||||
ctr = Ceiling[len/2];
|
||||
And @@ {Mod[len, 2] == 1, ctr > 0, digits[[ctr]] == 0,
|
||||
FreeQ[Drop[digits, {ctr}], 0]}]
|
||||
|
||||
cyclops = (* all Cyclops numbers with 3, 5 or 7 digits *)
|
||||
Flatten@{a,
|
||||
Outer[
|
||||
FromDigits@Flatten@{IntegerDigits@#1, 0, IntegerDigits@#2} &, b,
|
||||
b],
|
||||
Outer[
|
||||
FromDigits@Flatten@{IntegerDigits@#1, 0, IntegerDigits@#2} &, c,
|
||||
c]};
|
||||
|
||||
x = NestWhile[NextPrime, 10^8, ! (cyclopsQ@# && PrimeQ@#) &];
|
||||
|
||||
Labeled[Partition[Flatten[{0, a}][[;; 50]], 10] //
|
||||
TableForm, "First 50 Cyclop numbers", Top]
|
||||
Labeled[Partition[(primeCyclops = Cases[cyclops, _?PrimeQ])[[;; 50]],
|
||||
10] // TableForm, "First 50 prime cyclops numbers", Top]
|
||||
Labeled[Partition[(blind = Cases[primeCyclops, _?blindPrimeQ])[[;;
|
||||
50]], 10] //
|
||||
TableForm, "First 50 blind prime cyclops numbers", Top]
|
||||
Labeled[Partition[(p = Cases[primeCyclops, _?palindromeQ])[[;; 50]],
|
||||
10] // TableForm, "First 50 palindromic prime Cyclops Numbers", Top]
|
||||
Labeled[TableForm[{{x,
|
||||
Length@primeCyclops}, {NestWhile[NextPrime,
|
||||
x + 1, ! (cyclopsQ@# && PrimeQ@# && blindPrimeQ@#) &],
|
||||
Length@blind}, {NestWhile[NextPrime,
|
||||
x + 1, ! (cyclopsQ@# && PrimeQ@# && palindromeQ@#) &],
|
||||
Length@p}},
|
||||
TableHeadings -> {{"Prime", "Blind Prime",
|
||||
"Palindromic Prime"}, {"Value",
|
||||
"Index"}}], "First Cyclops numeber > 10,000,000", Top]
|
||||
109
Task/Cyclops-numbers/Nim/cyclops-numbers.nim
Normal file
109
Task/Cyclops-numbers/Nim/cyclops-numbers.nim
Normal file
|
|
@ -0,0 +1,109 @@
|
|||
import strutils, times
|
||||
|
||||
const Ranges = [0..0, 101..909, 11011..99099, 1110111..9990999, 111101111..999909999]
|
||||
|
||||
|
||||
func isCyclops(d: string): bool =
|
||||
d[d.len shr 1] == '0' and d.count('0') == 1
|
||||
|
||||
func isPrime(n: Natural): bool =
|
||||
if n < 2: return
|
||||
if n mod 2 == 0: return n == 2
|
||||
if n mod 3 == 0: return n == 3
|
||||
var d = 5
|
||||
while d * d <= n:
|
||||
if n mod d == 0: return false
|
||||
inc d, 2
|
||||
if n mod d == 0: return false
|
||||
inc d, 4
|
||||
return true
|
||||
|
||||
func isBlind(d: string): bool =
|
||||
var d = d
|
||||
let m = d.len shr 1
|
||||
result = (d[0..m-1] & d[m+1..^1]).parseInt().isPrime
|
||||
|
||||
func isPalindromic(d: string): bool =
|
||||
for i in 1..d.len:
|
||||
if d[i-1] != d[^i]: return
|
||||
result = true
|
||||
|
||||
|
||||
iterator cyclops(): (int, int) =
|
||||
var count = 0
|
||||
for r in Ranges:
|
||||
for n in r:
|
||||
if ($n).isCyclops:
|
||||
inc count
|
||||
yield (count, n)
|
||||
|
||||
iterator primeCyclops(): (int, int) =
|
||||
var count = 0
|
||||
for (_, n) in cyclops():
|
||||
if n.isPrime:
|
||||
inc count
|
||||
yield (count, n)
|
||||
|
||||
iterator blindPrimeCyclops(): (int, int) =
|
||||
var count = 0
|
||||
for (_, n) in primeCyclops():
|
||||
if ($n).isBlind:
|
||||
inc count
|
||||
yield (count, n)
|
||||
|
||||
iterator palindromicPrimeCyclops(): (int, int) =
|
||||
var count = 0
|
||||
for r in Ranges:
|
||||
for n in r:
|
||||
let d = $n
|
||||
if d.isCyclops and d.isPalindromic and n.isPrime:
|
||||
inc count
|
||||
yield (count, n)
|
||||
|
||||
let t0 = cpuTime()
|
||||
|
||||
echo "List of first 50 cyclops numbers:"
|
||||
for i, n in cyclops():
|
||||
stdout.write ($n).align(3), if i mod 10 == 0: '\n' else: ' '
|
||||
if i == 50: break
|
||||
|
||||
echo "\nList of first 50 prime cyclops numbers:"
|
||||
for i, n in primeCyclops():
|
||||
stdout.write ($n).align(5), if i mod 10 == 0: '\n' else: ' '
|
||||
if i == 50: break
|
||||
|
||||
echo "\nList of first 50 blind prime cyclops numbers:"
|
||||
for i, n in blindPrimeCyclops():
|
||||
stdout.write ($n).align(5), if i mod 10 == 0: '\n' else: ' '
|
||||
if i == 50: break
|
||||
|
||||
echo "\nList of first 50 palindromic prime cyclops numbers:"
|
||||
for i, n in palindromicPrimeCyclops():
|
||||
stdout.write ($n).align(7), if i mod 10 == 0: '\n' else: ' '
|
||||
if i == 50: break
|
||||
|
||||
for i, n in cyclops():
|
||||
if n > 10_000_000:
|
||||
echo "\nFirst cyclops number greater than ten million is ",
|
||||
($n).insertSep(), " at 1-based index: ", i
|
||||
break
|
||||
|
||||
for i, n in primeCyclops():
|
||||
if n > 10_000_000:
|
||||
echo "\nFirst prime cyclops number greater than ten million is ",
|
||||
($n).insertSep(), " at 1-based index: ", i
|
||||
break
|
||||
|
||||
for i, n in blindPrimeCyclops():
|
||||
if n > 10_000_000:
|
||||
echo "\nFirst blind prime cyclops number greater than ten million is ",
|
||||
($n).insertSep(), " at 1-based index: ", i
|
||||
break
|
||||
|
||||
for i, n in palindromicPrimeCyclops():
|
||||
if n > 10_000_000:
|
||||
echo "\nFirst palindromic prime cyclops number greater than ten million is ",
|
||||
($n).insertSep(), " at 1-based index: ", i
|
||||
break
|
||||
|
||||
echo "\nExecution time: ", (cpuTime() - t0).formatFloat(ffDecimal, precision = 3), " seconds."
|
||||
498
Task/Cyclops-numbers/Pascal/cyclops-numbers.pas
Normal file
498
Task/Cyclops-numbers/Pascal/cyclops-numbers.pas
Normal file
|
|
@ -0,0 +1,498 @@
|
|||
program cyclops;
|
||||
{$IFDEF FPC}
|
||||
{$MODE DELPHI}
|
||||
{$OPTIMIZATION ON,ALL}
|
||||
{$CodeAlign proc=32,loop=1}
|
||||
{$ENDIF}
|
||||
//extra https://oeis.org/A136098/b136098.txt take ~37 s( TIO.RUN )
|
||||
uses
|
||||
sysutils;
|
||||
const
|
||||
BIGLIMIT = 10*1000*1000;
|
||||
|
||||
type
|
||||
//number in base 9
|
||||
tnumdgts = array[0..10] of byte;
|
||||
tpnumdgts = pByte;
|
||||
tnum9 = packed record
|
||||
nmdgts : tnumdgts;
|
||||
nmMaxDgtIdx :byte;
|
||||
nmNum : uint32;
|
||||
end;
|
||||
tCN = record
|
||||
cnRight,
|
||||
cnLeft : tNum9;
|
||||
cnNum : Uint64;
|
||||
cndigits,
|
||||
cnIdx : Uint32;
|
||||
end;
|
||||
tCyclopsList = array of Uint64;
|
||||
|
||||
procedure InitCycNum(var cn:tCN);forward;
|
||||
|
||||
var
|
||||
cnMin,cnPow10Shift,cnPow9 : array[0..15] of Uint64;
|
||||
Cyclops :tCyclopsList;
|
||||
|
||||
function IndexToCyclops(n:Uint64):tCN;
|
||||
//zero-based index
|
||||
var
|
||||
dgtCnt,i,num : UInt32;
|
||||
q,p9: Uint64;
|
||||
Begin
|
||||
InitCycNum(result);
|
||||
if n = 0 then
|
||||
EXIT;
|
||||
result.cnIdx := n;
|
||||
dgtCnt := 0;
|
||||
|
||||
repeat
|
||||
p9 := sqr(cnPow9[dgtCnt]);
|
||||
if n < p9 then
|
||||
break;
|
||||
n -= p9;
|
||||
inc(dgtCnt)
|
||||
until dgtcnt>10;
|
||||
dec(dgtCnt);
|
||||
with result do
|
||||
Begin
|
||||
with cnRight do
|
||||
Begin
|
||||
nmMaxDgtIdx := dgtCnt;
|
||||
For i := 0 to dgtCnt do
|
||||
begin
|
||||
q := n DIV 9;
|
||||
nmdgts[i] := n-9*q;
|
||||
n := q;
|
||||
end;
|
||||
num :=0;
|
||||
For i := dgtcnt downto 0 do
|
||||
num := num*10+nmdgts[i]+1;
|
||||
nmNum:= num;
|
||||
cnNum := num;
|
||||
end;
|
||||
|
||||
with cnLeft do
|
||||
Begin
|
||||
nmMaxDgtIdx := dgtCnt;
|
||||
For i := 0 to dgtCnt do
|
||||
begin
|
||||
q := n DIV 9;
|
||||
nmdgts[i] := n-9*q;
|
||||
n := q;
|
||||
end;
|
||||
num :=0;
|
||||
For i := dgtcnt downto 0 do
|
||||
num := num*10+nmdgts[i]+1;
|
||||
nmNum:= num;
|
||||
cnNum += num*cnPow10Shift[dgtCnt];
|
||||
cndigits := dgtCnt;
|
||||
end;
|
||||
end;
|
||||
end;
|
||||
|
||||
procedure Out_Cyclops(const cl:tCyclopsList;colw,colc:NativeInt);
|
||||
var
|
||||
i,n : NativeInt;
|
||||
Begin
|
||||
n := High(cl);
|
||||
If n > 100 then
|
||||
n := 100;
|
||||
For i := 0 to n do
|
||||
begin
|
||||
write(cl[i]:colw);
|
||||
if (i+1) mod colc = 0 then
|
||||
writeln;
|
||||
end;
|
||||
if (i+1) mod colc <> 0 then
|
||||
writeln;
|
||||
if n< High(cl) then
|
||||
writeln(High(cl)+1,' : ',cl[High(cl)]);
|
||||
end;
|
||||
|
||||
procedure InitCnMinPow;
|
||||
//min = (0,1,11,111,1111,11111,111111,1111111,11111111,...);
|
||||
var
|
||||
i,min,pow,pow9 : Uint64;
|
||||
begin
|
||||
min := 0;
|
||||
pow := 100;
|
||||
pow9 := 1;
|
||||
For i :=0 to High(cnMin) do
|
||||
begin
|
||||
cnMin[i] := min;
|
||||
min := 10*min+1;
|
||||
cnPow10Shift[i] := pow;
|
||||
pow *= 10;
|
||||
cnPow9[i] := pow9;
|
||||
pow9 *= 9;
|
||||
end;
|
||||
end;
|
||||
|
||||
procedure ClearNum9(var tn:tNum9;idx:Uint32);
|
||||
begin
|
||||
fillchar(tn,SizeOf(tn),#0);
|
||||
tn.nmNum := cnMin[idx+1];
|
||||
end;
|
||||
|
||||
Procedure InitCycNum(var cn:tCN);
|
||||
Begin
|
||||
with cn do
|
||||
Begin
|
||||
cndigits := 0;
|
||||
ClearNum9(cnLeft,0);
|
||||
ClearNum9(cnRight,0);
|
||||
cnNum := 0;
|
||||
cnIdx := 0;
|
||||
end;
|
||||
end;
|
||||
|
||||
procedure IncNum9(var tn:tNum9);
|
||||
var
|
||||
idx,fac,n: Uint32;
|
||||
begin
|
||||
idx := 0;
|
||||
with tn do
|
||||
Begin
|
||||
fac := 1;
|
||||
n := nmdgts[0]+1;
|
||||
inc(nmNum);
|
||||
repeat
|
||||
if n < 9 then
|
||||
break;
|
||||
inc(nmNum,fac);
|
||||
nmdgts[idx] :=0;
|
||||
inc(idx);
|
||||
fac *= 10;
|
||||
n := nmdgts[idx]+1;
|
||||
until idx > nmMaxDgtIdx;
|
||||
If idx > High(nmdgts) then
|
||||
EXIT;
|
||||
nmdgts[idx] := n;
|
||||
if nmMaxDgtIdx<Idx then
|
||||
nmMaxDgtIdx := Idx;
|
||||
end;
|
||||
end;
|
||||
|
||||
procedure NextCycNum(var cycnum:tCN);
|
||||
begin
|
||||
with cycnum do
|
||||
Begin
|
||||
if cnIdx <> 0 then
|
||||
begin
|
||||
//increment right digits
|
||||
IncNum9(cnRight);
|
||||
if cnRight.nmMaxDgtIdx > cndigits then
|
||||
Begin
|
||||
//set right digits to minimum
|
||||
ClearNum9(cnRight,cndigits);
|
||||
//increment left digits
|
||||
IncNum9(cnLeft);
|
||||
//One more digit ?
|
||||
if cnLeft.nmMaxDgtIdx > cndigits then
|
||||
Begin
|
||||
inc(cndigits);
|
||||
ClearNum9(cnLeft,cndigits);
|
||||
ClearNum9(cnRight,cndigits);
|
||||
if cndigits>High(tnumdgts) then
|
||||
cndigits := High(tnumdgts);
|
||||
end;
|
||||
end;
|
||||
cnNum := cnLeft.nmNum*cnPow10Shift[cndigits]+cnRight.nmNUm;
|
||||
inc(cnIdx);
|
||||
end
|
||||
else
|
||||
Begin
|
||||
cnNum := 101;
|
||||
cnIdx := 1;
|
||||
end;
|
||||
end;
|
||||
end;
|
||||
|
||||
procedure MakePalinCycNum(var cycnum:tCN);
|
||||
//make right to be palin of left
|
||||
var
|
||||
n,dgt : Uint32;
|
||||
i,j:NativeInt;
|
||||
Begin
|
||||
n := 0;
|
||||
with cycnum do
|
||||
Begin
|
||||
i := 0;
|
||||
For j := cnDigits downto 0 do
|
||||
begin
|
||||
dgt := cnLeft.nmdgts[i];
|
||||
cnRight.nmdgts[j] := dgt;
|
||||
n := 10*n+(dgt+1);
|
||||
inc(i);
|
||||
end;
|
||||
cnRight.nmNum := n;
|
||||
cnNum := cnLeft.nmNum*cnPow10Shift[cndigits]+n;
|
||||
end;
|
||||
end;
|
||||
|
||||
procedure IncLeftCn(var cn:tCN);
|
||||
Begin
|
||||
with cn do
|
||||
Begin
|
||||
//set right digits to minimum
|
||||
ClearNum9(cnRight,cndigits);
|
||||
//increment left digits
|
||||
IncNum9(cnLeft);
|
||||
//One more digit ?
|
||||
if cnLeft.nmMaxDgtIdx > cndigits then
|
||||
Begin
|
||||
inc(cndigits);
|
||||
ClearNum9(cnLeft,cndigits);
|
||||
ClearNum9(cnRight,cndigits);
|
||||
if cndigits>High(tnumdgts) then
|
||||
cndigits := High(tnumdgts);
|
||||
end;
|
||||
cnNum := cnLeft.nmNum*cnPow10Shift[cndigits]+cnRight.nmNUm;
|
||||
end;
|
||||
end;
|
||||
|
||||
function isPalinCycNum(const cycnum:tCN):boolean;
|
||||
var
|
||||
i,j:NativeInt;
|
||||
Begin
|
||||
with cycnum do
|
||||
Begin
|
||||
i := cnDigits;
|
||||
j := 0;
|
||||
repeat
|
||||
result := (cnRight.nmdgts[i]=cnLeft.nmdgts[j]);
|
||||
if not(result) then
|
||||
BREAK;
|
||||
dec(i);
|
||||
inc(j);
|
||||
until i<0;
|
||||
end;
|
||||
end;
|
||||
|
||||
function FirstCyclops(cnt:NativeInt):tCN;
|
||||
var
|
||||
i: NativeInt;
|
||||
begin
|
||||
setlength(Cyclops,cnt);
|
||||
i := 0;
|
||||
InitCycNum(result);
|
||||
while i < cnt do
|
||||
begin
|
||||
Cyclops[i] := result.cnNum;
|
||||
inc(i);
|
||||
NextCycNum(result);
|
||||
end;
|
||||
repeat
|
||||
NextCycNum(result);
|
||||
inc(i);
|
||||
until result.cnNum> BIGLIMIT;
|
||||
end;
|
||||
|
||||
function isPrime(n:Uint64):boolean;
|
||||
var
|
||||
p,q : Uint64;
|
||||
Begin
|
||||
{
|
||||
if n< 4 then
|
||||
Begin
|
||||
if n < 2 then
|
||||
EXIT(false);
|
||||
EXIT(true);
|
||||
end;
|
||||
if n = 5 then
|
||||
exit(true);}
|
||||
if (n AND 1 = 0) then
|
||||
EXIT(false);
|
||||
q := n div 3;
|
||||
if n - 3*q = 0 then
|
||||
EXIT(false);
|
||||
p := 5;
|
||||
{$CodeAlign loop=1}
|
||||
repeat
|
||||
q := n div p;
|
||||
if n-q*p = 0 then
|
||||
EXIT(false);
|
||||
p += 2;
|
||||
q := n div p;
|
||||
if n-q*p = 0 then
|
||||
EXIT(false);
|
||||
if q < p then
|
||||
break;
|
||||
p += 4;
|
||||
until false;
|
||||
EXIT(true);
|
||||
end;
|
||||
|
||||
function FirstPrimeCyclops(cnt:NativeInt):tCN;
|
||||
var
|
||||
i: NativeInt;
|
||||
begin
|
||||
i := 0;
|
||||
setlength(Cyclops,cnt);
|
||||
InitCycNum(result);
|
||||
while i<cnt do
|
||||
begin
|
||||
if isPrime(result.cnNum) then
|
||||
Begin
|
||||
Cyclops[i] := result.cnNum;
|
||||
inc(i);
|
||||
end;
|
||||
NextCycNum(result);
|
||||
end;
|
||||
repeat
|
||||
if isPrime(result.cnNum) then
|
||||
begin;
|
||||
inc(i);
|
||||
if result.cnNum > BIGLIMIT then
|
||||
BREAK;
|
||||
end;
|
||||
NextCycNum(result);
|
||||
until false;
|
||||
result.cnIdx := i;
|
||||
end;
|
||||
|
||||
function FirstBlindPrimeCyclops(cnt:NativeInt):tCN;
|
||||
var
|
||||
n: Uint64;
|
||||
i: NativeInt;
|
||||
isPr:Boolean;
|
||||
begin
|
||||
i := 0;
|
||||
setlength(Cyclops,cnt);
|
||||
InitCycNum(result);
|
||||
while i< cnt do
|
||||
begin
|
||||
with result do
|
||||
if isPrime(cnNum) then
|
||||
Begin
|
||||
n:= cnRight.nmNum;
|
||||
if cndigits > 0 then
|
||||
n += cnLeft.nmNum*cnPow10Shift[cndigits-1]
|
||||
else
|
||||
n += cnLeft.nmNum*10;
|
||||
if isPrime(n) then
|
||||
Begin
|
||||
Cyclops[i] := cnNum;
|
||||
inc(i);
|
||||
end;
|
||||
end;
|
||||
NextCycNum(result);
|
||||
end;
|
||||
repeat
|
||||
with result do
|
||||
if isPrime(cnNum) then
|
||||
Begin
|
||||
n:= cnRight.nmNum;
|
||||
if cndigits > 0 then
|
||||
n += cnLeft.nmNum*cnPow10Shift[cndigits-1]
|
||||
else
|
||||
n += cnLeft.nmNum*10;
|
||||
isPr:= isPrime(n);
|
||||
inc(i,Ord(isPr));
|
||||
if isPr AND (cnNum > BIGLIMIT) then
|
||||
BREAK;
|
||||
end;
|
||||
NextCycNum(result);
|
||||
until false;
|
||||
result.cnIdx := i;
|
||||
end;
|
||||
|
||||
function FirstPalinPrimeCyclops(cnt:NativeInt):tCN;
|
||||
var
|
||||
i: NativeInt;
|
||||
begin
|
||||
i := 0;
|
||||
setlength(Cyclops,cnt);
|
||||
InitCycNum(result);
|
||||
while i< cnt do
|
||||
Begin
|
||||
MakePalinCycNum(result);
|
||||
with result do
|
||||
if isPrime(cnNum) then
|
||||
Begin
|
||||
Cyclops[i] := cnNum;
|
||||
inc(i);
|
||||
end;
|
||||
IncLeftCn(result);
|
||||
while Not(result.cnLeft.nmdgts[result.cnDigits]+1 in [1,3,7,9]) do
|
||||
IncLeftCn(result);
|
||||
end;
|
||||
|
||||
repeat
|
||||
MakePalinCycNum(result);
|
||||
with result do
|
||||
if isPrime(cnNum) then
|
||||
begin
|
||||
inc(i);
|
||||
if cnNum >BIGLIMIT then
|
||||
break;
|
||||
end;
|
||||
IncLeftCn(result);
|
||||
while Not(result.cnLeft.nmdgts[result.cnDigits]+1 in [1,3,7,9]) do
|
||||
IncLeftCn(result);
|
||||
until false;
|
||||
result.cnIdx := i;
|
||||
end;
|
||||
|
||||
var
|
||||
cycnum:tCN;
|
||||
T0 : Int64;
|
||||
cnt : NativeUint;
|
||||
begin
|
||||
InitCnMinPow;
|
||||
|
||||
cnt := 50;
|
||||
writeln('The first ',cnt,' cyclops numbers are:');
|
||||
cycnum := FirstCyclops(cnt);
|
||||
Out_Cyclops(Cyclops,5,10);
|
||||
writeln('First such number > ',BIGLIMIT,' is ',cycnum.cnNum,
|
||||
' at zero-based index ',cycnum.cnIdx);
|
||||
writeln;
|
||||
|
||||
cnt := 50;
|
||||
writeln('The first ',cnt,' prime cyclops numbers are:');
|
||||
T0 := GetTickCount64;
|
||||
cycnum := FirstPrimeCyclops(cnt);
|
||||
T0 := GetTickCOunt64-T0;
|
||||
Out_Cyclops(Cyclops,7,10);
|
||||
writeln('First such number > ',BIGLIMIT,' is ',cycnum.cnNum,
|
||||
' at one-based index ',cycnum.cnIdx);
|
||||
writeln(cycnum.cnIdx,'.th = ',cycnum.cnNum,' in ',T0/1000:6:3,' s');
|
||||
writeln;
|
||||
|
||||
cnt := 50;
|
||||
writeln('The first ',cnt,' blind prime cyclops numbers are:');
|
||||
T0 := GetTickCount64;
|
||||
cycnum := FirstBlindPrimeCyclops(cnt);
|
||||
T0 := GetTickCOunt64-T0;
|
||||
Out_Cyclops(Cyclops,7,10);
|
||||
writeln('First such number > ',BIGLIMIT,' is ',cycnum.cnNum,
|
||||
' at one-based index ',cycnum.cnIdx);
|
||||
writeln(cycnum.cnIdx,'.th = ',cycnum.cnNum,' in ',T0/1000:6:3,' s');
|
||||
writeln;
|
||||
|
||||
cnt := 50;
|
||||
writeln('The first ',cnt,' palindromatic prime cyclops numbers are:');
|
||||
cycnum := FirstPalinPrimeCyclops(cnt);
|
||||
Out_Cyclops(Cyclops,15,5);
|
||||
writeln('First such number > ',BIGLIMIT,' is ',cycnum.cnNum,
|
||||
' at one-based index ',cycnum.cnIdx);
|
||||
writeln;
|
||||
|
||||
cnt := 100;
|
||||
repeat
|
||||
write(cnt:17,'.th = ');
|
||||
if cnt <= 10*1000 then
|
||||
Begin
|
||||
InitCycNum(cycnum);
|
||||
repeat
|
||||
NextCycNum(cycnum);
|
||||
until cycnum.cnIdx = cnt;
|
||||
write(cycnum.cnNum);
|
||||
end;
|
||||
cycnum:= IndexToCyclops(cnt);
|
||||
writeln(' calc ',cycnum.cnNum);
|
||||
cnt *= 10;
|
||||
until cnt >1000*1000*1000*1000*1000;
|
||||
end.
|
||||
36
Task/Cyclops-numbers/Perl/cyclops-numbers.pl
Normal file
36
Task/Cyclops-numbers/Perl/cyclops-numbers.pl
Normal file
|
|
@ -0,0 +1,36 @@
|
|||
use strict;
|
||||
use warnings;
|
||||
use feature 'say';
|
||||
use ntheory 'is_prime';
|
||||
use List::AllUtils 'firstidx';
|
||||
|
||||
sub comma { reverse ((reverse shift) =~ s/(.{3})/$1,/gr) =~ s/^,//r }
|
||||
|
||||
my @cyclops = 0;
|
||||
for my $exp (0..3) {
|
||||
my @oom = grep { ! /0/ } 10**$exp .. 10**($exp+1)-1;
|
||||
for my $l (@oom) {
|
||||
for my $r (@oom) {
|
||||
push @cyclops, $l . '0' . $r;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
my @prime_cyclops = grep { is_prime $_ } @cyclops;
|
||||
my @prime_blind = grep { is_prime $_ =~ s/0//r } @prime_cyclops;
|
||||
my @prime_palindr = grep { $_ eq reverse $_ } @prime_cyclops;
|
||||
|
||||
my $upto = 50;
|
||||
my $over = 10_000_000;
|
||||
|
||||
for (
|
||||
['', @cyclops],
|
||||
['prime', @prime_cyclops],
|
||||
['blind prime', @prime_blind],
|
||||
['palindromic prime', @prime_palindr]) {
|
||||
my($text,@values) = @$_;
|
||||
my $i = firstidx { $_ > $over } @values;
|
||||
say "First $upto $text cyclops numbers:\n" .
|
||||
(sprintf "@{['%8d' x $upto]}", @values[0..$upto-1]) =~ s/(.{80})/$1\n/gr;
|
||||
printf "First $text number > %s: %s at (zero based) index: %s\n\n", map { comma($_) } $over, $values[$i], $i;
|
||||
}
|
||||
69
Task/Cyclops-numbers/Phix/cyclops-numbers-1.phix
Normal file
69
Task/Cyclops-numbers/Phix/cyclops-numbers-1.phix
Normal file
|
|
@ -0,0 +1,69 @@
|
|||
(phixonline)-->
|
||||
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
|
||||
<span style="color: #004080;">atom</span> <span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()</span>
|
||||
<span style="color: #008080;">function</span> <span style="color: #000000;">bump</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">half</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #000080;font-style:italic;">-- add a digit to valid halves
|
||||
-- eg {0} --> {1..9} (no zeroes)
|
||||
-- --> {11..99} ("")
|
||||
-- --> {111..999}, etc</span>
|
||||
<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</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;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">half</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
|
||||
<span style="color: #004080;">integer</span> <span style="color: #000000;">hi</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">half</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]*</span><span style="color: #000000;">10</span>
|
||||
<span style="color: #008080;">for</span> <span style="color: #000000;">digit</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">9</span> <span style="color: #008080;">do</span>
|
||||
<span style="color: #000000;">res</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">hi</span><span style="color: #0000FF;">+</span><span style="color: #000000;">digit</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
|
||||
<span style="color: #008080;">return</span> <span style="color: #000000;">res</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
|
||||
|
||||
<span style="color: #008080;">procedure</span> <span style="color: #000000;">cyclops</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">=</span><span style="color: #008000;">""</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{},</span>
|
||||
<span style="color: #000000;">half</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">0</span><span style="color: #0000FF;">}</span> <span style="color: #000080;font-style:italic;">-- valid digits, see bump()</span>
|
||||
<span style="color: #004080;">integer</span> <span style="color: #000000;">left</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000080;font-style:italic;">-- half[] before the 0</span>
|
||||
<span style="color: #000000;">right</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000080;font-style:italic;">-- half[] after the 0</span>
|
||||
<span style="color: #000000;">hlen</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000080;font-style:italic;">-- length(half)</span>
|
||||
<span style="color: #000000;">cpow</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">10</span><span style="color: #0000FF;">,</span> <span style="color: #000080;font-style:italic;">-- cyclops power (of 10)</span>
|
||||
<span style="color: #000000;">bcpow</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000080;font-style:italic;">-- blind cyclops power</span>
|
||||
<span style="color: #000000;">cn</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span> <span style="color: #000080;font-style:italic;">-- cyclops number (scratch)</span>
|
||||
<span style="color: #004080;">bool</span> <span style="color: #000000;">valid</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">false</span><span style="color: #0000FF;">,</span>
|
||||
<span style="color: #000000;">bPrime</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">match</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"prime"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">s</span><span style="color: #0000FF;">),</span>
|
||||
<span style="color: #000000;">bBlind</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">match</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"blind"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">s</span><span style="color: #0000FF;">),</span>
|
||||
<span style="color: #000000;">bPalin</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">match</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"palindromic"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #008080;">while</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)<</span><span style="color: #000000;">50</span> <span style="color: #008080;">or</span> <span style="color: #000000;">cn</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">1e7</span> <span style="color: #008080;">or</span> <span style="color: #008080;">not</span> <span style="color: #000000;">valid</span> <span style="color: #008080;">do</span>
|
||||
<span style="color: #000000;">right</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
|
||||
<span style="color: #008080;">if</span> <span style="color: #000000;">right</span><span style="color: #0000FF;">></span><span style="color: #000000;">hlen</span> <span style="color: #008080;">then</span>
|
||||
<span style="color: #000000;">right</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>
|
||||
<span style="color: #000000;">left</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
|
||||
<span style="color: #008080;">if</span> <span style="color: #000000;">left</span><span style="color: #0000FF;">></span><span style="color: #000000;">hlen</span> <span style="color: #008080;">then</span>
|
||||
<span style="color: #000000;">half</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">bump</span><span style="color: #0000FF;">(</span><span style="color: #000000;">half</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #000000;">hlen</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">half</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #000000;">cpow</span> <span style="color: #0000FF;">*=</span> <span style="color: #000000;">10</span>
|
||||
<span style="color: #000000;">bcpow</span> <span style="color: #0000FF;">*=</span> <span style="color: #000000;">10</span>
|
||||
<span style="color: #000000;">left</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
|
||||
<span style="color: #004080;">integer</span> <span style="color: #000000;">lh</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">half</span><span style="color: #0000FF;">[</span><span style="color: #000000;">left</span><span style="color: #0000FF;">],</span>
|
||||
<span style="color: #000000;">rh</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">half</span><span style="color: #0000FF;">[</span><span style="color: #000000;">right</span><span style="color: #0000FF;">]</span>
|
||||
<span style="color: #000000;">cn</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">lh</span><span style="color: #0000FF;">*</span><span style="color: #000000;">cpow</span><span style="color: #0000FF;">+</span><span style="color: #000000;">rh</span> <span style="color: #000080;font-style:italic;">-- cyclops number</span>
|
||||
<span style="color: #000000;">valid</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">not</span> <span style="color: #000000;">bPrime</span> <span style="color: #008080;">or</span> <span style="color: #7060A8;">is_prime</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cn</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #008080;">if</span> <span style="color: #000000;">valid</span> <span style="color: #008080;">and</span> <span style="color: #000000;">bBlind</span> <span style="color: #008080;">then</span>
|
||||
<span style="color: #000000;">valid</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">is_prime</span><span style="color: #0000FF;">(</span><span style="color: #000000;">lh</span><span style="color: #0000FF;">*</span><span style="color: #000000;">bcpow</span><span style="color: #0000FF;">+</span><span style="color: #000000;">rh</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
|
||||
<span style="color: #008080;">if</span> <span style="color: #000000;">valid</span> <span style="color: #008080;">and</span> <span style="color: #000000;">bPalin</span> <span style="color: #008080;">then</span>
|
||||
<span style="color: #000000;">valid</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%d"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">lh</span><span style="color: #0000FF;">)</span> <span style="color: #0000FF;">==</span> <span style="color: #7060A8;">reverse</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%d"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">rh</span><span style="color: #0000FF;">))</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
|
||||
<span style="color: #008080;">if</span> <span style="color: #000000;">valid</span> <span style="color: #008080;">then</span>
|
||||
<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%7d"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">cn</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;">while</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;">"First 50 %scyclops numbers:\n%s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join_by</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">50</span><span style="color: #0000FF;">],</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</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;">"First %scyclops number > 10,000,000: %s at (one based) index: %d\n\n"</span><span style="color: #0000FF;">,</span>
|
||||
<span style="color: #0000FF;">{</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">res</span><span style="color: #0000FF;">[$],</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)})</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
|
||||
|
||||
<span style="color: #000000;">cyclops</span><span style="color: #0000FF;">()</span>
|
||||
<span style="color: #000000;">cyclops</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"prime "</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #000000;">cyclops</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"blind prime "</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #000000;">cyclops</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"palindromic prime "</span><span style="color: #0000FF;">)</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;">t0</span><span style="color: #0000FF;">)</span>
|
||||
<!--
|
||||
36
Task/Cyclops-numbers/Phix/cyclops-numbers-2.phix
Normal file
36
Task/Cyclops-numbers/Phix/cyclops-numbers-2.phix
Normal file
|
|
@ -0,0 +1,36 @@
|
|||
(phixonline)-->
|
||||
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
|
||||
<span style="color: #004080;">atom</span> <span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()</span>
|
||||
<span style="color: #008080;">function</span> <span style="color: #000000;">bump</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">half</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (exactly the same as above)
|
||||
-- add a digit to valid halves
|
||||
-- eg {0} --> {1..9} (no zeroes)
|
||||
-- --> {11..99} ("")
|
||||
-- --> {111..999}, etc</span>
|
||||
<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</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;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">half</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
|
||||
<span style="color: #004080;">integer</span> <span style="color: #000000;">hi</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">half</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]*</span><span style="color: #000000;">10</span>
|
||||
<span style="color: #008080;">for</span> <span style="color: #000000;">digit</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">9</span> <span style="color: #008080;">do</span>
|
||||
<span style="color: #000000;">res</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">hi</span><span style="color: #0000FF;">+</span><span style="color: #000000;">digit</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
|
||||
<span style="color: #008080;">return</span> <span style="color: #000000;">res</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
|
||||
|
||||
<span style="color: #004080;">sequence</span> <span style="color: #000000;">half</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">0</span><span style="color: #0000FF;">}</span> <span style="color: #000080;font-style:italic;">-- valid digits, see bump()</span>
|
||||
<span style="color: #004080;">integer</span> <span style="color: #000000;">hlen</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span>
|
||||
<span style="color: #000000;">cpow</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">10</span> <span style="color: #000080;font-style:italic;">-- cyclops power (of 10)</span>
|
||||
<span style="color: #004080;">integer</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1_000_000_000</span>
|
||||
<span style="color: #004080;">atom</span> <span style="color: #000000;">hlen2</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>
|
||||
<span style="color: #008080;">while</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">></span><span style="color: #000000;">hlen2</span> <span style="color: #008080;">do</span>
|
||||
<span style="color: #000000;">n</span> <span style="color: #0000FF;">-=</span> <span style="color: #000000;">hlen2</span>
|
||||
<span style="color: #000000;">half</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">bump</span><span style="color: #0000FF;">(</span><span style="color: #000000;">half</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #000000;">hlen</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">half</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #000000;">hlen2</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">hlen</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #000000;">cpow</span> <span style="color: #0000FF;">*=</span> <span style="color: #000000;">10</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
|
||||
<span style="color: #004080;">integer</span> <span style="color: #000000;">left</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">/</span><span style="color: #000000;">hlen</span><span style="color: #0000FF;">)+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000080;font-style:italic;">-- half[] before the 0</span>
|
||||
<span style="color: #000000;">right</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">hlen</span><span style="color: #0000FF;">)+</span><span style="color: #000000;">1</span> <span style="color: #000080;font-style:italic;">-- half[] after the 0</span>
|
||||
<span style="color: #004080;">string</span> <span style="color: #000000;">fmt</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"The 1,000,000,000th cyclops number is %d (%s)\n"</span><span style="color: #0000FF;">,</span>
|
||||
<span style="color: #000000;">e</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;">t0</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: #000000;">fmt</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">half</span><span style="color: #0000FF;">[</span><span style="color: #000000;">left</span><span style="color: #0000FF;">]*</span><span style="color: #000000;">cpow</span><span style="color: #0000FF;">+</span><span style="color: #000000;">half</span><span style="color: #0000FF;">[</span><span style="color: #000000;">right</span><span style="color: #0000FF;">],</span><span style="color: #000000;">e</span><span style="color: #0000FF;">})</span>
|
||||
<!--
|
||||
79
Task/Cyclops-numbers/Python/cyclops-numbers.py
Normal file
79
Task/Cyclops-numbers/Python/cyclops-numbers.py
Normal file
|
|
@ -0,0 +1,79 @@
|
|||
from sympy import isprime
|
||||
|
||||
|
||||
def print50(a, width=8):
|
||||
for i, n in enumerate(a):
|
||||
print(f'{n: {width},}', end='\n' if (i + 1) % 10 == 0 else '')
|
||||
|
||||
|
||||
def generate_cyclops(maxdig=9):
|
||||
yield 0
|
||||
for d in range((maxdig + 1) // 2):
|
||||
arr = [str(i) for i in range(10**d, 10**(d+1)) if not('0' in str(i))]
|
||||
for left in arr:
|
||||
for right in arr:
|
||||
yield int(left + '0' + right)
|
||||
|
||||
|
||||
def generate_prime_cyclops():
|
||||
for c in generate_cyclops():
|
||||
if isprime(c):
|
||||
yield c
|
||||
|
||||
|
||||
def generate_blind_prime_cyclops():
|
||||
for c in generate_prime_cyclops():
|
||||
cstr = str(c)
|
||||
mid = len(cstr) // 2
|
||||
if isprime(int(cstr[:mid] + cstr[mid+1:])):
|
||||
yield c
|
||||
|
||||
|
||||
def generate_palindromic_cyclops(maxdig=9):
|
||||
for d in range((maxdig + 1) // 2):
|
||||
arr = [str(i) for i in range(10**d, 10**(d+1)) if not('0' in str(i))]
|
||||
for s in arr:
|
||||
yield int(s + '0' + s[::-1])
|
||||
|
||||
|
||||
def generate_palindromic_prime_cyclops():
|
||||
for c in generate_palindromic_cyclops():
|
||||
if isprime(c):
|
||||
yield c
|
||||
|
||||
|
||||
print('The first 50 cyclops numbers are:')
|
||||
gen = generate_cyclops()
|
||||
print50([next(gen) for _ in range(50)])
|
||||
for i, c in enumerate(generate_cyclops()):
|
||||
if c > 10000000:
|
||||
print(
|
||||
f'\nThe next cyclops number after 10,000,000 is {c} at position {i:,}.')
|
||||
break
|
||||
|
||||
print('\nThe first 50 prime cyclops numbers are:')
|
||||
gen = generate_prime_cyclops()
|
||||
print50([next(gen) for _ in range(50)])
|
||||
for i, c in enumerate(generate_prime_cyclops()):
|
||||
if c > 10000000:
|
||||
print(
|
||||
f'\nThe next prime cyclops number after 10,000,000 is {c} at position {i:,}.')
|
||||
break
|
||||
|
||||
print('\nThe first 50 blind prime cyclops numbers are:')
|
||||
gen = generate_blind_prime_cyclops()
|
||||
print50([next(gen) for _ in range(50)])
|
||||
for i, c in enumerate(generate_blind_prime_cyclops()):
|
||||
if c > 10000000:
|
||||
print(
|
||||
f'\nThe next blind prime cyclops number after 10,000,000 is {c} at position {i:,}.')
|
||||
break
|
||||
|
||||
print('\nThe first 50 palindromic prime cyclops numbers are:')
|
||||
gen = generate_palindromic_prime_cyclops()
|
||||
print50([next(gen) for _ in range(50)], 11)
|
||||
for i, c in enumerate(generate_palindromic_prime_cyclops()):
|
||||
if c > 10000000:
|
||||
print(
|
||||
f'\nThe next palindromic prime cyclops number after 10,000,000 is {c} at position {i}.')
|
||||
break
|
||||
55
Task/Cyclops-numbers/REXX/cyclops-numbers.rexx
Normal file
55
Task/Cyclops-numbers/REXX/cyclops-numbers.rexx
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
/*REXX pgm finds 1st N cyclops (Θ) #s, Θ primes, blind Θ primes, palindromic Θ primes*/
|
||||
parse arg n cols . /*obtain optional argument from the CL.*/
|
||||
if n=='' | n=="," then n= 50 /*Not specified? Then use the default.*/
|
||||
if cols=='' | cols=="," then cols= 10 /* " " " " " " */
|
||||
call genP /*build array of semaphores for primes.*/
|
||||
w= max(10, length( commas(@.#) ) ) /*max width of a number in any column. */
|
||||
pri?= 0; bli?= 0; pal?= 0; call 0 ' first ' commas(n) " cyclops numbers"
|
||||
pri?= 1; bli?= 0; pal?= 0; call 0 ' first ' commas(n) " prime cyclops numbers"
|
||||
pri?= 1; bli?= 1; pal?= 0; call 0 ' first ' commas(n) " blind prime cyclops numbers"
|
||||
pri?= 1; bli?= 0; pal?= 1; call 0 ' first ' commas(n) " palindromic prime cyclops numbers"
|
||||
exit 0 /*stick a fork in it, we're all done. */
|
||||
/*──────────────────────────────────────────────────────────────────────────────────────*/
|
||||
commas: parse arg ?; do jc=length(?)-3 to 1 by -3; ?=insert(',', ?, jc); end; return ?
|
||||
/*──────────────────────────────────────────────────────────────────────────────────────*/
|
||||
0: parse arg title; idx= 1 /*get the title of this output section.*/
|
||||
say ' index │'center(title, 1 + cols*(w+1) ) /*display the output title. */
|
||||
say '───────┼'center("" , 1 + cols*(w+1), '─') /* " " " separator*/
|
||||
finds= 0; $= /*the number of finds (so far); $ list.*/
|
||||
do j=0 until finds== n; L= length(j) /*find N cyclops numbers, start at 101.*/
|
||||
if L//2==0 then do; j= left(1, L+1, 0) /*Is J an even # of digits? Yes, bump J*/
|
||||
iterate /*use a new J that has odd # of digits.*/
|
||||
end
|
||||
z= pos(0, j); if z\==(L+1)%2 then iterate /* " " " " (zero in mid)? " */
|
||||
if pos(0, j, z+1)>0 then iterate /* " " " " (has two 0's)? " */
|
||||
if pri? then if \!.j then iterate /*Need a cyclops prime? Then skip.*/
|
||||
if bli? then do; ?= space(translate(j, , 0), 0) /*Need a blind cyclops prime ?*/
|
||||
if \!.? then iterate /*Not a blind cyclops prime? Then skip.*/
|
||||
end
|
||||
if pal? then do; r= reverse(j) /*Need a palindromic cyclops prime? */
|
||||
if r\==j then iterate /*Cyclops number not palindromic? Skip.*/
|
||||
if \!.r then iterate /* " palindrome not prime? " */
|
||||
end
|
||||
finds= finds + 1 /*bump the number of palindromic primes*/
|
||||
$= $ right( commas(j), w) /*add a palindromic prime ──► $ list.*/
|
||||
if finds//cols\==0 then iterate /*have we populated a line of output? */
|
||||
say center(idx, 7)'│' substr($, 2); $= /*display what we have so far (cols). */
|
||||
idx= idx + cols /*bump the index count for the output*/
|
||||
end /*j*/
|
||||
if $\=='' then say center(idx, 7)"│" substr($, 2) /*possible show residual output.*/
|
||||
say '───────┴'center("" , 1 + cols*(w+1), '─'); say
|
||||
return
|
||||
/*──────────────────────────────────────────────────────────────────────────────────────*/
|
||||
genP: !.= 0; hip= 7890987 - 1 /*placeholders for primes (semaphores).*/
|
||||
@.1=2; @.2=3; @.3=5; @.4=7; @.5=11; @.6=13 /*define some low primes. */
|
||||
!.2=1; !.3=1; !.5=1; !.7=1; !.11=1; !.13=1 /* " " " " flags. */
|
||||
#= 6; sq.#= @.# ** 2 /*number of primes so far; prime square*/
|
||||
do j=@.#+2 by 2 for max(0, hip%2-@.#%2-1) /*find odd primes from here on. */
|
||||
parse var j '' -1 _ /*get the last dec. digit of J.*/
|
||||
if _==5 then iterate; if j// 3==0 then iterate /*÷ by 5? ÷ by 3? Skip.*/
|
||||
if j// 7==0 then iterate; if j//11==0 then iterate /*÷ " 7? ÷ by 11? " */
|
||||
do k=6 while sq.k<=j /* [↓] divide by the known odd primes.*/
|
||||
if j // @.k == 0 then iterate j /*Is J ÷ X? Then not prime. ___ */
|
||||
end /*k*/ /* [↑] only process numbers ≤ √ J */
|
||||
#= #+1; @.#= j; sq.#= j*j; !.j= 1 /*bump # Ps; assign next P; P sq; P# */
|
||||
end /*j*/; return
|
||||
18
Task/Cyclops-numbers/Raku/cyclops-numbers.raku
Normal file
18
Task/Cyclops-numbers/Raku/cyclops-numbers.raku
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
use Lingua::EN::Numbers;
|
||||
|
||||
my @cyclops = 0, |flat lazy ^∞ .map: -> $exp {
|
||||
my @oom = (exp($exp, 10) ..^ exp($exp + 1, 10)).grep: { !.contains: 0 }
|
||||
|@oom.hyper.map: { $_ ~ 0 «~« @oom }
|
||||
}
|
||||
|
||||
my @prime-cyclops = @cyclops.grep: { .is-prime };
|
||||
|
||||
for '', @cyclops,
|
||||
'prime ', @prime-cyclops,
|
||||
'blind prime ', @prime-cyclops.grep( { .trans('0' => '').is-prime } ),
|
||||
'palindromic prime ', @prime-cyclops.grep( { $_ eq .flip } )
|
||||
-> $type, $iterator {
|
||||
say "\n\nFirst 50 {$type}cyclops numbers:\n" ~ $iterator[^50].batch(10)».fmt("%7d").join("\n") ~
|
||||
"\n\nFirst {$type}cyclops number > 10,000,000: " ~ comma($iterator.first: * > 1e7 ) ~
|
||||
" - at (zero based) index: " ~ comma $iterator.first: * > 1e7, :k;
|
||||
}
|
||||
24
Task/Cyclops-numbers/Ruby/cyclops-numbers.rb
Normal file
24
Task/Cyclops-numbers/Ruby/cyclops-numbers.rb
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
require 'prime'
|
||||
|
||||
NONZEROS = %w(1 2 3 4 5 6 7 8 9)
|
||||
|
||||
cyclopes = Enumerator.new do |y|
|
||||
(0..).each do |n|
|
||||
NONZEROS.repeated_permutation(n) do |lside|
|
||||
NONZEROS.repeated_permutation(n) do |rside|
|
||||
y << (lside.join + "0" + rside.join).to_i
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
prime_cyclopes = Enumerator.new {|y| cyclopes.each {|c| y << c if c.prime?} }
|
||||
blind_prime_cyclopes = Enumerator.new {|y| prime_cyclopes.each {|c| y << c if c.to_s.delete("0").to_i.prime?} }
|
||||
palindromic_prime_cyclopes = Enumerator.new {|y| prime_cyclopes.each {|c| y << c if c.to_s == c.to_s.reverse} }
|
||||
|
||||
n, m = 50, 10_000_000
|
||||
["cyclopes", "prime cyclopes", "blind prime cyclopes", "palindromic prime cyclopes"].zip(
|
||||
[cyclopes, prime_cyclopes, blind_prime_cyclopes, palindromic_prime_cyclopes]).each do |name, enum|
|
||||
cycl, idx = enum.each_with_index.detect{|n, i| n > m}
|
||||
puts "The first #{n} #{name} are: \n#{enum.take(n).to_a}\nFirst #{name} term > #{m}: #{cycl} at index: #{idx}.", ""
|
||||
end
|
||||
84
Task/Cyclops-numbers/Sidef/cyclops-numbers.sidef
Normal file
84
Task/Cyclops-numbers/Sidef/cyclops-numbers.sidef
Normal file
|
|
@ -0,0 +1,84 @@
|
|||
func cyclops_numbers(base = 10) {
|
||||
Enumerator({|callback|
|
||||
|
||||
var digits = @(1 .. base-1)
|
||||
|
||||
for k in (0 .. Inf `by` 2) {
|
||||
digits.variations_with_repetition(k, {|*a|
|
||||
a = (a.first(a.len>>1) + [0] + a.last(a.len>>1))
|
||||
callback(a.flip.digits2num(base))
|
||||
})
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func palindromic_cyclops_numbers(base = 10) {
|
||||
Enumerator({|callback|
|
||||
|
||||
var digits = @(1 .. base-1)
|
||||
|
||||
for k in (0..Inf) {
|
||||
digits.variations_with_repetition(k, {|*a|
|
||||
a = (a + [0] + a.flip)
|
||||
callback(a.flip.digits2num(base))
|
||||
})
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func prime_cyclops(base = 10) {
|
||||
var iter = cyclops_numbers(base)
|
||||
Enumerator({|callback|
|
||||
iter.each {|n|
|
||||
callback(n) if n.is_prime
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func blind_prime_cyclops(base = 10) {
|
||||
var iter = prime_cyclops(base)
|
||||
Enumerator({|callback|
|
||||
iter.each {|n|
|
||||
var k = (n.len(base)-1)>>1
|
||||
var r = ipow(base, k)
|
||||
if (r*idiv(n, r*base) + n%r -> is_prime) {
|
||||
callback(n)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func palindromic_prime_cyclops(base = 10) {
|
||||
var iter = palindromic_cyclops_numbers(base)
|
||||
Enumerator({|callback|
|
||||
iter.each {|n|
|
||||
callback(n) if n.is_prime
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
for text,f in ([
|
||||
['', cyclops_numbers],
|
||||
['prime', prime_cyclops],
|
||||
['blind prime', blind_prime_cyclops],
|
||||
['palindromic prime', palindromic_prime_cyclops],
|
||||
]) {
|
||||
|
||||
with (50) {|k|
|
||||
say "First #{k} #{text} cyclops numbers:"
|
||||
f().first(k).each_slice(10, {|*a|
|
||||
a.map { '%7s' % _ }.join(' ').say
|
||||
})
|
||||
}
|
||||
|
||||
var min = 10_000_000
|
||||
var iter = f()
|
||||
var index = 0
|
||||
var arr = Enumerator({|callback|
|
||||
iter.each {|n|
|
||||
callback([index, n]) if (n > min)
|
||||
++index
|
||||
}
|
||||
}).first(1)[0]
|
||||
say "\nFirst #{text} term > #{min.commify}: #{arr[1].commify} at (zero based) index: #{arr[0].commify}\n"
|
||||
}
|
||||
58
Task/Cyclops-numbers/Wren/cyclops-numbers.wren
Normal file
58
Task/Cyclops-numbers/Wren/cyclops-numbers.wren
Normal file
|
|
@ -0,0 +1,58 @@
|
|||
import "/math" for Int
|
||||
import "/seq" for Lst
|
||||
import "/fmt" for Fmt
|
||||
import "/str" for Str
|
||||
|
||||
var findFirst = Fn.new { |list|
|
||||
var i = 0
|
||||
for (n in list) {
|
||||
if (n > 1e7) return [n, i]
|
||||
i = i + 1
|
||||
}
|
||||
}
|
||||
|
||||
var ranges = [0..0, 101..909, 11011..99099, 1110111..9990999, 111101111..119101111]
|
||||
var cyclops = []
|
||||
for (r in ranges) {
|
||||
var numDigits = r.from.toString.count
|
||||
var center = (numDigits / 2).floor
|
||||
for (i in r) {
|
||||
var digits = Int.digits(i)
|
||||
if (digits[center] == 0 && digits.count { |d| d == 0 } == 1) cyclops.add(i)
|
||||
}
|
||||
}
|
||||
|
||||
System.print("The first 50 cyclops numbers are:")
|
||||
var candidates = cyclops[0...50]
|
||||
var ni = findFirst.call(cyclops)
|
||||
for (chunk in Lst.chunks(candidates, 10)) Fmt.print("$,6d", chunk)
|
||||
Fmt.print("\nFirst such number > 10 million is $,d at zero-based index $,d", ni[0], ni[1])
|
||||
|
||||
System.print("\n\nThe first 50 prime cyclops numbers are:")
|
||||
var primes = cyclops.where { |n| Int.isPrime(n) }
|
||||
candidates = primes.take(50).toList
|
||||
ni = findFirst.call(primes)
|
||||
for (chunk in Lst.chunks(candidates, 10)) Fmt.print("$,6d", chunk)
|
||||
Fmt.print("\nFirst such number > 10 million is $,d at zero-based index $,d", ni[0], ni[1])
|
||||
|
||||
System.print("\n\nThe first 50 blind prime cyclops numbers are:")
|
||||
var bpcyclops = []
|
||||
var ppcyclops = []
|
||||
for (p in primes) {
|
||||
var ps = p.toString
|
||||
var numDigits = ps.count
|
||||
var center = (numDigits/2).floor
|
||||
var noMiddle = Num.fromString(Str.delete(ps, center))
|
||||
if (Int.isPrime(noMiddle)) bpcyclops.add(p)
|
||||
if (ps == ps[-1..0]) ppcyclops.add(p)
|
||||
}
|
||||
candidates = bpcyclops[0...50]
|
||||
ni = findFirst.call(bpcyclops)
|
||||
for (chunk in Lst.chunks(candidates, 10)) Fmt.print("$,6d", chunk)
|
||||
Fmt.print("\nFirst such number > 10 million is $,d at zero-based index $,d", ni[0], ni[1])
|
||||
|
||||
System.print("\n\nThe first 50 palindromic prime cyclops numbers are:")
|
||||
candidates = ppcyclops[0...50]
|
||||
ni = findFirst.call(ppcyclops)
|
||||
for (chunk in Lst.chunks(candidates, 8)) Fmt.print("$,9d", chunk)
|
||||
Fmt.print("\nFirst such number > 10 million is $,d at zero-based index $,d", ni[0], ni[1])
|
||||
116
Task/Cyclops-numbers/XPL0/cyclops-numbers.xpl0
Normal file
116
Task/Cyclops-numbers/XPL0/cyclops-numbers.xpl0
Normal file
|
|
@ -0,0 +1,116 @@
|
|||
func IsCyclops(N); \Return 'true' if N is a cyclops number
|
||||
int N, I, J, K;
|
||||
char A(9);
|
||||
[I:= 0; \parse digits into array A
|
||||
repeat N:= N/10;
|
||||
A(I):= rem(0);
|
||||
I:= I+1;
|
||||
until N=0;
|
||||
if (I&1) = 0 then return false; \must have odd number of digits
|
||||
K:= I>>1;
|
||||
if A(K) # 0 then return false; \middle digit must be 0
|
||||
for J:= 0 to I-1 do \other digits must not be 0
|
||||
if A(J)=0 & J#K then return false;
|
||||
return true;
|
||||
];
|
||||
|
||||
func IsPrime(N); \Return 'true' if N > 2 is a prime number
|
||||
int N, I;
|
||||
[if (N&1) = 0 \even number\ then return false;
|
||||
for I:= 3 to sqrt(N) do
|
||||
[if rem(N/I) = 0 then return false;
|
||||
I:= I+1;
|
||||
];
|
||||
return true;
|
||||
];
|
||||
|
||||
func Blind(N); \Return blinded cyclops number
|
||||
int N, I, J, K; \i.e. center zero removed
|
||||
char A(9);
|
||||
[I:= 0; \parse digits into array A
|
||||
repeat N:= N/10;
|
||||
A(I):= rem(0);
|
||||
I:= I+1;
|
||||
until N=0;
|
||||
N:= A(I-1); \most significant digit
|
||||
K:= I>>1;
|
||||
for J:= I-2 downto 0 do
|
||||
if J#K then \skip middle zero
|
||||
N:= N*10 + A(J);
|
||||
return N;
|
||||
];
|
||||
|
||||
func Reverse(N); \Return N with its digits reversed
|
||||
int N, M;
|
||||
[M:= 0;
|
||||
repeat N:= N/10;
|
||||
M:= M*10 + rem(0);
|
||||
until N=0;
|
||||
return M;
|
||||
];
|
||||
|
||||
func IntLen(N); \Return number of decimal digits in N
|
||||
int N;
|
||||
int P, I;
|
||||
[P:= 10;
|
||||
for I:= 1 to 9 do \assumes N is 32-bits
|
||||
[if P>N then return I;
|
||||
P:= P*10;
|
||||
];
|
||||
return 10;
|
||||
];
|
||||
|
||||
int Count, N;
|
||||
|
||||
func Show; \Show results and return 'true' when done
|
||||
[Count:= Count+1;
|
||||
if Count <= 50 then
|
||||
[IntOut(0, N);
|
||||
if rem(Count/10) = 0 then CrLf(0) else ChOut(0, 9\tab\);
|
||||
];
|
||||
if N > 10_000_000 then
|
||||
[Text(0, "First such number > 10,000,000: ");
|
||||
IntOut(0, N);
|
||||
Text(0, " at zero based index: ");
|
||||
IntOut(0, Count-1);
|
||||
CrLf(0);
|
||||
return true;
|
||||
];
|
||||
return false;
|
||||
];
|
||||
|
||||
proc Common(Filter); \Common code gathered here
|
||||
int Filter;
|
||||
[Count:= 0;
|
||||
N:= 0;
|
||||
loop [if IsCyclops(N) then
|
||||
case Filter of
|
||||
0: if Show then quit;
|
||||
1: if IsPrime(N) then
|
||||
if Show then quit;
|
||||
2: if IsPrime(N) then if IsPrime(Blind(N)) then
|
||||
if Show then quit;
|
||||
3: if N=Reverse(N) then if IsPrime(N) then
|
||||
if Show then quit
|
||||
other [];
|
||||
N:= N+1;
|
||||
if (IntLen(N)&1) = 0 then N:= N*10; \must have odd number of digits
|
||||
];
|
||||
];
|
||||
|
||||
[Text(0, "First 50 cyclops numbers:
|
||||
");
|
||||
Common(0);
|
||||
Text(0, "
|
||||
First 50 prime cyclops numbers:
|
||||
");
|
||||
Common(1);
|
||||
Text(0, "
|
||||
First 50 blind prime cyclops numbers:
|
||||
");
|
||||
Common(2);
|
||||
Text(0, "
|
||||
First 50 palindromic prime cyclops numbers:
|
||||
");
|
||||
Common(3);
|
||||
]
|
||||
Loading…
Add table
Add a link
Reference in a new issue