# Deceptive numbers

Repunits are numbers that consist entirely of repetitions of the digit one (unity). The notation Rn symbolizes the repunit made up of n ones.

Deceptive numbers
You are encouraged to solve this task according to the task description, using any language you may know.

Every prime p larger than 5, evenly divides the repunit Rp-1.

E.G.

The repunit R6 is evenly divisible by 7.

111111 / 7 = 15873

The repunit R42 is evenly divisible by 43.

111111111111111111111111111111111111111111 / 43 = 2583979328165374677002583979328165374677

And so on.

There are composite numbers that also have this same property. They are often referred to as deceptive non-primes or deceptive numbers.

The repunit R90 is evenly divisible by the composite number 91 (=7*13).

111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 / 91 = 1221001221001221001221001221001221001221001221001221001221001221001221001221001221001221

• Find and show at least the first 10 deceptive numbers; composite numbers n that evenly divide the repunit Rn-1

## ALGOL 68

Works with: ALGOL 68G version Any - tested with release 3.0.1.win32

As with the Phix, Wren and other samples we only consider odd n.

```BEGIN # find repunits (all digits are 1 ) such that R(n-1) is divisible by n and n is not prime #
# R(n) is the nth repunit, so has n 1s                                                    #
PR precision 8000 PR             # set precision of LONG LONG INT, enough for up to R(8000) #
PR read "primes.incl.a68" PR                                      # include prime utilities #
[]BOOL prime = PRIMESIEVE 8000;
LONG LONG INT repunit := 111 111;   # n must be odd as all repunits are odd, the lowest odd #
INT           r count := 0;          # non-prime is 9, so we start with repunit set to R(6) #
FOR n FROM 9 BY 2 WHILE r count < 15 DO
repunit *:= 100 +:= 11;                                       # gets R(n-1) from R(n-3) #
IF NOT prime[ n ] THEN
IF repunit MOD n = 0 THEN
# found non-prime n which divides R(n-1) #
print( ( " ", whole( n, 0 ) ) );
r count +:= 1
FI
FI
OD
END```
Output:
``` 91 259 451 481 703 1729 2821 2981 3367 4141 4187 5461 6533 6541 6601
```

## Arturo

```deceptive?: function [n][
and? -> not? prime? n
-> zero? (to :integer repeat "1" n-1) % n
]

cnt: 0
i: 3

while [cnt < 10][
if deceptive? i [
print i
cnt: cnt + 1
]
i: i + 2
]
```
Output:
```91
259
451
481
703
1729
2821
2981
3367
4141```

## C

```#include <stdio.h>

unsigned modpow(unsigned b, unsigned e, unsigned m)
{
unsigned p;
for (p = 1; e; e >>= 1) {
if (e & 1)
p = p * b % m;
b = b * b % m;
}
return p;
}

int is_deceptive(unsigned n)
{
unsigned x;
if (n & 1 && n % 3 && n % 5) {
for (x = 7; x * x <= n; x += 6) {
if (!(n % x && n % (x + 4)))
return modpow(10, n - 1, n) == 1;
}
}
return 0;
}

int main(void)
{
unsigned c, i = 49;
for (c = 0; c != 50; ++i) {
if (is_deceptive(i)) {
printf(" %u", i);
++c;
}
}
return 0;
}
```
Output:
` 91 259 451 481 703 1729 2821 2981 3367 4141 4187 5461 6533 6541 6601 7471 7777 8149 8401 8911 10001 11111 12403 13981 14701 14911 15211 15841 19201 21931 22321 24013 24661 27613 29341 34133 34441 35113 38503 41041 45527 46657 48433 50851 50881 52633 54913 57181 63139 63973`

## C++

Library: GMP
```#include <gmpxx.h>

#include <iomanip>
#include <iostream>

bool is_prime(int n) {
if (n < 2)
return false;
if (n % 2 == 0)
return n == 2;
if (n % 3 == 0)
return n == 3;
for (int p = 5; p * p <= n; p += 4) {
if (n % p == 0)
return false;
p += 2;
if (n % p == 0)
return false;
}
return true;
}

int main() {
std::cout << "First 100 deceptive numbers:\n";
mpz_class repunit = 11;
for (int n = 3, count = 0; count != 100; n += 2) {
if (n % 3 != 0 && n % 5 != 0 && !is_prime(n) &&
mpz_divisible_ui_p(repunit.get_mpz_t(), n))
std::cout << std::setw(6) << n << (++count % 10 == 0 ? '\n' : ' ');
repunit *= 100;
repunit += 11;
}
}
```
Output:
```First 100 deceptive numbers:
91    259    451    481    703   1729   2821   2981   3367   4141
4187   5461   6533   6541   6601   7471   7777   8149   8401   8911
10001  11111  12403  13981  14701  14911  15211  15841  19201  21931
22321  24013  24661  27613  29341  34133  34441  35113  38503  41041
45527  46657  48433  50851  50881  52633  54913  57181  63139  63973
65311  66991  67861  68101  75361  79003  82513  83119  94139  95161
97273  97681 100001 101101 101491 102173 108691 113201 115627 115921
118301 118957 122221 126217 128713 130351 131821 134821 134863 137137
137149 138481 139231 145181 147001 148417 152551 158497 162401 164761
166499 170017 172081 179881 188191 188269 188461 188501 196651 201917
```

## F#

This task uses Extensible Prime Generator (F#)

```// Deceptive numbers. Nigel Galloway: February 13th., 2022
Seq.unfold(fun n->Some(n|>Seq.filter(isPrime>>not)|>Seq.filter(fun n->(10I**(n-1)-1I)%(bigint n)=0I),n|>Seq.map((+)30)))(seq{1;7;11;13;17;19;23;29})|>Seq.concat|>Seq.skip 1
|>Seq.chunkBySize 10|>Seq.take 7|>Seq.iter(fun n->n|>Array.iter(printf "%7d "); printfn "")
```
Output:
```     91     259     451     481     703    1729    2821    2981    3367    4141
4187    5461    6533    6541    6601    7471    7777    8149    8401    8911
10001   11111   12403   13981   14701   14911   15211   15841   19201   21931
22321   24013   24661   27613   29341   34133   34441   35113   38503   41041
45527   46657   48433   50851   50881   52633   54913   57181   63139   63973
65311   66991   67861   68101   75361   79003   82513   83119   94139   95161
97273   97681  100001  101101  101491  102173  108691  113201  115627  115921
```

## Factor

Works with: Factor version 0.99 2021-06-02
```USING: io kernel lists lists.lazy math math.functions
math.primes prettyprint ;

: repunit ( m -- n ) 10^ 1 - 9 / ;

: composite ( -- list ) 4 lfrom [ prime? not ] lfilter ;

: deceptive ( -- list )
composite [ [ 1 - repunit ] keep divisor? ] lfilter ;

10 deceptive ltake [ pprint bl ] leach nl
```
Output:
```91 259 451 481 703 1729 2821 2981 3367 4141
```

## Fermat

```Func Rep(n)=Sigma<m=0,n-1>[10^m].;
c:=0;
n:=3;
while c<10 do
n:=n+1;
if Isprime(n)>1 and Divides(n,Rep(n-1)) then !!n; c:+; fi
od;```

## Go

Translation of: Wren
Library: Go-rcu
```package main

import (
"fmt"
"math/big"
"rcu"
)

func main() {
count := 0
limit := 25
n := int64(17)
repunit := big.NewInt(1111111111111111)
t := new(big.Int)
zero := new(big.Int)
eleven := big.NewInt(11)
hundred := big.NewInt(100)
var deceptive []int64
for count < limit {
if !rcu.IsPrime(int(n)) && n%3 != 0 && n%5 != 0 {
bn := big.NewInt(n)
if t.Rem(repunit, bn).Cmp(zero) == 0 {
deceptive = append(deceptive, n)
count++
}
}
n += 2
repunit.Mul(repunit, hundred)
}
fmt.Println("The first", limit, "deceptive numbers are:")
fmt.Println(deceptive)
}
```
Output:
```The first 25 deceptive numbers are:
[91 259 451 481 703 1729 2821 2981 3367 4141 4187 5461 6533 6541 6601 7471 7777 8149 8401 8911 10001 11111 12403 13981 14701]
```

## J

```R=: (10x #. #&1)"0
deceptive=: 1&p: < 0 = ] | R@<:

2+I.deceptive 2+i.10000
91 259 451 481 703 1729 2821 2981 3367 4141 4187 5461 6533 6541 6601 7471 7777 8149 8401 8911 10001
```

For improved performance:

```deceptives=: {{
r=.\$k=.10x #.}.1#~j=.9
while. y>#r do.
if. 0<2|j do.
if. 0<5|j do.
if. 0=1 p:j do.
if. 0=0]j|k do.
r=. r, j
end.
end.
end.
end.
k=. 1 10x p.k
j=. j+1
end.
r
}}
```
Output:
```   deceptives 21
91 259 451 481 703 1729 2821 2981 3367 4141 4187 5461 6533 6541 6601 7471 7777 8149 8401 8911 10001
```

## jq

Works with gojq and fq, the Go implementations of jq

The following program assumes integer arithmetic is sufficiently accurate. Both gojq and fq meet this requirement as they support unbounded precision integer arithmetic.

Execution time using gojq on a 3GHz machine: 0.20s

```def is_prime:
. as \$n
| if (\$n < 2)         then false
elif (\$n % 2 == 0)  then \$n == 2
elif (\$n % 3 == 0)  then \$n == 3
elif (\$n % 5 == 0)  then \$n == 5
elif (\$n % 7 == 0)  then \$n == 7
elif (\$n % 11 == 0) then \$n == 11
elif (\$n % 13 == 0) then \$n == 13
elif (\$n % 17 == 0) then \$n == 17
elif (\$n % 19 == 0) then \$n == 19
else 23
| until( (. * .) > \$n or (\$n % . == 0); .+2)
| . * . > \$n
end;

# Output: a stream
def deceptives:
{nextrepunit: 1111111111111111}
| foreach range(17; infinite; 2) as \$n (.;
.repunit = .nextrepunit
| .nextrepunit |= . * 100 + 11;
select( (\$n | is_prime | not)
and (\$n % 3 != 0) and (\$n % 5 != 0)
and (.repunit % \$n == 0 ))
| \$n );

"The first 25 deceptive numbers are:", [limit(25;deceptives)]```
Output:
```The first 25 deceptive numbers are:
[91,259,451,481,703,1729,2821,2981,3367,4141,4187,5461,6533,6541,6601,7471,7777,8149,8401,8911,10001,11111,12403,13981,14701]
```

## Julia

```using Primes

function deceptives(numwanted)
n, r, ret = 2, big"1", Int[]
while length(ret) < numwanted
!isprime(n) && r % n == 0 && push!(ret, n)
n += 1
r = 10r + 1
end
return ret
end

@time println(deceptives(30))
```
Output:
```[91, 259, 451, 481, 703, 1729, 2821, 2981, 3367, 4141, 4187, 5461, 6533, 6541, 6601, 7471, 7777, 8149, 8401, 8911, 10001, 11111, 12403, 13981, 14701, 14911, 15211, 15841, 19201, 21931]
0.296141 seconds (317.94 k allocations: 196.253 MiB, 39.26% gc time)
```

## langur

Translation of: ALGOL 68
Works with: langur version 0.8.1
```val .isPrime = f .i == 2 or .i > 2 and not any f(.x) .i div .x, pseries 2 .. .i ^/ 2

var .nums = []
var .repunit = 111_111

for .n = 9; len(.nums) < 10; .n += 2 {
.repunit = .repunit x 100 + 11
if not .isPrime(.n) and .repunit div .n {
.nums = more .nums, .n
}
}

writeln .nums```
Output:
```[91, 259, 451, 481, 703, 1729, 2821, 2981, 3367, 4141]
```

## LFE

Translation of: Scheme
```(defmodule deceptives
(export (prime? 1) (deceptives 1)))

(defun prime? (n)
(if (< n 2)
'false
(prime? n 2 0 #B(1 2 2 4 2 4 2 4 6 2 6))))

(defun prime? (n d j wheel)
(cond
((=:= j (byte_size wheel))
(prime? n d 3 wheel))
((> (* d d) n)
'true)
((=:= 0 (rem n d))
'false)
(else
(prime? n (+ d (binary:at wheel j)) (+ j 1) wheel))))

(defun deceptives (n)
(deceptives 2 1 n '()))

(defun deceptives
((_ _ 0 l)
(lists:reverse l))
((k r n l)
(if (andalso (not (prime? k)) (=:= 0 (rem r k)))
(deceptives (+ k 1) (+ (* r 10) 1) (- n 1) (cons k l))
(deceptives (+ k 1) (+ (* r 10) 1) n l))))
```
Output:
```lfe> (slurp "deceptive.lfe")
#(ok deceptives)
lfe> (lfe_io:format "~w~n" (list (deceptives 10)))
(91 259 451 481 703 1729 2821 2981 3367 4141)
ok
```

## Mathematica/Wolfram Language

```ClearAll[DeceptiveNumberQ]
DeceptiveNumberQ[n_Integer] := If[! PrimeQ[n], PowerMod[10, n - 1, 9 n] == 1]
c = 0;
out = Reap[Do[
If[DeceptiveNumberQ[i],
Sow[i];
c++;
If[c >= 1000, Break[]]
]
,
{i, 2, \[Infinity]}
]][[2, 1]];
Print["The first 100:"]
Multicolumn[Take[out, 100], Appearance -> "Horizontal"]
Print["The 1000th is: ", out[[1000]]]
```
Output:
```The first 100:
91	259	451	481	703	1729	2821	2981	3367	4141
4187	5461	6533	6541	6601	7471	7777	8149	8401	8911
10001	11111	12403	13981	14701	14911	15211	15841	19201	21931
22321	24013	24661	27613	29341	34133	34441	35113	38503	41041
45527	46657	48433	50851	50881	52633	54913	57181	63139	63973
65311	66991	67861	68101	75361	79003	82513	83119	94139	95161
97273	97681	100001	101101	101491	102173	108691	113201	115627	115921
118301	118957	122221	126217	128713	130351	131821	134821	134863	137137
137149	138481	139231	145181	147001	148417	152551	158497	162401	164761
166499	170017	172081	179881	188191	188269	188461	188501	196651	201917

The 1000th is: 24279289```

## OCaml

```let modpow m =
let rec loop p b e =
if e land 1 = 0
then if e = 0 then p else loop p (b * b mod m) (e lsr 1)
else loop (p * b mod m) (b * b mod m) (e lsr 1)
in loop 1

let is_deceptive n =
let rec loop x =
x * x <= n && (n mod x = 0 || n mod (x + 4) = 0 || loop (x + 6))
in
n land 1 <> 0 && n mod 3 <> 0 && n mod 5 <> 0 && loop 7 &&
modpow n 10 (pred n) = 1

let () =
Seq.(ints 49 |> filter is_deceptive |> take 500
|> iter (Printf.printf " %u%!")) |> print_newline
```
Output:
` 91 259 451 481 703 1729 2821 2981 3367 4141 4187 5461 6533 6541 6601 7471 7777 8149 8401 8911 10001 11111 12403 13981 14701 14911 15211 15841 19201 21931 22321 24013 24661 27613 29341 34133 34441 35113 38503 41041 45527 46657 48433 50851 50881 52633 54913 57181 63139 63973 65311 66991 67861 68101 75361 79003 82513 83119 94139 95161 97273 97681 100001 101101 101491 102173 108691 113201 115627 115921 118301 118957 122221 126217 128713 130351 131821 134821 134863 137137 137149 138481 139231 145181 147001 148417 152551 158497 162401 164761 166499 170017 172081 179881 188191 188269 188461 188501 196651 201917 216001 216931 225589 226273 229633 231337 234421 237169 237817 245491 247753 248677 250717 251251 252601 253099 269011 269569 274231 281821 286903 287749 287809 294409 298033 301081 302177 304057 314821 334153 340561 341503 346801 351809 357641 364277 366337 372731 385003 390313 391141 399001 401401 410041 413339 420343 437251 451091 455971 458641 463241 463489 481601 488881 489997 491063 492101 497377 497503 497927 505363 507529 509971 511969 512461 520801 522349 530881 532171 552721 567721 585631 586993 588193 589537 595231 597871 601657 603961 607321 632641 634351 642001 658801 665401 670033 679861 710533 721801 736291 741751 748657 749521 754369 764491 765703 827281 838201 841633 847693 852841 853381 868001 873181 880237 886033 903169 906193 909709 924001 929633 963857 974611 976873 981317 989017 997633 997981 999001 1004329 1005697 1024651 1033669 1038331 1039441 1039849 1041043 1042417 1056331 1069993 1080697 1081649 1082809 1090051 1096681 1111111 1128871 1141141 1146401 1152271 1163801 1167607 1168513 1169101 1171261 1182721 1193221 1242241 1242571 1251949 1267801 1268551 1272271 1275347 1279201 1287937 1294411 1298737 1306369 1308853 1336699 1362061 1376299 1394171 1398101 1408849 1419607 1446241 1446661 1450483 1461241 1462441 1463749 1492663 1498981 1504321 1531711 1543381 1551941 1569457 1576381 1583821 1590751 1602601 1615681 1703221 1705621 1708993 1711381 1711601 1719601 1731241 1739089 1748921 1756351 1758121 1769377 1772611 1773289 1792081 1803413 1809697 1810513 1826209 1840321 1846681 1850017 1857241 1863907 1869211 1876393 1884961 1887271 1892143 1894651 1907851 1909001 1918201 1922801 1926761 1942957 1943341 1945423 1953671 1991821 2024641 2030341 2044657 2056681 2063971 2085301 2100901 2113921 2146957 2161501 2165801 2171197 2171401 2184931 2190931 2194973 2203321 2205967 2215291 2237017 2278001 2290289 2299081 2305633 2314201 2337301 2358533 2371681 2386141 2392993 2406401 2424731 2432161 2433601 2455921 2463661 2503501 2508013 2512441 2524801 2525909 2539183 2553061 2563903 2585701 2603381 2628073 2630071 2658433 2694601 2699431 2704801 2719981 2765713 2795519 2824061 2868097 2879317 2887837 2899351 2916511 2949991 2960497 2976487 2987167 3005737 3057601 3076481 3084577 3117547 3125281 3140641 3146221 3167539 3186821 3209053 3225601 3247453 3255907 3270403 3362083 3367441 3367771 3369421 3387781 3398921 3400013 3426401 3429889 3471071 3488041 3506221 3520609 3523801 3536821 3537667 3581761 3593551 3596633 3658177 3677741 3678401 3740737 3781141 3788851 3815011 3817681 3828001 3850771 3862207 3879089 3898129 3913003 3930697 3947777 3985921 4005001 4010401 4014241 4040281 4040881 4064677 4074907 4077151 4099439 4100041 4119301 4151281 4181921 4182739 4209661 4225057 4234021 4255903 4260301 4316089 4326301 4335241 4360801 4363261 4363661 4372771 4373461 4415251 4415581 4454281 4463641 4469471 4469551 4499701 4504501 4543621 4627441 4630141 4637617 4762381 4767841 4784689 4806061 4863127 4903921 4909177 4909411 4909913 4917781 5031181 5045401 5049001 5056051 5122133 5148001 5160013 5180593 5197837 5203471`

## PARI/GP

```Rep(n)=sum(X=0,n-1,10^X)
c=0
n=4
while(c<10,if(!isprime(n)&&Rep(n-1)%n==0,c=c+1;print(n));n=n+1)```
Output:
```91
259
451
481
703
1729
2821
2981
3367
4141

```

## Pascal

### Free Pascal

Brute force, not using gmp. Runtime ~ n^2.
Like Wren,et alias only checking odd divisors, no multiple of 3
Like Nigel said, no multiple of 5.

```program DeceptiveNumbers;
{\$IfDef FPC} {\$Optimization ON,ALL} {\$ENDIF}
{\$IfDef Windows} {\$APPTYPE CONSOLE} {\$ENDIF}
uses
sysutils;
const
LIMIT = 100000;//1E6 at home takes over (5 min) now 1m10s
RepInitLen = 13; //Uint64 19 decimal digits -> max 6 digits divisor
DecimalDigits = 10*1000*1000*1000*1000;//1E13
RepLimit = (DecimalDigits-1)DIV 9;//RepInitLen '1'

type
tmyUint64 = array[0..Limit DIV RepInitLen+1] of Uint64;
var
{\$Align 32}
K: tmyUint64;
{\$Align 32}
MaxKIdx : Int32;

procedure OutK(const K:tmyUint64);
var
i : Uint32;
begin
For i := MaxKidx downto 0 do
begin
write(k[i]:13);
end;
writeln;
end;

function isPrime(n: UInt64):boolean;
var
p: Uint64;
begin
if n in [2,3,5,7,11,13,17,19,23,29] then
EXIT(true);

if Not ODD(n) OR ( n MOD 3 = 0) then
EXIT(false);
p := 5;
repeat
if (n mod p=0)or(n mod(p+2)=0) then
EXIT(false);
p +=6;
until p*p>n;
Exit(true);
end;

procedure ExtendRep(var K:tmyUint64;n:NativeUint);
var
q : Uint64;
i : Int32;
begin
n -= MaxKidx*RepInitLen;
i := MaxKidx;
while RepInitLen<=n do
begin
K[i] := RepLimit;
inc(i);
dec(n,RepInitLen);
end;
if n = 0 then
Exit;
MaxKidx := i;
q := 1;
while n<RepInitLen do
begin
q *= 10;
inc(n);
end;
K[i] := RepLimit DIV q;
end;

function GetModK(const K:tmyUint64;n:Uint64):NativeUint;
var
r,q : Uint64;
i : Uint32;
Begin
r := 0;
For i := MaxKidx downto 0 do
begin
q := K[i]+r*DecimalDigits;
r := q MOD n;
end;
Exit(r)
end;

const
NextNotMulOF35 : array[0..7] of byte = (6,4,2,4,2,4,6,2);
var
i,cnt,idx35 : UInt64;
BEGIN
fillchar(K,SizeOF(K),#0);
MaxKIdx:= 0;
cnt := 0;
i := 1;
idx35 := 0;
repeat
inc(i,NextNotMulOF35[idx35]);
IF i > LIMIT then
BREAK;
idx35 := (idx35+1) AND 7;
if isprime(i) then
continue;
ExtendRep(k,i-1);
IF GetModK(K,i)=0 then
Begin
inc(cnt);
write(i:6,',');
if cnt Mod 10 = 0 then
writeln;
end;
until false;
{\$IfDef Windows}
{\$ENDIF}
END.
```
@TIO.RUN:
```Real time: 1.009 s User time: 0.971 s Sys. time: 0.033 s CPU share: 99.43 %

91,   259,   451,   481,   703,  1729,  2821,  2981,  3367,  4141,
4187,  5461,  6533,  6541,  6601,  7471,  7777,  8149,  8401,  8911,
10001, 11111, 12403, 13981, 14701, 14911, 15211, 15841, 19201, 21931,
22321, 24013, 24661, 27613, 29341, 34133, 34441, 35113, 38503, 41041,
45527, 46657, 48433, 50851, 50881, 52633, 54913, 57181, 63139, 63973,
65311, 66991, 67861, 68101, 75361, 79003, 82513, 83119, 94139, 95161,
97273, 97681,```

## Perl

```use strict;
use warnings;
use Math::AnyNum qw(imod is_prime);

my(\$x,@D) = 2;
while (\$x++) {
push @D, \$x if 1 == \$x%2 and !is_prime \$x and 0 == imod(1x(\$x-1),\$x);
last if 25 == @D
}
print "@D\n";
```
Output:
`91 259 451 481 703 1729 2821 2981 3367 4141 4187 5461 6533 6541 6601 7471 7777 8149 8401 8911 10001 11111 12403 13981 14701`

## Phix

Library: Phix/online

You can run this online here.

```with javascript_semantics
constant limit = 70
atom t0 = time()
include mpfr.e
mpz repunit = mpz_init(0)
integer n = 1, count = 0
printf(1,"The first %d deceptive numbers are:\n",limit)
while count<limit do
-- No repunit is ever divisible by 2 or 5 since it ends in 1.
-- If n is 3*k, sum(digits(repunit))=3*k-1, not divisible by 3.
-- Hence only check odd and hop any multiples of 3 or 5.
n += 2
mpz_mul_si(repunit,repunit,100)
if gcd(n,3*5)=1
and not is_prime(n)
and mpz_divisible_ui_p(repunit,n) then
count += 1
printf(1," %7d%n",{n,remainder(count,10)=0})
end if
end while
printf(1,"%s\n",elapsed(time()-t0))
```
Output:
```The first 70 deceptive numbers are:
91     259     451     481     703    1729    2821    2981    3367    4141
4187    5461    6533    6541    6601    7471    7777    8149    8401    8911
10001   11111   12403   13981   14701   14911   15211   15841   19201   21931
22321   24013   24661   27613   29341   34133   34441   35113   38503   41041
45527   46657   48433   50851   50881   52633   54913   57181   63139   63973
65311   66991   67861   68101   75361   79003   82513   83119   94139   95161
97273   97681  100001  101101  101491  102173  108691  113201  115627  115921
1.6s
```

Extending the limit to 100 (matching the C++ and Rust entries) is no problem:

```  118301  118957  122221  126217  128713  130351  131821  134821  134863  137137
137149  138481  139231  145181  147001  148417  152551  158497  162401  164761
166499  170017  172081  179881  188191  188269  188461  188501  196651  201917
4.2s -- (7.3s under pwa/p2js)
```

## Prolog

```checkpair(1, 2).
checkpair(R, K) :-
checkpair(R0, K0),
R is 10*R0 + 1,
K is K0 + 1.

deceptive(K) :-
checkpair(R, K),
\+ prime(K),
divmod(R, K, _, 0).

lazy_findall(N, deceptive(N), Ds),
length(Ns, K),
prefix(Ns, Ds).

% check if a number is prime
%
wheel235(L) :-
W = [4, 2, 4, 2, 4, 6, 2, 6 | W],
L = [1, 2, 2 | W].

prime(N) :-
N >= 2,
wheel235(W),
prime(N, 2, W).

prime(N, D, _) :- D*D > N, !.
prime(N, D, [A|As]) :-
N mod D =\= 0,
D2 is D + A, prime(N, D2, As).
```
Output:
```?- task(10, Ns),write(Ns).
[91,259,451,481,703,1729,2821,2981,3367,4141]
Ns = [91, 259, 451, 481, 703, 1729, 2821, 2981, 3367|...].
```

## Python

```from itertools import count, islice
from math import isqrt

def is_deceptive(n):
if n & 1 and n % 3 and n % 5 and pow(10, n - 1, n) == 1:
for d in range(7, isqrt(n) + 1, 6):
if not (n % d and n % (d + 4)): return True
return False

print(*islice(filter(is_deceptive, count()), 100))
```
Output:
`91 259 451 481 703 1729 2821 2981 3367 4141 4187 5461 6533 6541 6601 7471 7777 8149 8401 8911 10001 11111 12403 13981 14701 14911 15211 15841 19201 21931 22321 24013 24661 27613 29341 34133 34441 35113 38503 41041 45527 46657 48433 50851 50881 52633 54913 57181 63139 63973 65311 66991 67861 68101 75361 79003 82513 83119 94139 95161 97273 97681 100001 101101 101491 102173 108691 113201 115627 115921 118301 118957 122221 126217 128713 130351 131821 134821 134863 137137 137149 138481 139231 145181 147001 148417 152551 158497 162401 164761 166499 170017 172081 179881 188191 188269 188461 188501 196651 201917`

## Raku

```my \R = [\+] 1, 10, 100 … *;
put (2..∞).grep( {\$_ % 2 && \$_ % 3 && \$_ % 5 && !.is-prime} ).grep( { R[\$_-2] %% \$_ } )[^25];
```
Output:
`91 259 451 481 703 1729 2821 2981 3367 4141 4187 5461 6533 6541 6601 7471 7777 8149 8401 8911 10001 11111 12403 13981 14701`

## Ruby

```require 'prime'

deceptives = Enumerator.new do |y|
10.step(by: 10) do |n|
[1,3,7,9].each do |digit|
cand = n + digit
next if cand % 3 == 0 || cand.prime?
repunit = ("1"*(cand-1)).to_i
y << cand if (repunit % cand) == 0
end
end
end

p deceptives.take(25).to_a
```
Output:
```[91, 259, 451, 481, 703, 1729, 2821, 2981, 3367, 4141, 4187, 5461, 6533, 6541, 6601, 7471, 7777, 8149, 8401, 8911, 10001, 11111, 12403, 13981, 14701]
```

## Rust

```// [dependencies]
// primal = "0.3"
// rug = "1.15.0"

fn main() {
println!("First 100 deceptive numbers:");
use rug::Integer;
let mut repunit = Integer::from(11);
let mut n: u32 = 3;
let mut count = 0;
while count != 100 {
if n % 3 != 0 && n % 5 != 0 && !primal::is_prime(n as u64) && repunit.is_divisible_u(n) {
print!("{:6}", n);
count += 1;
if count % 10 == 0 {
println!();
} else {
print!(" ");
}
}
n += 2;
repunit *= 100;
repunit += 11;
}
}
```
Output:
```First 100 deceptive numbers:
91    259    451    481    703   1729   2821   2981   3367   4141
4187   5461   6533   6541   6601   7471   7777   8149   8401   8911
10001  11111  12403  13981  14701  14911  15211  15841  19201  21931
22321  24013  24661  27613  29341  34133  34441  35113  38503  41041
45527  46657  48433  50851  50881  52633  54913  57181  63139  63973
65311  66991  67861  68101  75361  79003  82513  83119  94139  95161
97273  97681 100001 101101 101491 102173 108691 113201 115627 115921
118301 118957 122221 126217 128713 130351 131821 134821 134863 137137
137149 138481 139231 145181 147001 148417 152551 158497 162401 164761
166499 170017 172081 179881 188191 188269 188461 188501 196651 201917
```

## Scheme

Uses a Chez Scheme extension for defining a circular list.

```(define prime?
(let ((wheel '(1 2 2 . #1=(4 2 4 2 4 6 2 6 . #1#))))
(lambda (n)
(if (< n 2)
#f
(let loop ((f 2) (w wheel))
(cond
((> (* f f) n)  #t)
((zero? (remainder n f))  #f)
(#t  (loop (+ f (car w)) (cdr w)))))))))

(define (deceptives n)
(let loop ((k 2) (r 1) (n n) (l '()))
(if (zero? n)
(reverse! l)
(if (and (not (prime? k)) (zero? (remainder r k)))
(loop (+ k 1) (+ (* 10 r) 1) (- n 1) (cons k l))
(loop (+ k 1) (+ (* 10 r) 1) n l)))))
```
Output:
```Chez Scheme Version 9.5

> (deceptives 10)
(91 259 451 481 703 1729 2821 2981 3367 4141)
```

## Sidef

```say 100.by {|n|
n.is_composite && (divmod(powmod(10, n-1, n)-1, 9, n) == 0)
}.join(' ')
```
Output:
```91 259 451 481 703 1729 2821 2981 3367 4141 4187 5461 6533 6541 6601 7471 7777 8149 8401 8911 10001 11111 12403 13981 14701 14911 15211 15841 19201 21931 22321 24013 24661 27613 29341 34133 34441 35113 38503 41041 45527 46657 48433 50851 50881 52633 54913 57181 63139 63973 65311 66991 67861 68101 75361 79003 82513 83119 94139 95161 97273 97681 100001 101101 101491 102173 108691 113201 115627 115921 118301 118957 122221 126217 128713 130351 131821 134821 134863 137137 137149 138481 139231 145181 147001 148417 152551 158497 162401 164761 166499 170017 172081 179881 188191 188269 188461 188501 196651 201917
```

## V (Vlang)

Translation of: Go
```import math.big

fn is_prime(n int) bool {
if n < 2 {
return false
} else if n%2 == 0 {
return n == 2
} else if n%3 == 0 {
return n == 3
} else {
mut d := 5
for d*d <= n {
if n%d == 0 {
return false
}
d += 2
if n%d == 0 {
return false
}
d += 4
}
return true
}
}

fn main() {
mut count := 0
limit := 25
mut n := i64(17)
mut repunit := big.integer_from_i64(1111111111111111)
mut t := big.integer_from_int(0)
zero := big.integer_from_int(0)
eleven := big.integer_from_int(11)
hundred := big.integer_from_int(100)
mut deceptive := []i64{}
for count < limit {
if !is_prime(int(n)) && n%3 != 0 && n%5 != 0 {
bn := big.integer_from_i64(n)
t = repunit % bn
if t == zero {
deceptive << n
count++
}
}
n += 2
repunit = repunit * hundred
repunit = repunit + eleven
}
println("The first \$limit deceptive numbers are:")
println(deceptive)
}
```
Output:
```The first 25 deceptive numbers are:
[91, 259, 451, 481, 703, 1729, 2821, 2981, 3367, 4141, 4187, 5461, 6533, 6541, 6601, 7471, 7777, 8149, 8401, 8911, 10001, 11111, 12403, 13981, 14701]
```

## Wren

Library: Wren-gmp
Library: Wren-math

An embedded program so we can use GMP. Takes 0.019 seconds to find the first 25 deceptive numbers.

The first 62 deceptive numbers (up to 97681 though not shown in full) are found in 0.179 seconds.

```/* deceptive_numbers.wren */

import "./gmp" for Mpz
import "./math" for Int

var count = 0
var limit = 25
var n = 17
var repunit = Mpz.from(1111111111111111)
var deceptive = []
while (count < limit) {
if (!Int.isPrime(n) && n % 3 != 0 && n % 5 != 0) {
if (repunit.isDivisibleUi(n)) {
```The first 25 deceptive numbers are: