I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# Curzon numbers

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

A Curzon number is defined to be a positive integer n for which 2n + 1 is evenly divisible by 2 × n + 1.

Generalized Curzon numbers are those where the positive integer n, using a base integer k, satisfy the condition that kn + 1 is evenly divisible by k × n + 1.

Base here does not imply the radix of the counting system; rather the integer the equation is based on. All calculations should be done in base 10.

Generalized Curzon numbers only exist for even base integers.

• Find and show the first 50 Generalized Curzon numbers for even base integers from 2 through 10.

Stretch
• Find and show the one thousandth.

and even though it is not specifically mentioned that they are Curzon numbers:

## Arturo

`curzon?: function [n,base]->    zero? (inc base^n) % inc base*n first50: function [b][    result: new []    i: 1    while [50 > size result][        if curzon? i b -> 'result ++ i         i: i + 1    ]    return result] oneThousandth: function [b][    cnt: 0    i: 1    while [cnt < 1000][        if curzon? i b -> cnt: cnt+1        i: i + 1    ]    return dec i] loop select 2..10 => even? 'withBase [    print ["First 50 Curzon numbers with base" withBase]    loop split.every: 10 first50 withBase 'row [        print map to [:string] row 'item -> pad item 4    ]    print ["\n1000th Curzon with base" withBase "=" oneThousandth withBase]    print ""]`
Output:
```First 50 Curzon numbers with base 2
1    2    5    6    9   14   18   21   26   29
30   33   41   50   53   54   65   69   74   78
81   86   89   90   98  105  113  114  125  134
138  141  146  153  158  165  173  174  186  189
194  198  209  210  221  230  233  245  249  254

1000th Curzon with base 2 = 8646

First 50 Curzon numbers with base 4
1    3    7    9   13   15   25   27   37   39
43   45   49   57   67   69   73   79   87   93
97   99  105  115  127  135  139  153  163  165
169  175  177  183  189  193  199  205  207  213
219  235  249  253  255  265  267  273  277  279

1000th Curzon with base 4 = 9375

First 50 Curzon numbers with base 6
1    6   30   58   70   73   90  101  105  121
125  146  153  166  170  181  182  185  210  233
241  242  266  282  290  322  373  381  385  390
397  441  445  446  450  453  530  557  562  585
593  601  602  605  606  621  646  653  670  685

1000th Curzon with base 6 = 20717

First 50 Curzon numbers with base 8
1   14   35   44   72   74   77  129  131  137
144  149  150  185  200  219  236  266  284  285
299  309  336  357  381  386  390  392  402  414
420  441  455  459  470  479  500  519  527  536
557  582  600  602  617  639  654  674  696  735

1000th Curzon with base 8 = 22176

First 50 Curzon numbers with base 10
1    9   10   25  106  145  190  193  238  253
306  318  349  385  402  462  486  526  610  649
658  678  733  762  810  990  994 1033 1077 1125
1126 1141 1149 1230 1405 1422 1441 1485 1509 1510
1513 1606 1614 1630 1665 1681 1690 1702 1785 1837

1000th Curzon with base 10 = 46845```

## C++

Library: GMP
`#include <iomanip>#include <iostream>#include <vector> #include <gmpxx.h> bool is_curzon(int n, int k) {    mpz_class p;    mpz_ui_pow_ui(p.get_mpz_t(), k, n);    return (p + 1) % (k * n + 1) == 0;} int main() {    for (int k = 2; k <= 10; k += 2) {        std::cout << "Curzon numbers with base " << k << ":\n";        int count = 0, n = 1;        for (; count < 50; ++n) {            if (is_curzon(n, k)) {                std::cout << std::setw(4) << n                          << (++count % 10 == 0 ? '\n' : ' ');            }        }        for (;;) {            if (is_curzon(n, k))                ++count;            if (count == 1000)                break;            ++n;        }        std::cout << "1000th Curzon number with base " << k << ": " << n                  << "\n\n";    }    return 0;}`
Output:
```Curzon numbers with base 2:
1    2    5    6    9   14   18   21   26   29
30   33   41   50   53   54   65   69   74   78
81   86   89   90   98  105  113  114  125  134
138  141  146  153  158  165  173  174  186  189
194  198  209  210  221  230  233  245  249  254
1000th Curzon number with base 2: 8646

Curzon numbers with base 4:
1    3    7    9   13   15   25   27   37   39
43   45   49   57   67   69   73   79   87   93
97   99  105  115  127  135  139  153  163  165
169  175  177  183  189  193  199  205  207  213
219  235  249  253  255  265  267  273  277  279
1000th Curzon number with base 4: 9375

Curzon numbers with base 6:
1    6   30   58   70   73   90  101  105  121
125  146  153  166  170  181  182  185  210  233
241  242  266  282  290  322  373  381  385  390
397  441  445  446  450  453  530  557  562  585
593  601  602  605  606  621  646  653  670  685
1000th Curzon number with base 6: 20717

Curzon numbers with base 8:
1   14   35   44   72   74   77  129  131  137
144  149  150  185  200  219  236  266  284  285
299  309  336  357  381  386  390  392  402  414
420  441  455  459  470  479  500  519  527  536
557  582  600  602  617  639  654  674  696  735
1000th Curzon number with base 8: 22176

Curzon numbers with base 10:
1    9   10   25  106  145  190  193  238  253
306  318  349  385  402  462  486  526  610  649
658  678  733  762  810  990  994 1033 1077 1125
1126 1141 1149 1230 1405 1422 1441 1485 1509 1510
1513 1606 1614 1630 1665 1681 1690 1702 1785 1837
1000th Curzon number with base 10: 46845

```

## Factor

Works with: Factor version 0.99 2022-04-03
`USING: grouping interpolate io kernel make math math.functionsprettyprint ranges sequences ; : curzon? ( k n -- ? ) [ ^ 1 + ] 2keep * 1 + divisor? ; : next ( k n -- k n' ) [ 2dup curzon? ] [ 1 + ] do until ; : curzon ( k -- seq )    1 [ 50 [ dup , next ] times ] { } make 2nip ; : curzon. ( k -- )    dup [I Curzon numbers with base \${}:I] nl    curzon 10 group simple-table. ; 2 10 2 <range> [ curzon. nl ] each`
Output:
```Curzon numbers with base 2:
1   2   5   6   9   14  18  21  26  29
30  33  41  50  53  54  65  69  74  78
81  86  89  90  98  105 113 114 125 134
138 141 146 153 158 165 173 174 186 189
194 198 209 210 221 230 233 245 249 254

Curzon numbers with base 4:
1   3   7   9   13  15  25  27  37  39
43  45  49  57  67  69  73  79  87  93
97  99  105 115 127 135 139 153 163 165
169 175 177 183 189 193 199 205 207 213
219 235 249 253 255 265 267 273 277 279

Curzon numbers with base 6:
1   6   30  58  70  73  90  101 105 121
125 146 153 166 170 181 182 185 210 233
241 242 266 282 290 322 373 381 385 390
397 441 445 446 450 453 530 557 562 585
593 601 602 605 606 621 646 653 670 685

Curzon numbers with base 8:
1   14  35  44  72  74  77  129 131 137
144 149 150 185 200 219 236 266 284 285
299 309 336 357 381 386 390 392 402 414
420 441 455 459 470 479 500 519 527 536
557 582 600 602 617 639 654 674 696 735

Curzon numbers with base 10:
1    9    10   25   106  145  190  193  238  253
306  318  349  385  402  462  486  526  610  649
658  678  733  762  810  990  994  1033 1077 1125
1126 1141 1149 1230 1405 1422 1441 1485 1509 1510
1513 1606 1614 1630 1665 1681 1690 1702 1785 1837
```

## Go

Translation of: Wren
`package main import (    "fmt"    "math/big") func main() {    zero := big.NewInt(0)    one := big.NewInt(1)    for k := int64(2); k <= 10; k += 2 {        bk := big.NewInt(k)        fmt.Println("The first 50 Curzon numbers using a base of", k, ":")        count := 0        n := int64(1)        pow := big.NewInt(k)        z := new(big.Int)        var curzon50 []int64        for {            z.Add(pow, one)            d := k*n + 1            bd := big.NewInt(d)            if z.Rem(z, bd).Cmp(zero) == 0 {                if count < 50 {                    curzon50 = append(curzon50, n)                }                count++                if count == 50 {                    for i := 0; i < len(curzon50); i++ {                        fmt.Printf("%4d ", curzon50[i])                        if (i+1)%10 == 0 {                            fmt.Println()                        }                    }                    fmt.Print("\nOne thousandth: ")                }                if count == 1000 {                    fmt.Println(n)                    break                }            }            n++            pow.Mul(pow, bk)        }        fmt.Println()    }}`
Output:
```The first 50 Curzon numbers using a base of 2 :
1    2    5    6    9   14   18   21   26   29
30   33   41   50   53   54   65   69   74   78
81   86   89   90   98  105  113  114  125  134
138  141  146  153  158  165  173  174  186  189
194  198  209  210  221  230  233  245  249  254

One thousandth: 8646

The first 50 Curzon numbers using a base of 4 :
1    3    7    9   13   15   25   27   37   39
43   45   49   57   67   69   73   79   87   93
97   99  105  115  127  135  139  153  163  165
169  175  177  183  189  193  199  205  207  213
219  235  249  253  255  265  267  273  277  279

One thousandth: 9375

The first 50 Curzon numbers using a base of 6 :
1    6   30   58   70   73   90  101  105  121
125  146  153  166  170  181  182  185  210  233
241  242  266  282  290  322  373  381  385  390
397  441  445  446  450  453  530  557  562  585
593  601  602  605  606  621  646  653  670  685

One thousandth: 20717

The first 50 Curzon numbers using a base of 8 :
1   14   35   44   72   74   77  129  131  137
144  149  150  185  200  219  236  266  284  285
299  309  336  357  381  386  390  392  402  414
420  441  455  459  470  479  500  519  527  536
557  582  600  602  617  639  654  674  696  735

One thousandth: 22176

The first 50 Curzon numbers using a base of 10 :
1    9   10   25  106  145  190  193  238  253
306  318  349  385  402  462  486  526  610  649
658  678  733  762  810  990  994 1033 1077 1125
1126 1141 1149 1230 1405 1422 1441 1485 1509 1510
1513 1606 1614 1630 1665 1681 1690 1702 1785 1837

One thousandth: 46845
```

## jq

Works with gojq, the Go implementation of jq

The following jq program requires gojq for integer-arithmetic accuracy.

Preliminaries

`# To take advantage of gojq's arbitrary-precision integer arithmetic:def power(\$b): . as \$in | reduce range(0;\$b) as \$i (1; . * \$in); def lpad(\$len): tostring | (\$len - length) as \$l | (" " * \$l)[:\$l] + .; # gojq does not currently define _nwisedef _nwise(\$n):  def n: if length <= \$n then . else .[0:\$n] , (.[\$n:] | n) end;  n; def printRows(\$m): _nwise(\$m) | map(lpad(5)) | join("");`

`def isCurzon(\$n; \$k):  (\$k | power(\$n) + 1) % (\$k * \$n + 1) == 0; # Emit a stream of Curzon numbers base \$kdef curzons(\$k):  range(0; infinite) | select(isCurzon(.; \$k)); # Print the first 50 and the \$n-th Curzon numbers# for k in range(klow; khigh+1; 2)def printcurzons(klow; khigh; \$n):  range(klow; khigh+1; 2) as \$k  | [limit(\$n; curzons(\$k))] as \$curzons  | "Curzon numbers with k = \(\$k):",    (\$curzons[:50] | printRows(25) ),    "    \(\$n)-th Curzon with k = \(\$k): \(\$curzons[\$n - 1])",    ""; printcurzons(2; 10; 1000)`
Output:
```Curzon numbers with k = 2:
0    1    2    5    6    9   14   18   21   26   29   30   33   41   50   53   54   65   69   74   78   81   86   89   90
98  105  113  114  125  134  138  141  146  153  158  165  173  174  186  189  194  198  209  210  221  230  233  245  249
1000-th Curzon with k = 2: 8645

Curzon numbers with k = 4:
0    1    3    7    9   13   15   25   27   37   39   43   45   49   57   67   69   73   79   87   93   97   99  105  115
127  135  139  153  163  165  169  175  177  183  189  193  199  205  207  213  219  235  249  253  255  265  267  273  277
1000-th Curzon with k = 4: 9373

Curzon numbers with k = 6:
0    1    6   30   58   70   73   90  101  105  121  125  146  153  166  170  181  182  185  210  233  241  242  266  282
290  322  373  381  385  390  397  441  445  446  450  453  530  557  562  585  593  601  602  605  606  621  646  653  670
1000-th Curzon with k = 6: 20681

Curzon numbers with k = 8:
0    1   14   35   44   72   74   77  129  131  137  144  149  150  185  200  219  236  266  284  285  299  309  336  357
381  386  390  392  402  414  420  441  455  459  470  479  500  519  527  536  557  582  600  602  617  639  654  674  696
1000-th Curzon with k = 8: 22122

Curzon numbers with k = 10:
0    1    9   10   25  106  145  190  193  238  253  306  318  349  385  402  462  486  526  610  649  658  678  733  762
810  990  994 1033 1077 1125 1126 1141 1149 1230 1405 1422 1441 1485 1509 1510 1513 1606 1614 1630 1665 1681 1690 1702 1785
1000-th Curzon with k = 10: 46837

```

## Julia

`isCurzon(n, k) = (BigInt(k)^n + 1) % (k * n + 1) == 0 function printcurzons(klow, khigh)    for k in filter(iseven, klow:khigh)        n, curzons = 0, Int[]        while length(curzons) < 1000            isCurzon(n, k) && push!(curzons, n)            n += 1        end        println("Curzon numbers with k = \$k:")        foreach(p -> print(lpad(p[2], 5), p[1] % 25 == 0 ? "\n" : ""), enumerate(curzons[1:50]))        println("    Thousandth Curzon with k = \$k: ", curzons[1000])    endend printcurzons(2, 10) `
Output:
```Curzon numbers with k = 2:
1    2    5    6    9   14   18   21   26   29   30   33   41   50   53   54   65   69   74   78   81   86   89   90   98
105  113  114  125  134  138  141  146  153  158  165  173  174  186  189  194  198  209  210  221  230  233  245  249  254
Thousandth Curzon with k = 2: 8646
Curzon numbers with k = 4:
1    3    7    9   13   15   25   27   37   39   43   45   49   57   67   69   73   79   87   93   97   99  105  115  127
135  139  153  163  165  169  175  177  183  189  193  199  205  207  213  219  235  249  253  255  265  267  273  277  279
Thousandth Curzon with k = 4: 9375
Curzon numbers with k = 6:
1    6   30   58   70   73   90  101  105  121  125  146  153  166  170  181  182  185  210  233  241  242  266  282  290
322  373  381  385  390  397  441  445  446  450  453  530  557  562  585  593  601  602  605  606  621  646  653  670  685
Thousandth Curzon with k = 6: 20717
Curzon numbers with k = 8:
1   14   35   44   72   74   77  129  131  137  144  149  150  185  200  219  236  266  284  285  299  309  336  357  381
386  390  392  402  414  420  441  455  459  470  479  500  519  527  536  557  582  600  602  617  639  654  674  696  735
Thousandth Curzon with k = 8: 22176
Curzon numbers with k = 10:
1    9   10   25  106  145  190  193  238  253  306  318  349  385  402  462  486  526  610  649  658  678  733  762  810
990  994 1033 1077 1125 1126 1141 1149 1230 1405 1422 1441 1485 1509 1510 1513 1606 1614 1630 1665 1681 1690 1702 1785 1837
Thousandth Curzon with k = 10: 46845
```

## Pascal

A console application in Free Pascal, created with the Lazarus IDE.

It isn't clear why the task description says "generalized Curzon numbers only exist for even base integers." If k >= 3 is an odd base, then, besides the trivial solution n = 1, it can be checked that n = k^(k-1) is a Curzon number according to the given definition. It seems from the output below that Curzon numbers with an odd base are much scarcer than those with an even base.

` program CurzonNumbers;uses SysUtils;const  MAX_CURZON_MEG = 100;  RC_LINE_LENGTH = 66; procedure ListCurzonNumbers( base : integer);var  k, n, m, x, testBit, maxCurzon : uint64;  nrHits : integer;  lineOut : string;begin  maxCurzon := 1000000*MAX_CURZON_MEG;  k := uint64( base);  nrHits := 0;  n := 0;  WriteLn;  if Odd( base) then WriteLn( SysUtils.Format(        'Curzon numbers with base %d up to %d million', [base, MAX_CURZON_MEG]))  else WriteLn( SysUtils.Format(        'First 50 Curzon numbers with base %d', [base]));  lineOut := '';  repeat    inc(n); // possible (generalized) Curzon number    m := k*n + 1; // modulus    testBit := 1;    repeat testBit := testBit shl 1 until testBit > n;    testBit := testBit shr 2;    // Calculate k^n modulo m    x := k;    while testBit > 0 do begin      x := (x*x) mod m;      if (testBit and n) <> 0 then x := (x*k) mod m;      testBit := testBit shr 1;    end;    // n is a Curzon number to base k iff k^n + 1 is divisible by m    if (x + 1) mod m = 0 then begin      inc( nrHits);      if Odd( base) then        lineOut := lineOut + ' ' + SysUtils.IntToStr( n)      else if (nrHits <= 50) then        lineOut := lineOut + SysUtils.Format( '%5d', [n]);      if Length( lineOut) >= RC_LINE_LENGTH then begin        WriteLn( lineOut); lineOut := '';      end      else if (nrHits = 1000) then begin        if lineOut <> '' then begin          WriteLn( lineOut); lineOut := '';        end;        WriteLn( SysUtils.Format( '1000th = %d', [n]));      end;    end;  until (n = maxCurzon) or (nrHits = 1000);  if lineOut <> '' then WriteLn( lineOut);end; begin  ListCurzonNumbers( 2);  ListCurzonNumbers( 4);  ListCurzonNumbers( 6);  ListCurzonNumbers( 8);  ListCurzonNumbers(10);  ListCurzonNumbers( 3);  ListCurzonNumbers( 5);  ListCurzonNumbers( 7);  ListCurzonNumbers( 9);  ListCurzonNumbers(11);end. `
Output:
```First 50 Curzon numbers with base 2
1    2    5    6    9   14   18   21   26   29   30   33   41   50
53   54   65   69   74   78   81   86   89   90   98  105  113  114
125  134  138  141  146  153  158  165  173  174  186  189  194  198
209  210  221  230  233  245  249  254
1000th = 8646

First 50 Curzon numbers with base 4
1    3    7    9   13   15   25   27   37   39   43   45   49   57
67   69   73   79   87   93   97   99  105  115  127  135  139  153
163  165  169  175  177  183  189  193  199  205  207  213  219  235
249  253  255  265  267  273  277  279
1000th = 9375

First 50 Curzon numbers with base 6
1    6   30   58   70   73   90  101  105  121  125  146  153  166
170  181  182  185  210  233  241  242  266  282  290  322  373  381
385  390  397  441  445  446  450  453  530  557  562  585  593  601
602  605  606  621  646  653  670  685
1000th = 20717

First 50 Curzon numbers with base 8
1   14   35   44   72   74   77  129  131  137  144  149  150  185
200  219  236  266  284  285  299  309  336  357  381  386  390  392
402  414  420  441  455  459  470  479  500  519  527  536  557  582
600  602  617  639  654  674  696  735
1000th = 22176

First 50 Curzon numbers with base 10
1    9   10   25  106  145  190  193  238  253  306  318  349  385
402  462  486  526  610  649  658  678  733  762  810  990  994 1033
1077 1125 1126 1141 1149 1230 1405 1422 1441 1485 1509 1510 1513 1606
1614 1630 1665 1681 1690 1702 1785 1837
1000th = 46845

Curzon numbers with base 3 up to 100 million
1 9 3825 6561 102465 188505 190905 1001385 1556985 3427137 5153577
5270625 5347881 13658225 14178969 20867625 23828049 27511185 29400657
48533625 80817009 83406609 89556105

Curzon numbers with base 5 up to 100 million
1 625 57057 7748433 30850281

Curzon numbers with base 7 up to 100 million
1 135 5733 11229 42705 50445 117649 131365 168093 636405 699825 1269495
2528155 4226175 6176709 6502545 9365265 9551115 13227021 14464485
14912625 20859435 26903605 28251265 30589905 32660901 37597329 41506875
42766465 55452075 56192535

Curzon numbers with base 9 up to 100 million
1 81 558657 43046721 64734273

Curzon numbers with base 11 up to 100 million
1 2233 1623457 2213497 5413617 6306993 7567945 8054145 45750705 83024865
84034665
```

## Perl

`use strict;use warnings;use Math::AnyNum 'ipow'; sub curzon {    my(\$base,\$cnt) = @_;    my(\$n,@C) = 0;    while (++\$n) {        push @C, \$n if 0 == (ipow(\$base,\$n) + 1) % (\$base * \$n + 1);        return @C if \$cnt == @C;    }} my \$upto = 50;for my \$k (<2 4 6 8 10>) {    my @C = curzon(\$k,1000);    print "First \$upto Curzon numbers using a base of \$k:\n" .    (sprintf "@{['%5d' x \$upto]}", @C[0..\$upto-1]) =~ s/(.{125})/\$1\n/gr;    print "Thousandth: \$C[-1]\n\n";}`
Output:
```First 50 Curzon numbers using a base of 2:
1    2    5    6    9   14   18   21   26   29   30   33   41   50   53   54   65   69   74   78   81   86   89   90   98
105  113  114  125  134  138  141  146  153  158  165  173  174  186  189  194  198  209  210  221  230  233  245  249  254
Thousandth: 8646

First 50 Curzon numbers using a base of 4:
1    3    7    9   13   15   25   27   37   39   43   45   49   57   67   69   73   79   87   93   97   99  105  115  127
135  139  153  163  165  169  175  177  183  189  193  199  205  207  213  219  235  249  253  255  265  267  273  277  279
Thousandth: 9375

First 50 Curzon numbers using a base of 6:
1    6   30   58   70   73   90  101  105  121  125  146  153  166  170  181  182  185  210  233  241  242  266  282  290
322  373  381  385  390  397  441  445  446  450  453  530  557  562  585  593  601  602  605  606  621  646  653  670  685
Thousandth: 20717

First 50 Curzon numbers using a base of 8:
1   14   35   44   72   74   77  129  131  137  144  149  150  185  200  219  236  266  284  285  299  309  336  357  381
386  390  392  402  414  420  441  455  459  470  479  500  519  527  536  557  582  600  602  617  639  654  674  696  735
Thousandth: 22176

First 50 Curzon numbers using a base of 10:
1    9   10   25  106  145  190  193  238  253  306  318  349  385  402  462  486  526  610  649  658  678  733  762  810
990  994 1033 1077 1125 1126 1141 1149 1230 1405 1422 1441 1485 1509 1510 1513 1606 1614 1630 1665 1681 1690 1702 1785 1837
Thousandth: 46845```

## Phix

```with javascript_semantics
include mpfr.e
mpz {pow,z} = mpz_inits(2)
for base=2 to 10 by 2 do
printf(1,"The first 50 Curzon numbers using a base of %d:\n",base)
integer count = 0, n = 1
mpz_set_si(pow,base)
while true do
integer d = base*n + 1
if mpz_divisible_ui_p(z,d) then
count = count + 1
if count<=50 then
printf(1,"%5d%s",{n,iff(remainder(count,25)=0?"\n":"")})
elsif count=1000 then
printf(1,"One thousandth: %d\n\n",n)
exit
end if
end if
n += 1
mpz_mul_si(pow,pow,base)
end while
end for
```
Output:
```The first 50 Curzon numbers using a base of 2:
1    2    5    6    9   14   18   21   26   29   30   33   41   50   53   54   65   69   74   78   81   86   89   90   98
105  113  114  125  134  138  141  146  153  158  165  173  174  186  189  194  198  209  210  221  230  233  245  249  254
One thousandth: 8646

The first 50 Curzon numbers using a base of 4:
1    3    7    9   13   15   25   27   37   39   43   45   49   57   67   69   73   79   87   93   97   99  105  115  127
135  139  153  163  165  169  175  177  183  189  193  199  205  207  213  219  235  249  253  255  265  267  273  277  279
One thousandth: 9375

The first 50 Curzon numbers using a base of 6:
1    6   30   58   70   73   90  101  105  121  125  146  153  166  170  181  182  185  210  233  241  242  266  282  290
322  373  381  385  390  397  441  445  446  450  453  530  557  562  585  593  601  602  605  606  621  646  653  670  685
One thousandth: 20717

The first 50 Curzon numbers using a base of 8:
1   14   35   44   72   74   77  129  131  137  144  149  150  185  200  219  236  266  284  285  299  309  336  357  381
386  390  392  402  414  420  441  455  459  470  479  500  519  527  536  557  582  600  602  617  639  654  674  696  735
One thousandth: 22176

The first 50 Curzon numbers using a base of 10:
1    9   10   25  106  145  190  193  238  253  306  318  349  385  402  462  486  526  610  649  658  678  733  762  810
990  994 1033 1077 1125 1126 1141 1149 1230 1405 1422 1441 1485 1509 1510 1513 1606 1614 1630 1665 1681 1690 1702 1785 1837
One thousandth: 46845
```

## Quackery

`  [ number\$    space 4 of swap join    -5 split nip echo\$ ]    is rjust   (   n -->   )    [ 5 times       [ 10 times           [ behead rjust ]         cr ]    drop ]                  is display (   [ -->   )   [ temp take    over join    temp put ]              is dax     (   [ -->   )   [ 2dup ** 1+    unrot * 1+ mod 0 = ]    is curzon  ( n n --> b )   5 times    [ i^ 1+ 2 *      say "Curzon numbers base "      dup echo cr      1      [] temp put      [ 2dup curzon if dax        temp share        size 1000 < while        1+ again ]      2drop      temp take       50 split swap display      say "  ... "      -1 peek echo cr cr ] `
Output:
```Curzon numbers base 2
1    2    5    6    9   14   18   21   26   29
30   33   41   50   53   54   65   69   74   78
81   86   89   90   98  105  113  114  125  134
138  141  146  153  158  165  173  174  186  189
194  198  209  210  221  230  233  245  249  254
... 8646

Curzon numbers base 4
1    3    7    9   13   15   25   27   37   39
43   45   49   57   67   69   73   79   87   93
97   99  105  115  127  135  139  153  163  165
169  175  177  183  189  193  199  205  207  213
219  235  249  253  255  265  267  273  277  279
... 9375

Curzon numbers base 6
1    6   30   58   70   73   90  101  105  121
125  146  153  166  170  181  182  185  210  233
241  242  266  282  290  322  373  381  385  390
397  441  445  446  450  453  530  557  562  585
593  601  602  605  606  621  646  653  670  685
... 20717

Curzon numbers base 8
1   14   35   44   72   74   77  129  131  137
144  149  150  185  200  219  236  266  284  285
299  309  336  357  381  386  390  392  402  414
420  441  455  459  470  479  500  519  527  536
557  582  600  602  617  639  654  674  696  735
... 22176

Curzon numbers base 10
1    9   10   25  106  145  190  193  238  253
306  318  349  385  402  462  486  526  610  649
658  678  733  762  810  990  994 1033 1077 1125
1126 1141 1149 1230 1405 1422 1441 1485 1509 1510
1513 1606 1614 1630 1665 1681 1690 1702 1785 1837
... 46845
```

## Raku

`sub curzon (\$base) { lazy (1..∞).hyper.map: { \$_ if (exp(\$_, \$base) + 1) %% (\$base × \$_ + 1) } }; for <2 4 6 8 10> {    my \$curzon = .&curzon;    say "\nFirst 50 Curzon numbers using a base of \$_:\n" ~      \$curzon[^50].batch(25)».fmt("%4s").join("\n") ~      "\nOne thousandth: " ~ \$curzon[999]}`
Output:
```First 50 Curzon numbers using a base of 2:
1    2    5    6    9   14   18   21   26   29   30   33   41   50   53   54   65   69   74   78   81   86   89   90   98
105  113  114  125  134  138  141  146  153  158  165  173  174  186  189  194  198  209  210  221  230  233  245  249  254
One thousandth: 8646

First 50 Curzon numbers using a base of 4:
1    3    7    9   13   15   25   27   37   39   43   45   49   57   67   69   73   79   87   93   97   99  105  115  127
135  139  153  163  165  169  175  177  183  189  193  199  205  207  213  219  235  249  253  255  265  267  273  277  279
One thousandth: 9375

First 50 Curzon numbers using a base of 6:
1    6   30   58   70   73   90  101  105  121  125  146  153  166  170  181  182  185  210  233  241  242  266  282  290
322  373  381  385  390  397  441  445  446  450  453  530  557  562  585  593  601  602  605  606  621  646  653  670  685
One thousandth: 20717

First 50 Curzon numbers using a base of 8:
1   14   35   44   72   74   77  129  131  137  144  149  150  185  200  219  236  266  284  285  299  309  336  357  381
386  390  392  402  414  420  441  455  459  470  479  500  519  527  536  557  582  600  602  617  639  654  674  696  735
One thousandth: 22176

First 50 Curzon numbers using a base of 10:
1    9   10   25  106  145  190  193  238  253  306  318  349  385  402  462  486  526  610  649  658  678  733  762  810
990  994 1033 1077 1125 1126 1141 1149 1230 1405 1422 1441 1485 1509 1510 1513 1606 1614 1630 1665 1681 1690 1702 1785 1837
One thousandth: 46845```

## Rust

`// [dependencies]// rug = "1.15.0" fn is_curzon(n: u32, k: u32) -> bool {    use rug::{Complete, Integer};    (Integer::u_pow_u(k, n).complete() + 1) % (k * n + 1) == 0} fn main() {    for k in (2..=10).step_by(2) {        println!("Curzon numbers with base {k}:");        let mut count = 0;        let mut n = 1;        while count < 50 {            if is_curzon(n, k) {                count += 1;                print!("{:4}{}", n, if count % 10 == 0 { "\n" } else { " " });            }            n += 1;        }        loop {            if is_curzon(n, k) {                count += 1;                if count == 1000 {                    break;                }            }            n += 1;        }        println!("1000th Curzon number with base {k}: {n}\n");    }}`
Output:
```Curzon numbers with base 2:
1    2    5    6    9   14   18   21   26   29
30   33   41   50   53   54   65   69   74   78
81   86   89   90   98  105  113  114  125  134
138  141  146  153  158  165  173  174  186  189
194  198  209  210  221  230  233  245  249  254
1000th Curzon number with base 2: 8646

Curzon numbers with base 4:
1    3    7    9   13   15   25   27   37   39
43   45   49   57   67   69   73   79   87   93
97   99  105  115  127  135  139  153  163  165
169  175  177  183  189  193  199  205  207  213
219  235  249  253  255  265  267  273  277  279
1000th Curzon number with base 4: 9375

Curzon numbers with base 6:
1    6   30   58   70   73   90  101  105  121
125  146  153  166  170  181  182  185  210  233
241  242  266  282  290  322  373  381  385  390
397  441  445  446  450  453  530  557  562  585
593  601  602  605  606  621  646  653  670  685
1000th Curzon number with base 6: 20717

Curzon numbers with base 8:
1   14   35   44   72   74   77  129  131  137
144  149  150  185  200  219  236  266  284  285
299  309  336  357  381  386  390  392  402  414
420  441  455  459  470  479  500  519  527  536
557  582  600  602  617  639  654  674  696  735
1000th Curzon number with base 8: 22176

Curzon numbers with base 10:
1    9   10   25  106  145  190  193  238  253
306  318  349  385  402  462  486  526  610  649
658  678  733  762  810  990  994 1033 1077 1125
1126 1141 1149 1230 1405 1422 1441 1485 1509 1510
1513 1606 1614 1630 1665 1681 1690 1702 1785 1837
1000th Curzon number with base 10: 46845

```

## Sidef

`func is_curzon(n, k) {    powmod(k, n, k*n + 1).is_congruent(-1, k*n + 1) && (n > 0)} for k in (2 .. 10 `by` 2) {    say "\nFirst 50 Curzon numbers using a base of #{k}:"    say 50.by {|n| is_curzon(n, k) }.join(' ')    say ("1000th term: ", 1000.th {|n| is_curzon(n,k) })}`
Output:
```First 50 Curzon numbers using a base of 2:
1 2 5 6 9 14 18 21 26 29 30 33 41 50 53 54 65 69 74 78 81 86 89 90 98 105 113 114 125 134 138 141 146 153 158 165 173 174 186 189 194 198 209 210 221 230 233 245 249 254
1000th term: 8646

First 50 Curzon numbers using a base of 4:
1 3 7 9 13 15 25 27 37 39 43 45 49 57 67 69 73 79 87 93 97 99 105 115 127 135 139 153 163 165 169 175 177 183 189 193 199 205 207 213 219 235 249 253 255 265 267 273 277 279
1000th term: 9375

First 50 Curzon numbers using a base of 6:
1 6 30 58 70 73 90 101 105 121 125 146 153 166 170 181 182 185 210 233 241 242 266 282 290 322 373 381 385 390 397 441 445 446 450 453 530 557 562 585 593 601 602 605 606 621 646 653 670 685
1000th term: 20717

First 50 Curzon numbers using a base of 8:
1 14 35 44 72 74 77 129 131 137 144 149 150 185 200 219 236 266 284 285 299 309 336 357 381 386 390 392 402 414 420 441 455 459 470 479 500 519 527 536 557 582 600 602 617 639 654 674 696 735
1000th term: 22176

First 50 Curzon numbers using a base of 10:
1 9 10 25 106 145 190 193 238 253 306 318 349 385 402 462 486 526 610 649 658 678 733 762 810 990 994 1033 1077 1125 1126 1141 1149 1230 1405 1422 1441 1485 1509 1510 1513 1606 1614 1630 1665 1681 1690 1702 1785 1837
1000th term: 46845
```

## Wren

Library: Wren-gmp
Library: Wren-seq
Library: Wren-fmt
`/* curzon_numbers.wren */ import "./gmp" for Mpzimport "./seq" for Lstimport "./fmt" for Fmt for (k in [2, 4, 6, 8, 10]) {    System.print("The first 50 Curzon numbers using a base of %(k):")    var count = 0    var n = 1    var pow = Mpz.from(k)    var curzon50 = []    while (true) {        var z = pow + Mpz.one        var d = k*n + 1        if (z.isDivisibleUi(d)) {            if (count < 50) curzon50.add(n)            count = count + 1            if (count == 50) {                for (chunk in Lst.chunks(curzon50, 10)) Fmt.print("\$4d", chunk)                System.write("\nOne thousandth: ")            }            if (count == 1000) {                System.print(n)                break            }        }        n = n + 1        pow.mul(k)    }    System.print()}`
Output:
```The first 50 Curzon numbers using a base of 2:
1    2    5    6    9   14   18   21   26   29
30   33   41   50   53   54   65   69   74   78
81   86   89   90   98  105  113  114  125  134
138  141  146  153  158  165  173  174  186  189
194  198  209  210  221  230  233  245  249  254

One thousandth: 8646

The first 50 Curzon numbers using a base of 4:
1    3    7    9   13   15   25   27   37   39
43   45   49   57   67   69   73   79   87   93
97   99  105  115  127  135  139  153  163  165
169  175  177  183  189  193  199  205  207  213
219  235  249  253  255  265  267  273  277  279

One thousandth: 9375

The first 50 Curzon numbers using a base of 6:
1    6   30   58   70   73   90  101  105  121
125  146  153  166  170  181  182  185  210  233
241  242  266  282  290  322  373  381  385  390
397  441  445  446  450  453  530  557  562  585
593  601  602  605  606  621  646  653  670  685

One thousandth: 20717

The first 50 Curzon numbers using a base of 8:
1   14   35   44   72   74   77  129  131  137
144  149  150  185  200  219  236  266  284  285
299  309  336  357  381  386  390  392  402  414
420  441  455  459  470  479  500  519  527  536
557  582  600  602  617  639  654  674  696  735

One thousandth: 22176

The first 50 Curzon numbers using a base of 10:
1    9   10   25  106  145  190  193  238  253
306  318  349  385  402  462  486  526  610  649
658  678  733  762  810  990  994 1033 1077 1125
1126 1141 1149 1230 1405 1422 1441 1485 1509 1510
1513 1606 1614 1630 1665 1681 1690 1702 1785 1837

One thousandth: 46845
```