# Cyclops numbers

Cyclops numbers is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

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.

• 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)

## ALGOL 68

Generates the sequence. <lang algol68>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 #
[ 1 : max prime ]BOOL prime;
prime[ 1 ] := FALSE; prime[ 2 ] := TRUE;
FOR i FROM 3 BY 2 TO UPB prime DO prime[ i ] := TRUE  OD;
FOR i FROM 4 BY 2 TO UPB prime DO prime[ i ] := FALSE OD;
FOR i FROM 3 BY 2 TO ENTIER sqrt( max prime ) DO
IF prime[ i ] THEN FOR s FROM i * i BY i + i TO UPB prime DO prime[ s ] := FALSE OD FI
OD;
# 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 := c MOD 2 = 0;
FOR d FROM 3 BY 2 TO c OVER 2 WHILE possibly prime := c MOD d /= 0 DO SKIP 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 # ;
# 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( ( "The first 50 cyclops numbers:", newline, "   " ) );
FOR i TO 50 DO
print( ( " ", whole( first cyclops[ i ], -7 ) ) );
IF i MOD 10 = 0 THEN print( ( newline, "   " ) ) FI
OD;
print( ( newline, "The first 50 prime cyclops numbers:", newline, "   " ) );
FOR i TO 50 DO
print( ( " ", whole( first prime cyclops[ i ], -7 ) ) );
IF i MOD 10 = 0 THEN print( ( newline, "   " ) ) FI
OD;
print( ( newline, "The first 50 palindromic prime cyclops numbers:", newline, "   " ) );
FOR i TO 50 DO
print( ( " ", whole( first palindromic prime cyclops[ i ], -7 ) ) );
IF i MOD 10 = 0 THEN print( ( newline, "   " ) ) FI
OD;
print( ( newline, "The first 50 blind prime cyclops numbers:", newline, "   " ) );
FOR i TO 50 DO
print( ( " ", whole( first blind prime cyclops[ i ], -7 ) ) );
IF i MOD 10 = 0 THEN print( ( newline, "   " ) ) FI
OD
```

END</lang>

Output:
```The 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 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 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 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
```

## Factor

An attempt to make it fast has resulted in a lot of code, but here's the basic idea. Cyclops numbers are stored in four parts: an integer representing whatever is to the left of the `0`, a right integer, the number of digits in either side, and the maximum number with that many digits. For example, `T{ cyclops f 33 34 2 99 }` represents the number `33034`. The left and right are zeroless; that is, they are not allowed to have any zeros.

In order to find the successor to a given cyclops number:

• Increment the right integer to the next zeroless integer using the following formula (from OEIS):

`a(n+1) = f(a(n)) with f(x) = 1 + if x mod 10 < 9 then x else 10*f([x/10])`

• Unless right = max, in which case increment the left integer instead in the same manner, and reset the right integer back to `max / 9`.
• Unless left = max, in which case we move up to the next order of magnitude by adding `max/9 + 1` to both sides, adding `1` to the number of digits, and setting the new max as `max := max * 10 + 9`

Cyclops numbers in this form can be converted to integers (as late as possible) with `int(c) = 10^(c.n + 1) * c.left + c.right`

where `n` is the number of digits in either side.

Cyclops numbers can be converted to blind form with the same formula without the `+ 1`.

Works with: Factor version 0.99 2021-06-02

<lang factor>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</lang>

Output:
```First 50 cyclops numbers:
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 605

First cyclops number > 10,000,000: 111,101,111 - at (zero based) index: 538,083.

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

First prime cyclops number > 10,000,000: 111,101,129 - at (zero based) index: 39,319.

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

First blind prime cyclops number > 10,000,000: 111,101,161 - at (zero based) index: 11,393.

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

First palindromic prime cyclops number > 10,000,000: 114,808,411 - at (zero based) index: 66.

One billionth cyclops number:
35,296,098,111
```

## Go

Translation of: Wren
Library: Go-rcu

<lang go>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)
```

}</lang>

Output:
```The first 50 cyclops numbers are:
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

First such number > 10 million is 111,101,111 at zero-based index 538,084

The first 50 prime cyclops numbers are:
101    103    107    109    307    401    409    503    509    601
607    701    709    809    907 11,027 11,047 11,057 11,059 11,069
11,071 11,083 11,087 11,093 12,011 12,037 12,041 12,043 12,049 12,071
12,073 12,097 13,033 13,037 13,043 13,049 13,063 13,093 13,099 14,011
14,029 14,033 14,051 14,057 14,071 14,081 14,083 14,087 15,013 15,017

First such number > 10 million is 111,101,129 at zero-based index 39,319

The first 50 blind prime cyclops numbers are:
101    103    107    109    307    401    503    509    601    607
701    709    809    907 11,071 11,087 11,093 12,037 12,049 12,097
13,099 14,029 14,033 14,051 14,071 14,081 14,083 14,087 15,031 15,053
15,083 16,057 16,063 16,067 16,069 16,097 17,021 17,033 17,041 17,047
17,053 17,077 18,047 18,061 18,077 18,089 19,013 19,031 19,051 19,073

First such number > 10 million is 111,101,161 at zero-based index 11,393

The first 50 palindromic prime cyclops numbers are:
101    16,061    31,013    35,053    38,083    73,037    74,047    91,019
94,049 1,120,211 1,150,511 1,160,611 1,180,811 1,190,911 1,250,521 1,280,821
1,360,631 1,390,931 1,490,941 1,520,251 1,550,551 1,580,851 1,630,361 1,640,461
1,660,661 1,670,761 1,730,371 1,820,281 1,880,881 1,930,391 1,970,791 3,140,413
3,160,613 3,260,623 3,310,133 3,380,833 3,460,643 3,470,743 3,590,953 3,670,763
3,680,863 3,970,793 7,190,917 7,250,527 7,310,137 7,540,457 7,630,367 7,690,967
7,750,577 7,820,287

First such number > 10 million is 114,808,411 at zero-based index 66
```

## Julia

Julia's indexes are 1 based, hence one greater than those of 0 based indices. <lang julia>using Primes

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
(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 isodd(l) && d[l ÷ 2 + 1] == 0 && count(x -> x == 0, d) == 1 && d == reverse(d)
```

end

function findcyclops(N, iscycs, nextcandidate)

```   i, list = 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 = 1, 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()

</lang>
Output:
```The first 50 cyclops numbers are:
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     605

The next cyclops number after 10,000,000 is 111101111 at position 538084.

The first 50 prime cyclops numbers are:
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 next prime cyclops number after 10,000,000 is 111101129 at position 39320.

The first 50 blind prime cyclops numbers are:
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 next prime cyclops number after 10,000,000 is 111101161 at position 11394.

The first 50 palindromic prime cyclops numbers are:
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 next prime cyclops number after 10,000,000 is 114808411 at position 67.
```

## Phix

Library: Phix/online

You can run this online here (however it is about 5x slower than desktop/Phix, so expect a blank screen for about 45s).

```with javascript_semantics

function bump(sequence s)
sequence res = {}
for i=1 to length(s) do
integer si = s[i]*10
for j=1 to 9 do
res &= si+j
end for
end for
return res
end function

procedure cyclops(string s="")
sequence res = {},
half = {0}
integer l = 1, r = 0, h = 1, p = 10, pb = 1, n = 0
bool valid = false,
bPrime = match("prime",s),
bBlind = match("blind",s),
bPalin = match("palindromic",s)
while length(res)<50 or n<=1e7 or not valid do
r += 1
if r>h then
r = 1
l += 1
if l>h then
half = bump(half)
h *= 9
p *= 10
pb *= 10
l = 1
end if
end if
integer lh = half[l],
rh = half[r]
n = lh*p+rh
valid = not bPrime or is_prime(n)
if valid and bBlind then
valid = is_prime(lh*pb+rh)
end if
if valid and bPalin then
valid = sprintf("%d",lh) == reverse(sprintf("%d",rh))
end if
if valid then
res = append(res,sprintf("%7d",n))
end if
end while
printf(1,"First 50 %scyclops numbers:\n%s\n",{s,join_by(res[1..50],1,10)})
printf(1,"First %scyclops number > 10,000,000: %s at (one based) index: %d\n\n",
{s,res[\$],length(res)})
end procedure

cyclops()
cyclops("prime ")
cyclops("blind prime ")
cyclops("palindromic prime ")
```
Output:
```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

First cyclops number > 10,000,000: 111101111 at (one based) index: 538085

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

First prime cyclops number > 10,000,000: 111101129 at (one based) index: 39320

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

First blind prime cyclops number > 10,000,000: 111101161 at (one based) index: 11394

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

First palindromic prime cyclops number > 10,000,000: 114808411 at (one based) index: 67
```

## Raku

<lang perl6>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;
```

}</lang>

Output:
```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

First cyclops number > 10,000,000: 111,101,111 - at (zero based) index: 538,084

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

First prime cyclops number > 10,000,000: 111,101,129 - at (zero based) index: 39,319

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

First blind prime cyclops number > 10,000,000: 111,101,161 - at (zero based) index: 11,393

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

First palindromic prime cyclops number > 10,000,000: 114,808,411 - at (zero based) index: 66```

## REXX

<lang rexx>/*REXX pprogram finds and displays the first fifty cyclops numbers, cyclops primes,*/ /*─────────────────────────────── blind cyclops primes, and palindromic cyclops 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. */

```                                     first= ' the first '
```

isPri= 0; isBli= 0; isPal= 0; call 0 first commas(n) " cyclops numbers" isPri= 1; isBli= 0; isPal= 0; call 0 first commas(n) " prime cyclops numbers" isPri= 1; isBli= 1; isPal= 0; call 0 first commas(n) " blind prime cyclops numbers" isPri= 1; isBli= 0; isPal= 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 /*get the title of this output section.*/

```  say ' index │'center(title,   1 + cols*(w+1)     )
say '───────┼'center(""   ,   1 + cols*(w+1), '─')
finds= 0;                   idx= 1            /*define # of a type of cyclops # & idx*/
\$=                                            /*\$: list of the numbers found (so far)*/
do j=0  until finds== n;   L= length(j)     /*\$: list of the numbers found (so far)*/
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 isPri  then if \!.j        then iterate  /*Need a cyclops prime?      Then skip.*/
if isBli  then do;   ?= space(translate(j,,0), 0)   /*Need a blind cyclops prime ? */
if \!.?  then iterate  /*Not a blind cyclops prime? Then skip.*/
end
if isPal  then do;   r= reverse(j)          /*Need a palindromic cyclops prime?    */
if r\==j then iterate  /*Cyclops number not palindromic? Skip.*/
if \!.r  then iterate  /*Cyclops palindromic not prime?  Skip.*/
end
finds= finds + 1                            /*bump the number of palindromic primes*/
if cols<0                     then iterate  /*Build the list  (to be shown later)? */
\$= \$ 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= 8000000 - 1 /*placeholders for primes (semaphores).*/

```     @.1=2;  @.2=3;  @.3=5;  @.4=7;  @.5=11     /*define some low primes.              */
!.2=1;  !.3=1;  !.5=1;  !.7=1;  !.11=1     /*   "     "   "    "     flags.       */
#=5;     s.#= @.# **2      /*number of primes so far;     prime². */
do j=@.#+2  by 2  to hip                 /*find odd primes from here on.        */
parse var j  -1 _; if     _==5  then iterate  /*J divisible by 5?  (right dig)*/
if j// 3==0  then iterate  /*"     "      " 3?             */
if j// 7==0  then iterate  /*"     "      " 7?             */
do k=5  while s.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;    s.#= j*j;   !.j= 1 /*bump # of Ps; assign next P;  P²; P# */
end          /*j*/;   return</lang>
```
output   when using the default inputs:
``` index │                                         the first  50  cyclops numbers
───────┼───────────────────────────────────────────────────────────────────────────────────────────────────────────────
1   │          0        101        102        103        104        105        106        107        108        109
11   │        201        202        203        204        205        206        207        208        209        301
21   │        302        303        304        305        306        307        308        309        401        402
31   │        403        404        405        406        407        408        409        501        502        503
41   │        504        505        506        507        508        509        601        602        603        604
───────┴───────────────────────────────────────────────────────────────────────────────────────────────────────────────

index │                                      the first  50  prime cyclops numbers
───────┼───────────────────────────────────────────────────────────────────────────────────────────────────────────────
1   │        101        103        107        109        307        401        409        503        509        601
11   │        607        701        709        809        907     11,027     11,047     11,057     11,059     11,069
21   │     11,071     11,083     11,087     11,093     12,011     12,037     12,041     12,043     12,049     12,071
31   │     12,073     12,097     13,033     13,037     13,043     13,049     13,063     13,093     13,099     14,011
41   │     14,029     14,033     14,051     14,057     14,071     14,081     14,083     14,087     15,013     15,017
───────┴───────────────────────────────────────────────────────────────────────────────────────────────────────────────

index │                                   the first  50  blind prime cyclops numbers
───────┼───────────────────────────────────────────────────────────────────────────────────────────────────────────────
1   │        101        103        107        109        307        401        503        509        601        607
11   │        701        709        809        907     11,071     11,087     11,093     12,037     12,049     12,097
21   │     13,099     14,029     14,033     14,051     14,071     14,081     14,083     14,087     15,031     15,053
31   │     15,083     16,057     16,063     16,067     16,069     16,097     17,021     17,033     17,041     17,047
41   │     17,053     17,077     18,047     18,061     18,077     18,089     19,013     19,031     19,051     19,073
───────┴───────────────────────────────────────────────────────────────────────────────────────────────────────────────

index │                                the first  50  palindromic prime cyclops numbers
───────┼───────────────────────────────────────────────────────────────────────────────────────────────────────────────
1   │        101     16,061     31,013     35,053     38,083     73,037     74,047     91,019     94,049  1,120,211
11   │  1,150,511  1,160,611  1,180,811  1,190,911  1,250,521  1,280,821  1,360,631  1,390,931  1,490,941  1,520,251
21   │  1,550,551  1,580,851  1,630,361  1,640,461  1,660,661  1,670,761  1,730,371  1,820,281  1,880,881  1,930,391
31   │  1,970,791  3,140,413  3,160,613  3,260,623  3,310,133  3,380,833  3,460,643  3,470,743  3,590,953  3,670,763
41   │  3,680,863  3,970,793  7,190,917  7,250,527  7,310,137  7,540,457  7,630,367  7,690,967  7,750,577  7,820,287
───────┴───────────────────────────────────────────────────────────────────────────────────────────────────────────────
```

## Wren

Library: Wren-seq
Library: Wren-fmt
Library: Wren-str

<lang ecmascript>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 (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])</lang>

Output:
```The first 50 cyclops numbers are:
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

First such number > 10 million is 111,101,111 at zero-based index 538,084

The first 50 prime cyclops numbers are:
101    103    107    109    307    401    409    503    509    601
607    701    709    809    907 11,027 11,047 11,057 11,059 11,069
11,071 11,083 11,087 11,093 12,011 12,037 12,041 12,043 12,049 12,071
12,073 12,097 13,033 13,037 13,043 13,049 13,063 13,093 13,099 14,011
14,029 14,033 14,051 14,057 14,071 14,081 14,083 14,087 15,013 15,017

First such number > 10 million is 111,101,129 at zero-based index 39,319

The first 50 blind prime cyclops numbers are:
101    103    107    109    307    401    503    509    601    607
701    709    809    907 11,071 11,087 11,093 12,037 12,049 12,097
13,099 14,029 14,033 14,051 14,071 14,081 14,083 14,087 15,031 15,053
15,083 16,057 16,063 16,067 16,069 16,097 17,021 17,033 17,041 17,047
17,053 17,077 18,047 18,061 18,077 18,089 19,013 19,031 19,051 19,073

First such number > 10 million is 111,101,161 at zero-based index 11,393

The first 50 palindromic prime cyclops numbers are:
101    16,061    31,013    35,053    38,083    73,037    74,047    91,019
94,049 1,120,211 1,150,511 1,160,611 1,180,811 1,190,911 1,250,521 1,280,821
1,360,631 1,390,931 1,490,941 1,520,251 1,550,551 1,580,851 1,630,361 1,640,461
1,660,661 1,670,761 1,730,371 1,820,281 1,880,881 1,930,391 1,970,791 3,140,413
3,160,613 3,260,623 3,310,133 3,380,833 3,460,643 3,470,743 3,590,953 3,670,763
3,680,863 3,970,793 7,190,917 7,250,527 7,310,137 7,540,457 7,630,367 7,690,967
7,750,577 7,820,287

First such number > 10 million is 114,808,411 at zero-based index 66
```