Curzon numbers: Difference between revisions
No edit summary |
|||
Line 956: | Line 956: | ||
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 |
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 |
1000th term: 46845 |
||
</pre> |
|||
=={{header|Vlang}}== |
|||
{{trans|go}} |
|||
<lang vlang>import math.big |
|||
fn main() { |
|||
zero := big.zero_int |
|||
one := big.one_int |
|||
for k := i64(2); k <= 10; k += 2 { |
|||
bk := big.integer_from_i64(k) |
|||
println("The first 50 Curzon numbers using a base of $k:") |
|||
mut count := 0 |
|||
mut n := i64(1) |
|||
mut pow := big.integer_from_i64(k) |
|||
mut curzon50 := []i64{} |
|||
for { |
|||
z := pow + one |
|||
d := k*n + 1 |
|||
bd := big.integer_from_i64(d) |
|||
if z%bd == zero { |
|||
if count < 50 { |
|||
curzon50 << n |
|||
} |
|||
count++ |
|||
if count == 50 { |
|||
for i in 0..curzon50.len { |
|||
print("${curzon50[i]:4} ") |
|||
if (i+1)%10 == 0 { |
|||
println('') |
|||
} |
|||
} |
|||
print("\nOne thousandth: ") |
|||
} |
|||
if count == 1000 { |
|||
println(n) |
|||
break |
|||
} |
|||
} |
|||
n++ |
|||
pow *= bk |
|||
} |
|||
println('') |
|||
} |
|||
}</lang> |
|||
{{out}} |
|||
<pre> |
|||
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 |
|||
</pre> |
</pre> |
||
Revision as of 13:11, 6 June 2022
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.
- Task
- Find and show the first 50 Generalized Curzon numbers for even base integers from 2 through 10.
- Stretch
- Find and show the one thousandth.
- See also
and even though it is not specifically mentioned that they are Curzon numbers:
- OEIS:A230076 - (A007521(n)-1)/4 (Generalized Curzon numbers with a base 4)
Arturo
<lang rebol>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 ""
]</lang>
- 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++
<lang cpp>#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;
}</lang>
- 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
<lang factor>USING: grouping interpolate io kernel make math math.functions prettyprint 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</lang>
- 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
<lang go>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() }
}</lang>
- 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
Adapted from Julia
Works with gojq, the Go implementation of jq
The following jq program requires gojq for integer-arithmetic accuracy.
Preliminaries <lang jq># 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 _nwise
def _nwise($n):
def n: if length <= $n then . else .[0:$n] , (.[$n:] | n) end; n;
def printRows($m): _nwise($m) | map(lpad(5)) | join("");</lang>
The task <lang jq>def isCurzon($n; $k):
($k | power($n) + 1) % ($k * $n + 1) == 0;
- Emit a stream of Curzon numbers base $k
def 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)</lang>
- 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
<lang 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]) end
end
printcurzons(2, 10)
</lang>
- 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. <lang pascal> 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. </lang>
- 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
Mathematica /Wolfram Language
<lang Mathematica>ClearAll[CurzonNumberQ] CurzonNumberQ[b_Integer][n_Integer]:=PowerMod[b,n,b n+1]==b n val=Select[Range[100000],CurzonNumberQ[2]]; Take[val,50] val1000
val=Select[Range[100000],CurzonNumberQ[4]]; Take[val,50] val1000
val=Select[Range[100000],CurzonNumberQ[6]]; Take[val,50] val1000
val=Select[Range[100000],CurzonNumberQ[8]]; Take[val,50] val1000
val=Select[Range[100000],CurzonNumberQ[10]]; Take[val,50] val1000</lang>
- Output:
{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 {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 {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 {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 {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
Perl
<lang 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";
}</lang>
- 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 mpz_add_ui(z,pow,1) 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
<lang 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 ]
</lang>
- 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
<lang perl6>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]
}</lang>
- 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
<lang 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"); }
}</lang>
- 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
<lang ruby>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) })
}</lang>
- 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
Vlang
<lang vlang>import math.big
fn main() {
zero := big.zero_int one := big.one_int for k := i64(2); k <= 10; k += 2 { bk := big.integer_from_i64(k) println("The first 50 Curzon numbers using a base of $k:") mut count := 0 mut n := i64(1) mut pow := big.integer_from_i64(k) mut curzon50 := []i64{} for { z := pow + one d := k*n + 1 bd := big.integer_from_i64(d) if z%bd == zero { if count < 50 { curzon50 << n } count++ if count == 50 { for i in 0..curzon50.len { print("${curzon50[i]:4} ") if (i+1)%10 == 0 { println() } } print("\nOne thousandth: ") } if count == 1000 { println(n) break } } n++ pow *= bk } println() }
}</lang>
- 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
Wren
<lang ecmascript>/* curzon_numbers.wren */
import "./gmp" for Mpz import "./seq" for Lst import "./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()
}</lang>
- 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