Ulam spiral (for primes)
You are encouraged to solve this task according to the task description, using any language you may know.
An Ulam spiral (of primes numbers) is a method of visualizing prime numbers when expressed in a (normally counter-clockwise) outward spiral (usually starting at 1), constructed on a square grid, starting at the "center".
An Ulam spiral is also known as a prime spiral.
The first grid (green) is shown with all numbers (primes and non-primes) shown, starting at 1.
In an Ulam spiral of primes, only the primes are shown (usually indicated by some glyph such as a dot), and all non-primes as shown as a blank (or some other whitespace). Of course, the grid and border are not to be displayed (but they are displayed here when using these Wiki HTML tables).
Normally, the spiral starts in the "center", and the 2nd number is to the viewer's right and the number spiral starts from there in a counter-clockwise direction. There are other geometric shapes that are used as well, including clock-wise spirals. Also, some spirals (for the 2nd number) is viewed upwards from the 1st number instead of to the right, but that is just a matter of orientation.
Sometimes, the starting number can be specified to show more visual striking patterns (of prime densities).
| 65 | 64 | 63 | 62 | 61 | 60 | 59 | 58 | 57 |
| 66 | 37 | 36 | 35 | 34 | 33 | 32 | 31 | 56 |
| 67 | 38 | 17 | 16 | 15 | 14 | 13 | 30 | 55 |
| 68 | 39 | 18 | 5 | 4 | 3 | 12 | 29 | 54 |
| 69 | 40 | 19 | 6 | 1 | 2 | 11 | 28 | 53 |
| 70 | 41 | 20 | 7 | 8 | 9 | 10 | 27 | 52 |
| 71 | 42 | 21 | 22 | 23 | 24 | 25 | 26 | 51 |
| 72 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 |
| 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 |
[A larger than necessary grid (numbers wise) is shown here to illustrate the pattern of numbers on the diagonals (which may be used by the method to orientate the direction of spiral-construction algorithm within the example computer programs)].
Then, to show the Ulam prime spiral, a character (or glyph) is shown instead of each prime number, and a blank for all non-prime numbers. In the orange grid below, the prime numbers are left intact to see what numbers are to be changed to the character for viewing.
| 61 | 59 | |||||||
| 37 | 31 | |||||||
| 67 | 17 | 13 | ||||||
| 5 | 3 | 29 | ||||||
| 19 | 2 | 11 | 53 | |||||
| 41 | 7 | |||||||
| 71 | 23 | |||||||
| 43 | 47 | |||||||
| 73 | 79 |
Then, in the final transformation of the Ulam spiral (the yellow grid), translate the primes to a glyph such as a ∙ or some other suitable glyph.
| ∙ | ∙ | |||||||
| ∙ | ∙ | |||||||
| ∙ | ∙ | ∙ | ||||||
| ∙ | ∙ | ∙ | ||||||
| ∙ | ∙ | ∙ | ∙ | |||||
| ∙ | ∙ | |||||||
| ∙ | ∙ | |||||||
| ∙ | ∙ | |||||||
| ∙ | ∙ |
- Task
For any sized N x N grid, construct and show an Ulam spiral (counter-clockwise) of primes starting at some specified initial number (the default would be 1), with some suitably dotty representation to indicate primes, and the absence of dots to indicate non-primes.
You should demonstrate the generator by showing at Ulam prime spiral large enough to (almost) fill your terminal screen.
- Also see
-
- Wikipedia entry: Ulam spiral.
- MathWorld™ entry: Prime Spiral.
C
<lang c>
- include <stdio.h>
- include <stdint.h>
- include <stdlib.h>
- include <math.h>
typedef uint32_t bitsieve;
unsigned sieve_check(bitsieve *b, const unsigned v) {
if ((v != 2 && !(v & 1)) || (v < 2))
return 0;
else
return !(b[v >> 6] & (1 << (v >> 1 & 31)));
}
bitsieve* sieve(const unsigned v) {
unsigned i, j; bitsieve *b = calloc((v >> 6) + 1, sizeof(uint32_t));
for (i = 3; i <= sqrt(v); i += 2)
if (!(b[i >> 6] & (1 << (i >> 1 & 31))))
for (j = i*i; j < v; j += (i << 1))
b[j >> 6] |= (1 << (j >> 1 & 31));
return b;
}
- define max(x,y) ((x) > (y) ? (x) : (y))
/* This mapping taken from python solution */ int ulam_get_map(int x, int y, int n) {
x -= (n - 1) / 2; y -= n / 2;
int mx = abs(x), my = abs(y); int l = 2 * max(mx, my); int d = y > x ? l * 3 + x + y : l - x - y;
return pow(l - 1, 2) + d;
}
/* Passing a value of 0 as glyph will print numbers */ void output_ulam_spiral(int n, const char glyph) {
/* An even side length does not make sense, use greatest odd value < n */ n -= n % 2 == 0 ? 1 : 0;
const char *spaces = "................."; int mwidth = log10(n * n) + 1;
bitsieve *b = sieve(n * n + 1); int x, y;
for (x = 0; x < n; ++x) {
for (y = 0; y < n; ++y) {
int z = ulam_get_map(y, x, n);
if (glyph == 0) {
if (sieve_check(b, z))
printf("%*d ", mwidth, z);
else
printf("%.*s ", mwidth, spaces);
}
else {
printf("%c", sieve_check(b, z) ? glyph : spaces[0]);
}
}
printf("\n");
}
free(b);
}
int main(int argc, char *argv[]) {
const int n = argc < 2 ? 9 : atoi(argv[1]);
output_ulam_spiral(n, 0);
printf("\n");
output_ulam_spiral(n, '#');
printf("\n");
return 0;
} </lang>
- Output:
Run with a side-length of 29
... ... ... ... ... ... ... ... ... ... ... ... 773 ... ... ... 769 ... ... ... ... ... ... ... 761 ... ... ... 757 ... 677 ... ... ... 673 ... ... ... ... ... ... ... ... ... ... ... 661 ... 659 ... ... ... ... ... 653 ... ... ... 787 ... 577 ... ... ... ... ... 571 ... 569 ... ... ... ... ... 563 ... ... ... ... ... 557 ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... 479 ... ... ... ... ... ... ... ... ... ... ... 467 ... ... ... 463 ... ... ... ... ... ... ... 401 ... ... ... 397 ... ... ... ... ... ... ... 389 ... ... ... ... ... 383 ... ... ... ... ... ... ... ... ... 487 ... ... ... ... ... ... ... ... ... 317 ... ... ... 313 ... 311 ... ... ... 307 ... 461 ... 647 ... ... ... ... ... ... ... 257 ... ... ... ... ... 251 ... ... ... ... ... ... ... ... ... 241 ... 379 ... ... ... 751 ... 683 ... ... ... ... ... 197 ... ... ... 193 ... 191 ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... 139 ... 137 ... ... ... ... ... 239 ... ... ... 547 ... ... ... ... ... 491 ... ... ... 199 ... 101 ... ... ... 97 ... ... ... ... ... ... ... 181 ... ... ... 457 ... 643 ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... 61 ... 59 ... ... ... 131 ... ... ... ... ... ... ... ... ... ... ... ... ... 331 ... ... ... 103 ... 37 ... ... ... ... ... 31 ... 89 ... 179 ... ... ... ... ... 641 ... 797 ... 587 ... 409 ... 263 ... 149 ... 67 ... 17 ... ... ... 13 ... ... ... ... ... ... ... 373 ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... 5 ... 3 ... 29 ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... 151 ... ... ... 19 ... ... 2 11 ... 53 ... 127 ... 233 ... ... ... 541 ... 743 ... 691 ... ... ... ... ... ... ... 107 ... 41 ... 7 ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... 71 ... ... ... 23 ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... 499 ... 337 ... ... ... 109 ... 43 ... ... ... 47 ... ... ... 83 ... 173 ... ... ... 449 ... ... ... ... ... 593 ... ... ... 269 ... ... ... 73 ... ... ... ... ... 79 ... ... ... ... ... 229 ... 367 ... ... ... 739 ... ... ... ... ... ... ... ... ... ... ... 113 ... ... ... ... ... ... ... ... ... ... ... 293 ... ... ... ... ... ... ... ... ... ... ... 271 ... 157 ... ... ... ... ... 163 ... ... ... 167 ... ... ... 227 ... ... ... ... ... ... ... ... ... 503 ... ... ... 211 ... ... ... ... ... ... ... ... ... ... ... 223 ... ... ... ... ... ... ... 631 ... ... ... ... ... 419 ... ... ... ... ... 277 ... ... ... 281 ... 283 ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... 347 ... 349 ... ... ... 353 ... ... ... ... ... 359 ... ... ... 443 ... ... ... 809 ... 599 ... 421 ... ... ... ... ... ... ... ... ... 431 ... 433 ... ... ... ... ... 439 ... ... ... ... ... 733 ... 701 ... ... ... 509 ... ... ... ... ... ... ... ... ... ... ... 521 ... 523 ... ... ... ... ... ... ... ... ... 811 ... 601 ... ... ... ... ... 607 ... ... ... ... ... 613 ... ... ... 617 ... 619 ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... 709 ... ... ... ... ... ... ... ... ... 719 ... ... ... ... ... ... ... 727 ... ... ... ... ... ... ... ... ... ... ... 821 ... 823 ... ... ... 827 ... 829 ... ... ... ... ... ... ... ... ... 839 ... ... ............#...#.......#...# .#...#...........#.#.....#... #.#.....#.#.....#.....#...... .........#...........#...#... ....#...#.......#.....#...... ...#.........#...#.#...#.#.#. ......#.....#.........#.#...# .#.....#...#.#............... ..............#.#.....#...#.. ...#...#.#...#.......#...#.#. ..............#.#...#........ .....#...#.#.....#.#.#.....#. #.#.#.#.#.#.#...#.......#.... .............#.#.#........... ........#...#..##.#.#.#...#.# .#.......#.#.#............... ..........#...#.............. ...#.#...#.#...#...#.#...#... ..#...#...#.....#.....#.#...# ...........#...........#..... ......#.#.....#...#...#...... ...#...#...........#.......#. ....#.....#...#.#............ .........#.#...#.....#...#... #.#.#.........#.#.....#.....# .#...#...........#.#......... #.#.....#.....#...#.#........ .......#.........#.......#... ........#.#...#.#.........#..
D
<lang d>import std.stdio, std.math, std.algorithm, std.array, std.range;
int cell(in int n, int x, int y, in int start=1) pure nothrow @safe @nogc {
x = x - (n - 1) / 2; y = y - n / 2; immutable l = 2 * max(x.abs, y.abs); immutable d = (y > x) ? (l * 3 + x + y) : (l - x - y); return (l - 1) ^^ 2 + d + start - 1;
}
void showSpiral(in int n, in string symbol="# ", in int start=1, string space=null) /*@safe*/ {
if (space is null)
space = " ".replicate(symbol.length);
immutable top = start + n ^^ 2 + 1;
auto isPrime = [false, false, true] ~ [true, false].replicate(top / 2);
foreach (immutable x; 3 .. 1 + cast(int)real(top).sqrt) {
if (!isPrime[x])
continue;
foreach (immutable i; iota(x ^^ 2, top, x * 2))
isPrime[i] = false;
}
string cellStr(in int x) pure nothrow @safe @nogc {
return isPrime[x] ? symbol : space;
}
foreach (immutable y; 0 .. n)
n.iota.map!(x => cell(n, x, y, start)).map!cellStr.joiner.writeln;
}
void main() {
35.showSpiral;
}</lang>
- Output:
# # # #
# # # # #
# # # #
# # # # #
# # # # #
# # # # # #
# # # # #
# # # # #
# # # # # # # #
# # # # # #
# # # # #
# # # # #
# # # # # # # #
# # #
# # # # # # # # # #
# # # # # # # # # #
# # # #
# # # # # # # # # #
# # # #
# #
# # # # # # # # # # #
# # # # # # #
# #
# # # # # #
# # # # #
# # # # #
# # # # # #
# # # # # # # # #
# # # #
# # # # # #
# # # # # #
# # # # #
# # # # #
# # # #
# # # # #
Alternative Version
This generates a PGM image, using the module from the Grayscale Image Task; <lang d>import std.stdio, std.math, std.algorithm, std.array, grayscale_image;
uint cell(in uint n, int x, int y, in uint start=1) pure nothrow @safe @nogc {
x = x - (n - 1) / 2; y = y - n / 2; immutable l = 2 * max(x.abs, y.abs); immutable d = (y > x) ? (l * 3 + x + y) : (l - x - y); return (l - 1) ^^ 2 + d + start - 1;
}
bool[] primes(in uint n, in uint top, in uint start=1) pure nothrow @safe {
auto isPrime = [false, false, true] ~ [true, false].replicate(top / 2);
foreach (immutable x; 3 .. 1 + cast(uint)real(top).sqrt)
if (isPrime[x])
for (uint i = x ^^ 2; i < top; i += x * 2)
isPrime[i] = false;
return isPrime;
}
void main() {
enum n = 512; enum start = 1; immutable top = start + n ^^ 2 + 1; immutable isPrime = primes(n, top, start); auto img = new Image!Gray(n, n);
foreach (immutable y; 0 .. n)
foreach (immutable x; 0 .. n)
img[x, y] = isPrime[cell(n, x, y, start)] ? Gray.black : Gray.white;
img.savePGM("ulam_spiral.pgm");
}</lang>
Perl
<lang perl>use ntheory qw/is_prime/; use Imager;
my $n = shift || 512; my $start = shift || 1; my $file = "ulam.png";
sub cell {
my($n, $x, $y, $start) = @_; $y -= $n>>1; $x -= ($n-1)>>1; my $l = 2*(abs($x) > abs($y) ? abs($x) : abs($y)); my $d = ($y > $x) ? $l*3 + $x + $y : $l-$x-$y; ($l-1)**2 + $d + $start - 1;
}
my $black = Imager::Color->new('#000000'); my $white = Imager::Color->new('#FFFFFF'); my $img = Imager->new(xsize => $n, ysize => $n, channels => 1); $img->box(filled=>1, color=>$white);
for my $y (0 .. $n-1) {
for my $x (0 .. $n-1) {
my $v = cell($n, $x, $y, $start);
$img->setpixel(x => $x, y => $y, color => $black) if is_prime($v);
}
}
$img->write(file => $file) or die "Cannot write $file: ", $img->errstr, "\n";</lang>
- Output:
Creates an image file ulam.png in current directory similar to the one on MathWorld. The square dimension can be optionally specified.
Perl 6
<lang perl6>sub MAIN($max = 160, $start = 1) {
(my %world){0}{0} = 0;
my $loc = 0+0i;
my $dir = 1;
my $n = $start;
my $side = 0;
while ++$side < $max {
step for ^$side; turn-left; step for ^$side; turn-left;
}
braille-graphics %world;
sub step {
$loc += $dir; %world{$loc.im}{$loc.re} = $n if (++$n).is-prime;
}
sub turn-left { $dir *= -i; }
sub turn-right { $dir *= i; }
}
sub braille-graphics (%a) {
my ($ylo, $yhi, $xlo, $xhi);
for %a.keys -> $y {
$ylo min= +$y; $yhi max= +$y; for %a{$y}.keys -> $x { $xlo min= +$x; $xhi max= +$x; }
}
for $ylo, $ylo + 4 ...^ * > $yhi -> \y {
for $xlo, $xlo + 2 ...^ * > $xhi -> \x { my $cell = 0x2800; $cell += 1 if %a{y + 0}{x + 0}; $cell += 2 if %a{y + 1}{x + 0}; $cell += 4 if %a{y + 2}{x + 0}; $cell += 8 if %a{y + 0}{x + 1}; $cell += 16 if %a{y + 1}{x + 1}; $cell += 32 if %a{y + 2}{x + 1}; $cell += 64 if %a{y + 3}{x + 0}; $cell += 128 if %a{y + 3}{x + 1}; print chr($cell); } print "\n";
}
}</lang>
- Output:
⠔⠀⠀⠀⢐⠀⠁⠀⠀⠀⢐⠁⠀⢀⠀⠄⠄⠀⢀⠀⠀⠅⢀⠁⢅⢄⠀⢀⠔⠁⠀⠀⠀⢀⢀⠀⠀⠀⠁⢀⢀⠀⠀⢔⠁⢔⠄⠀⢄⠐⠀⠀⢀⠁⠐⠄⠀⢑⠄⠁⠄⠀⠁⠄⠀⠀⠀⢐⠀⠄⠐⠀⢁⢀⠀⠀⠄⠀⢕⠐ ⠄⠁⠁⠄⠀⠄⢀⠀⠐⠀⠀⠁⢁⢀⠐⠀⠀⠀⢁⠐⠄⠀⠀⠔⠀⢐⠁⠄⠀⠑⠀⢀⠁⠀⠐⠐⠁⠀⠄⠀⢀⠀⠀⠀⠐⠀⠐⠀⠅⠀⠀⢄⢀⠐⠁⠐⠄⠁⢀⠀⠀⠐⠁⠀⠀⠄⢄⠀⠕⠁⠀⠐⢄⠀⠀⢀⠐⠄⠁⠀ ⠀⠀⢀⠁⢀⠀⠑⢀⠀⠄⠀⠀⠅⢑⠀⠁⠐⠀⠀⠐⠀⠄⠁⢄⠀⢑⠀⠄⢑⠀⠁⠀⢀⠑⢐⠀⠁⢀⠄⠐⢀⠄⠁⠀⠀⠀⠀⢀⠄⠀⠀⠑⠀⢀⠔⢁⠀⠀⠀⠀⠐⠁⠀⠑⢀⠀⠐⠀⢄⠔⢐⠄⠅⠐⠀⠅⢁⠀⠁⠁ ⠅⢀⠄⠑⠀⠀⠅⠄⠀⢐⠐⠀⠀⠄⠀⢁⠄⠀⢔⢀⠁⠀⠔⠁⠑⢐⠀⠐⠀⠁⢑⠀⠀⢁⠀⠀⠄⠀⠀⠑⢀⠀⠄⠔⠁⠀⠄⠀⠐⢀⠀⠀⠔⠁⠀⠐⠀⠀⠐⠁⠐⠀⠀⢀⠄⠁⢁⠀⠀⠐⠀⠁⢐⠀⠐⠀⠄⠑⠐⠄ ⠀⠀⠀⢐⠑⠑⢀⠁⠑⢀⠐⠀⠄⠀⠀⢀⢐⠕⠄⠀⠀⠀⠐⠀⠀⢀⠄⠀⠀⠀⠄⠐⠐⠀⠀⠁⢄⠐⠅⢀⠐⠄⠁⠐⠀⠅⢀⠐⢁⢀⠀⠁⠐⠕⠀⠀⠀⠀⢐⠀⠅⠐⠔⢁⠀⠐⠅⠐⠄⢀⠀⢄⠀⢀⠄⠀⠀⢀⠁⠐ ⢀⠀⠀⢀⠁⠀⠀⠀⢁⠁⠐⠀⠁⢐⢀⠀⠁⠀⠔⠁⢄⠁⠁⠄⠀⢀⠄⠀⢐⠀⠔⠁⢀⠕⠁⢀⠁⠀⢀⠔⢐⠀⠀⠁⢀⠀⠀⢀⠔⠀⠄⠄⠁⠀⠄⢐⠄⠁⢁⠀⠄⠀⠀⠄⠀⢄⠀⢀⢀⠁⠄⢀⠄⠀⢀⠁⢁⠀⠀⠀ ⠁⠄⠀⠀⠄⠀⠄⠀⠄⠑⢄⠔⠁⠀⠁⠀⠐⠀⠀⠀⠀⠀⢀⠀⠀⠄⠁⢁⠐⠀⠀⢀⠀⠄⠐⠀⢐⠀⠁⠀⠀⠁⠁⠄⠁⢄⠔⠀⠐⠀⠀⠔⢄⠀⠀⢐⠀⢅⠀⠁⢀⠀⠀⠀⠀⠀⠄⠀⠐⠀⠀⠀⠄⠀⠀⠀⠐⠀⠄⠄ ⠀⠑⠐⠔⠀⢀⢀⠀⢁⠔⠁⢁⠄⠁⠀⠀⠀⠅⠀⢀⠀⠁⢀⠀⢄⠀⠀⠀⠐⠀⢀⠐⠁⢀⠀⠀⠀⢀⠁⠀⠐⠀⠄⢀⠔⢁⠀⠀⢅⠐⠑⠅⠀⠐⠀⢀⠁⢄⠀⠀⢁⠐⠄⠀⠐⢕⢀⠁⢀⠁⠑⠅⠀⢁⠐⠀⠁⠀⢁⢐ ⢀⠁⠄⠀⠀⢄⠁⠄⠀⠀⠐⠅⠁⠁⢀⢀⢅⠄⠐⢁⠀⠄⠀⠄⠅⠑⢀⠔⢀⠀⠀⢁⠀⠕⠐⠀⠀⠐⢄⠐⢀⠄⠀⠁⢀⠁⢀⠀⠄⢀⠀⠀⠀⢀⠑⢐⠀⠀⠁⠄⠐⠁⠄⠄⠀⠀⠐⢄⢀⠀⠄⠄⠀⠀⠀⠄⢄⢀⠄⠀ ⠐⠄⠐⠁⠀⠔⠑⠀⠀⠐⠀⠀⠑⠀⠐⠄⠀⠀⠐⠀⠁⢀⠄⠀⠀⢐⠀⠔⠀⠀⢄⠄⠁⢐⠀⠀⢄⠔⠀⢀⢐⠁⠅⢀⠀⠄⠐⠀⢐⠀⠁⢕⠄⠀⠀⢔⠁⠀⢐⠀⢀⠄⠑⠄⠀⠀⠄⠀⠀⠄⠐⠁⠄⠀⠐⠔⠄⠀⠀⠀ ⢀⠐⢀⢐⠀⠀⠄⠑⠑⠐⠐⠀⠔⠑⠀⠐⠀⢀⠀⠀⢀⠄⠀⠁⢄⠀⠁⠀⢀⠁⢀⠀⠀⠀⠐⠄⠁⢐⠔⠅⢐⠅⠀⠀⠅⠀⠀⠀⠁⠀⠔⠄⠀⠔⢀⠀⠄⢁⠐⢁⢀⢁⢀⢀⢁⠄⠁⢀⠀⠀⢁⢑⠀⢀⢐⠁⠀⠀⠀⠁ ⠀⠄⠅⠀⠁⠅⠁⢁⠄⠀⠀⢀⠀⢄⠀⠁⠁⢁⠀⠄⢅⢁⠄⠄⠐⢀⢀⠄⠁⠀⠀⠀⢄⠔⠁⢀⠐⠁⠄⠐⠀⠀⠁⢐⠀⠀⢀⢀⠀⠀⠀⠐⠀⠄⠐⠀⠀⠁⠄⠀⠁⠀⠀⠁⢄⠀⠁⢅⠀⠄⠁⠀⠁⠅⢀⠀⠀⠀⠐⠁ ⠁⠀⠀⠀⠀⠀⠀⢄⠀⠐⢀⠀⠐⠄⠄⠁⠀⠔⠔⠄⠀⠁⠀⠐⠄⢀⠀⠄⠔⠀⠁⠀⠀⢐⢔⠁⠅⠀⠀⢐⠀⠀⠄⠄⠀⠑⠔⠀⠅⢀⠁⠔⢀⠀⢔⠀⠁⠐⠐⠐⢐⠔⠀⠐⠀⠐⠀⠀⠐⢐⠄⠐⠐⠀⠑⢐⠐⠑⠐⠐ ⢀⠁⠁⠀⠀⢑⢀⠀⠑⢀⠀⢀⠀⠀⠁⢔⠀⠀⠀⠀⢀⢀⠁⠁⢄⠀⢁⠀⠀⠐⠁⢀⠐⢁⠐⠐⢁⠐⠀⢄⠐⠅⠀⢐⠄⢁⢀⠐⠄⠐⠐⠀⠀⠔⠀⠑⢔⢀⠑⠀⠀⠐⠑⠀⠀⠐⢀⢀⠑⠀⠐⢀⠀⠁⠐⠁⠀⢁⠀⠀ ⠀⠔⠀⢀⠀⠀⢀⠑⠄⠁⠄⠄⢀⠐⠁⠁⠅⠁⢁⢀⠁⠀⢐⠀⠁⠅⢀⢁⠀⢀⠑⢑⠄⠀⠀⠄⠀⠁⢄⠀⢐⠄⠁⠑⢀⠅⢑⠀⠀⠀⠄⠄⢄⠄⠕⢀⠀⠔⢄⢀⠀⠀⠀⠁⢄⠄⠀⠁⠀⠐⠄⠀⠁⢀⠄⠔⠁⠀⠁⠄ ⠀⠀⠐⠀⠄⠀⠀⢀⠄⠄⢄⠔⠐⢄⠀⠀⠄⠀⠀⠀⠀⠀⢄⠔⠐⠀⠔⠐⠀⠀⠔⠀⠀⢕⢔⠀⠁⢐⠁⢑⠐⠁⠀⠀⠀⢄⠀⠀⢅⠐⠑⠐⠀⠀⢐⠔⠀⠄⠀⠑⢔⠀⠀⠔⠀⠁⢀⠄⠀⠀⠀⠀⠀⠐⠀⠀⠐⠀⠐⠀ ⠄⠐⠀⠄⠀⢀⠐⠀⢀⢐⠀⢀⠄⠀⢐⠀⠀⠀⠀⠐⠐⢄⠀⠀⠔⠀⢀⠀⠀⢐⢔⠀⢀⢄⠀⠄⢀⢀⠐⠁⢐⠅⠅⢀⠑⠄⠐⠐⠀⢀⠀⠁⠁⠑⠀⢁⠅⠀⠁⠄⠀⠁⠀⠀⠁⠁⠁⠐⠑⠁⠁⠀⢀⠐⢀⢀⠀⠁⠀⢀ ⢁⢀⠄⠁⠐⠀⢁⠀⠀⠀⠀⠁⠀⢑⠀⢁⠐⠀⠀⠀⢁⠁⢐⠀⢀⠀⠀⠀⢕⢄⢁⢑⠄⠀⠔⢀⠐⠁⢀⠄⠐⠄⠄⢑⢄⠅⢄⠀⠁⢁⢀⠐⠁⢀⠀⠄⠀⠐⠀⠀⠀⢀⠀⠁⢄⠀⠄⠀⢀⠅⢁⠀⠀⢀⠀⠅⠄⠀⠑⠀ ⠁⠄⠄⠁⠄⠀⠀⠀⠀⠁⠀⠄⠁⠀⠀⠄⠀⠀⠁⠄⠀⠁⠄⠀⠀⠄⠄⠄⠀⠀⠄⠀⠄⠁⠄⠀⠅⠄⠁⢕⢐⠀⢀⠔⠀⠔⠄⠑⠐⠀⠑⢔⠐⠁⠐⠐⠀⢄⠐⠐⠄⠀⠀⠀⠔⠑⠄⠄⠀⠀⠀⠀⢀⠄⠀⠀⠀⠁⢐⠔ ⠐⠀⠑⢐⠁⠀⢐⠑⢁⢀⠐⢀⢐⠑⠁⠀⠀⢀⠀⠁⠑⠀⠑⢐⢀⠑⢐⠀⠁⢑⠀⠑⠐⠐⠐⠑⢐⠑⢑⠄⣔⢅⢁⢁⠐⢀⢁⢅⠁⠐⢐⠀⠀⠄⢀⢐⢅⢁⠀⠀⠀⠀⠐⠁⢁⠔⢀⢑⠁⢁⠐⢀⠀⠀⢄⢀⢁⢅⢀⠀ ⢀⠀⠀⠁⠀⠀⠀⢐⢀⠁⠀⠀⠁⠀⠅⠀⠔⢁⢀⠀⠀⠀⢁⢁⠁⢐⠀⢀⠅⠅⢀⠀⠄⢁⠄⢄⠀⢕⠅⠑⢄⠀⠄⢄⢀⠄⢀⠄⠄⠀⢄⠀⠄⢄⠀⠀⢀⠄⢀⢀⠄⠀⠄⠄⠀⢀⠀⢄⠄⠀⢄⢀⠄⢀⢀⠄⠀⠄⠀⢀ ⠐⢄⠀⠄⠀⠄⠐⠀⠀⠁⢀⠀⠅⠀⠄⠄⠀⠀⠀⢀⠔⠕⠄⠄⠑⠀⠀⠁⠀⠐⠔⢄⠀⠀⢄⠐⠔⢀⠁⢐⢀⠐⠄⠐⠁⠀⠄⠐⠐⠄⠁⠀⠐⠀⠄⠀⠑⠄⠐⠀⠀⠐⠀⠔⠀⠁⠔⠀⠁⠀⠀⠑⠄⠔⠀⠀⠀⠑⠐⠀ ⠀⠀⢀⠄⠐⠀⠀⠀⢀⠄⠀⢑⢀⠁⠐⢀⠑⠀⠔⠐⢁⢐⠀⠐⢀⠀⠑⢐⠀⠀⢀⠐⢐⢔⠐⠄⢀⠁⠁⢐⠑⢄⢄⠑⠀⠁⠐⠐⢁⠐⠑⢁⠑⢀⢀⢀⠐⠁⢐⢐⠀⠐⠐⠀⢀⠑⢁⠁⠀⠀⠀⠑⠀⠁⢐⢀⠑⠀⢀⢀ ⠁⢀⠀⠀⢁⠀⠀⠅⠀⠀⠅⠀⠀⠐⢀⢀⢀⠄⠀⠅⠀⢁⠔⠀⠁⢁⠁⠁⠑⢄⠀⠁⠁⢀⢀⠄⠑⢔⠀⠐⠔⠁⠀⠄⠀⠑⢀⠀⠕⠄⠀⠀⠄⢀⠀⠁⢄⠁⢄⠄⠐⠄⢄⠔⠀⠀⠐⠁⢀⠐⠀⠀⠅⠀⠀⠔⠀⢀⠁⠀ ⠀⢄⠐⠁⠀⠐⠕⠀⠄⠐⠀⠐⠀⢀⠐⠐⠀⠀⠅⠀⠄⠁⢀⠄⠀⠄⠔⠑⢀⠀⠅⠀⠅⠄⠀⠄⠁⢀⠄⠀⢀⠀⢁⢀⠕⠀⠀⠑⠀⠐⠀⢄⠐⠁⢄⠄⠁⠐⠄⠐⢀⠀⠁⠄⠔⠀⢄⠀⠁⠄⠔⠁⢐⠄⠐⠀⠀⠑⢀⠔ ⢀⠐⢀⠀⠀⠐⠄⠁⠐⠄⠐⠀⢀⠑⠁⠄⠀⠁⠐⠀⢀⠀⠁⢀⠀⠐⠐⠔⠁⢀⠀⠑⠀⠀⠐⠀⢔⠑⠀⢐⠀⢁⢀⠐⠀⢀⠐⢀⠄⠁⢄⠁⠀⠀⠁⠀⠀⠀⢐⢀⢁⢑⠀⢀⠑⠐⠁⠀⢀⢀⠀⠁⢀⢀⠀⠀⠐⢀⠀⠐ ⢀⢁⠀⠀⢑⢅⢁⢄⢀⢀⠅⠀⠀⠄⢀⢁⢐⢁⢀⢅⢄⠀⠀⢀⢀⠐⠅⠁⠀⠀⢁⠐⠀⢀⠀⠀⠐⢀⠀⢀⠄⠅⠐⢐⠀⠀⠔⠁⠑⠐⠄⠀⠄⠀⠅⠁⠄⠐⠀⠀⠁⠁⠀⠄⠅⠀⠀⠄⠄⠅⠀⠄⠀⠄⠀⠁⠀⠀⠔⠀ ⠁⠀⠀⠁⠀⠀⠀⢀⠄⠀⠀⠀⠀⠄⠄⠀⢀⠀⠐⢀⠀⠀⢄⠔⠄⠀⠄⠀⠀⠔⠕⢀⠔⠀⠀⠄⠄⠀⠁⠐⠀⠀⠕⢀⠕⠁⠀⠁⢑⠀⠀⢀⢀⠐⠄⠀⠑⠀⠀⠁⢄⠔⠑⢐⠀⠑⢄⠐⠀⠀⠐⠀⠀⠀⠀⠀⠄⠁⢀⠄ ⠀⠁⠐⠀⠁⠀⠄⠀⠑⠀⠀⢀⠀⠐⠀⠄⠀⠑⠀⠀⢐⠀⠁⢅⠀⠀⠀⠐⠀⢀⠄⠀⢁⢄⠀⠁⠔⠑⠄⠀⠑⢄⠔⠁⢀⠀⠀⢄⠄⠀⠀⠐⠁⠁⢀⠐⠄⠀⠁⠐⠁⢀⢑⠁⠐⠐⢀⠑⠔⠀⠁⠀⢁⢀⠄⠁⢐⠀⠀⠀ ⠀⠅⠁⢀⠐⠀⠁⠐⠀⠁⠐⢄⠀⢄⢀⠀⠄⢀⠁⢁⠄⠀⠐⠀⢑⠄⠀⠑⠐⠀⠁⠀⠁⠐⠐⠀⠁⠄⠄⢀⠄⠁⠐⢀⠄⠐⠀⠄⠀⠄⠀⠀⢀⠄⢀⢐⠀⠑⠀⠀⠄⢄⢄⠀⢅⠀⠀⠄⠀⠅⠀⠄⠐⢀⠀⠔⠅⠀⠄⢁ ⠄⠀⠄⠄⠀⠄⠀⢀⠀⠐⠀⠀⠁⠀⠔⠄⠀⠀⠁⠀⠄⢄⠀⠐⠀⠀⠄⢑⠀⠁⠅⠀⠁⠀⢀⠄⠑⢀⠄⢀⢀⠔⢀⠀⠑⠄⠀⠅⠀⠀⠅⢕⠀⠐⢐⠀⠄⠕⠀⠀⢀⠀⠀⢀⠀⠁⠀⠀⠐⢀⠐⠁⢀⠔⠁⢐⠀⠀⠐⠀ ⠀⠐⢁⢀⠐⠀⢀⠁⠀⠀⠁⠑⠄⠀⢁⠐⠁⠅⢀⠐⢀⠄⠀⠀⠐⠀⠅⢀⠐⢀⢀⠁⠅⢀⠀⠄⠔⠑⠁⠀⠁⠀⠐⠁⢀⠀⠀⢀⠀⠐⠄⠔⠐⠁⢄⠀⠅⢄⠑⠀⢀⠐⠀⠀⢁⢀⠀⢀⠁⢀⠁⠅⠁⠀⠁⠀⠀⠄⠀⠁ ⠀⠀⢀⠀⠄⢁⠀⠀⠄⠀⢁⢁⠀⠀⠀⠐⠀⠄⠀⠐⠀⢀⢀⠁⠁⠄⠄⢀⠀⠀⠑⢀⠀⠑⠐⠁⠀⠀⠁⢐⠄⠀⢀⠐⠄⠐⢀⠁⠑⢀⠀⠀⠐⠀⢑⠄⠀⠁⠀⠅⠐⠄⠀⠀⠄⠀⠄⠁⠀⠄⢁⢀⠁⠁⠄⠀⠀⠀⠀⢄ ⠑⠀⠀⠀⢀⠀⠁⠄⠐⠀⠀⠄⢄⠀⠐⠐⠀⠑⢁⠀⠔⠀⠀⠀⠀⠀⠕⢄⠀⠐⠀⢀⠔⠅⢀⠀⠐⠀⠅⢐⠀⠕⠐⢀⠀⠔⠀⠅⠀⠀⠀⠄⢀⠁⢀⠀⠀⠔⠀⠐⠁⢀⠀⠁⢀⠁⠀⠐⠐⠄⠐⠐⠄⠀⠀⠀⠀⠀⠔⠐ ⠐⠀⢐⠀⠀⠀⢀⠀⠐⠐⠀⠀⠐⠀⠄⢀⠁⢄⠀⠑⢀⠀⠐⢀⢄⠀⠀⢀⠀⢅⢔⠁⠄⠐⠀⠁⠀⠑⠀⠀⠐⠁⠄⠀⢁⢀⠀⠁⠐⠁⠀⠀⠀⠀⠀⠀⠀⠀⠐⢀⠄⠀⢀⢔⠑⢅⠀⠐⢄⠁⢀⠄⢁⢀⠐⠀⠀⢀⢀⢑ ⠀⠄⠅⢀⠁⠀⠀⠅⠁⠀⢄⠀⠁⠐⠁⢀⠀⠀⠀⠀⠀⠑⠀⠄⢀⠀⠀⢀⠐⠀⠀⢀⠁⠐⢀⠄⠁⢔⠄⠀⠄⠄⠑⠄⠁⠀⠀⠁⠐⠐⠄⠁⢄⠀⢀⠄⠁⠀⠔⠁⢀⠐⠄⠀⠀⠀⢁⢐⠀⠀⠄⠀⠀⢀⠀⠅⠀⠀⠀⠀ ⠔⠀⠄⠀⢀⠄⠁⢀⠁⠄⠀⠀⠑⠀⠐⠁⠀⠐⠑⢀⠄⠄⠀⠀⢄⠀⠔⠔⢀⠀⠁⠀⠔⠀⢀⠄⠀⠀⠁⢐⠀⠑⠀⠀⠀⢅⠀⠀⢀⠀⠁⠄⠀⠁⢀⠀⠔⠐⠀⠀⢅⠀⠐⢀⠀⠀⠄⢀⠐⠔⠀⠁⠄⠀⠁⠀⠔⠐⠀⠀ ⠀⠐⢀⠐⠀⠁⢀⠀⠀⠐⠐⢀⢄⠐⢄⠐⠀⠅⠀⠁⠁⠄⠐⢁⠄⠀⠀⢄⠀⠅⠔⠀⢁⠀⠐⠄⢀⠀⠁⠀⠐⠀⢀⠑⢀⠄⠀⠅⠀⠀⠅⠀⠀⢀⢔⠐⠄⠀⠁⠀⠐⠀⠀⢀⠑⠀⠄⠐⢁⢀⠀⢄⢄⠁⢀⠀⢐⠐⠁⠁ ⠁⠄⠄⠀⠀⠁⠀⢐⠀⠐⠀⠄⢑⠀⠀⠑⠄⠁⢁⢀⠀⢑⠔⠁⠀⠄⠄⠀⢀⠀⠑⠔⠁⢁⠀⠄⢁⠔⠀⢀⠔⠀⢐⠀⠀⠀⠄⠄⠀⠐⠁⢁⠔⠁⠐⠐⠁⢀⢀⠀⠁⠔⠀⠀⠀⠅⠁⠀⠄⠀⠔⠁⢑⠀⠀⠀⠀⠀⠐⠀ ⠁⠀⠅⠐⠀⠁⠀⠀⠐⠁⠀⠀⠕⠀⠀⠅⠀⠐⠀⠀⠕⠁⠀⠄⠅⠀⠀⠐⠀⠐⠅⠀⠀⠄⠀⠀⠀⠀⠀⠐⠀⠀⠀⠀⠁⠀⠀⠀⠄⠀⠐⠁⠀⠄⠁⠀⠁⠄⠀⠐⠄⠀⠅⠀⠀⠔⠁⠀⠀⠕⠀⠀⠀⠀⠀⠁⠀⠁⠀⠀
Python
<lang python># coding=UTF-8 from __future__ import print_function, division from math import sqrt
def cell(n, x, y, start=1):
d, y, x = 0, y - n//2, x - (n - 1)//2 l = 2*max(abs(x), abs(y)) d = (l*3 + x + y) if y > x else (l - x - y) return (l - 1)**2 + d + start - 1
def show_spiral(n, symbol='# ', start=1, space=None):
top = start + n*n + 1
is_prime = [False,False,True] + [True,False]*(top//2)
for x in range(3, 1 + int(sqrt(top))):
if not is_prime[x]: continue
for i in range(x*x, top, x*2):
is_prime[i] = False
cell_str = lambda x: f(x) if is_prime[x] else space f = lambda _: symbol # how to show prime cells
if space == None: space = ' '*len(symbol)
if not len(symbol): # print numbers instead
max_str = len(str(n*n + start - 1))
if space == None: space = '.'*max_str + ' '
f = lambda x: ('%' + str(max_str) + 'd ')%x
for y in range(n):
print(.join(cell_str(v) for v in [cell(n, x, y, start) for x in range(n)]))
print()
show_spiral(10, symbol=u'♞', space=u'♘') # black are the primes show_spiral(9, symbol=, space=' - ')
- for filling giant terminals
- show_spiral(1001, symbol='*', start=42)</lang>
- Output:
♘♘♘♞♘♘♘♘♘♘ ♘♘♘♘♞♘♞♘♘♘ ♘♞♘♘♘♘♘♞♘♞ ♞♘♞♘♘♘♞♘♘♘ ♘♘♘♞♘♞♘♞♘♘ ♘♘♞♘♘♞♞♘♞♘ ♘♞♘♞♘♘♘♘♘♘ ♞♘♘♘♞♘♘♘♘♘ ♘♞♘♘♘♞♘♘♘♞ ♞♘♘♘♘♘♞♘♘♘ - - - - 61 - 59 - - - 37 - - - - - 31 - 67 - 17 - - - 13 - - - - - 5 - 3 - 29 - - - 19 - - 2 11 - 53 - 41 - 7 - - - - - 71 - - - 23 - - - - - 43 - - - 47 - - - 73 - - - - - 79 - -
REXX
Programming note for the showing of the spiral: because images can't be uploaded at this time on Rosetta Code, the glyphs for primes was chosen to be a solid glyph (or in ASCII or XML terminology, a "block").
This then allows the REXX program to compress two rows of the Ulam spiral into one by processing two rows at a time by comparing each character to the character on the next line (when comparing two lines as a pair):
- if a char on row k is a block, and the char on row k+1 is a block, then a "block" is used.
- if a char on row k is a block, and the char on row k+1 is a blank, then a "uhblk" is used.
- if a char on row k is a blank, and the char on row k+1 is a block, then a "lhblk" is used.
- if a char on row k is a blank, and the char on row k+1 is a blank, then a blank is used.
For codepage 437:
- a "block" is 'db'x █
- a "uhblk" is 'df'x ▄
- a "lhblk" is 'dc'x ▀
Or, to show all three characters in the (above) ordered next to each other (separated by a blank): █ ▄ ▀
This allows the displaying of the Ulam prime spiral to keep a (mostly) square aspect ratio.
The characters chosen allow for the HTML on Rosetta Code to shrink (via STYLE font-size) to shrink the displayed output.
counter-clockwise
<lang rexx>/*REXX pgm shows cntr-clockwise Ulam spiral of primes in a square matrix*/ parse arg size init char . /*get the matrix size from the CL*/ if size== | size==',' then size=79 /*No size? Then use default of 79*/ if init== | init==',' then init= 1 /*No init? Then use default of 1 */ if char== then char='█' /*No char? Then use default of █ */ tot=size**2; offset=init-1 /*numbers in spiral; start offset*/ uR.=0; bR.=0 /*the upper/bottom right corners.*/
do od=1 by 2 to tot; _=od**2+1+offset; uR._=1; _=_ + od; bR._=1; end
bL.=0; uL.=0 /*the bottom/upper left corners. */
do ev=2 by 2 to tot; _=ev**2+1+offset; bL._=1; _=_ + ev; uL._=1; end
$.= bigP=0; #p=0; app=1; inc=0; r=1; $=0; minR=1; maxR=1; $=0; !.= /*──────────────────────────────────────────────construct the spiral #s.*/
do i=init for tot; r=r+inc; minR=min(minR,r); maxR=max(maxR,r)
x=isPrime(i); if x then bigP=max(bigP,i); #p=#p+x /*bigP, #primes.*/
if app then $.r=$.r || x /*append token.*/
else $.r= x || $.r /*prepend token.*/
if uR.i then do; app=1; inc=+1; iterate; end /*advance ↓ */
if bL.i then do; app=0; inc=-1; iterate; end /* " ↑ */
if bR.i then do; app=0; inc= 0; iterate; end /* " ► */
if uL.i then do; app=1; inc= 0; iterate; end /* " ◄ */
end /*i*/
do j=minR to maxR by 2; jp=j+1; $=$+1 /*fold two lines*/
do k=1 for length($.j); top=substr($.j,k,1) /*the 1st line*/
bot=word(substr($.jp,k,1) 0,1) /*2nd line*/
if top then if bot then !.$=!.$'█' /*has top & bot.*/
else !.$=!.$'▀' /*has top,¬ bot.*/
else if bot then !.$=!.$'▄' /*¬ top, has bot*/
else !.$=!.$' ' /*¬ top, ¬ bot.*/
end /*k*/
end /*j*/ /* [↓] show prime# spiral matrix*/
do m=1 for $; say !.m; end /*m*/
say; say init 'is the starting point,' ,
tot 'numbers used,' #p "primes found, largest prime:" bigP
exit /*stick a fork in it, we're done.*/ /*───────────────────────────────────ISPRIME subroutine──────────────────────────────*/ isPrime: procedure; parse arg x; if x<2 then return 0 if wordpos(x,'2 3 5 7')\==0 then return 1 if x//2==0 then return 0; if x//3==0 then return 0
do j=5 by 6 until j*j>x; if x//j==0 then return 0; if x//(j+2)==0 then return 0; end
return 1</lang>
- Output:
when the default inputs are used
▀ ▀ ▀ ▄ ▀ ▄ ▄▀ ▄▀ ▀ ▀ ▄ ▄ ▀ ▄▀
▄▀ ▀▄ ▄ ▄ ▀ ▄▀ ▀ ▄▀ ▀ ▀ ▀ ▀ ▄ ▀ ▄
▀ ▀ ▄ ▀ ▄▀ ▄▀ ▄ ▀ ▄ ▄ ▄ ▀
▀▄ ▄▀ ▀ ▄ ▄▀ ▀▄▀ ▄ ▀ ▄ ▄ ▄ ▀ ▀
▀ ▄ ▄ ▀ ▄ ▄▀ ▀ ▄ ▀▄ ▄ ▀ ▀ ▄ ▄ ▀ ▄ ▄
▀ ▄ ▀ ▀ ▄▀▄ ▀ ▄ ▀ ▀ ▀ ▀ ▄ ▀ ▄ ▀▄
▀ ▀ ▀ ▄▀ ▄▀ ▄ ▄▀ ▄ ▄▀ ▄ ▀ ▄ ▄ ▄ ▄ ▀▄ ▄ ▀▄
▄ ▄ ▀▄ ▄ ▄ ▄ ▄ ▀▄ ▀ ▄▀ ▄ ▄ ▀ ▀ ▀▄ ▄
▀ ▄ ▀ ▀ ▀ ▀▄▀▄ ▀ ▄ ▀ ▀▄ ▀ ▀▄ ▀▄ ▄
▄ ▀ ▄ ▄ ▄ ▄▀ ▀ ▀▄ ▄▀ ▄▀ ▄ ▀ ▀ ▀▄▀ ▀ ▄ ▀ ▀▄
▄ ▄ ▄ ▄ ▄ ▀▄ ▄ ▀ ▄▀ ▀▄ ▄▀ ▀ ▄▀▄ ▄ ▄ ▄ ▀
▀▄▀ ▀ ▀ ▀▄▀▄ ▄ ▄ ▀▄ ▀▄ ▄▀ ▀
▄ ▄ ▄ ▄ ▄▀ ▄▀ ▀ ▀▄ ▄ ▄ ▀ ▀ ▀▄ ▀ ▀ ▀
▀▄ ▀ ▄ ▄▀▄ ▄▀▄ ▀ ▄ ▄ ▄▀ ▀ ▄ ▀ ▄ ▄▀ ▀
▀ ▀ ▄ ▀▄ ▀ ▀▄ ▄ ▄▀ ▄ ▀▄ ▀ ▀ ▀ ▄▀ ▄
▄ ▄ ▄ ▀▄▀▄ ▄ ▄▀ ▀ ▄ ▄▀ ▀ ▀ ▄▀▄▀ ▀▄ ▄ ▄ ▄ ▀
▀ ▀ ▀ ▀ ▀▄ ▄ ▄ ▄ ▀▄ ▄ ▀▄ ▄ ▄▀ ▄ ▄ ▄
▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀▄ ▄ ▄▀ ▀ ▀ ▀▄ ▀▄
▀▄ ▀▄ ▄ ▀▄ ▄ ▀ ▀▄ ▀▄ ▄ ▄ ▄▀▄ ▄▀▄▀▄ ▄▀ ▀ ▀ ▄ ▀ ▀ ▀ ▄ ▄ ▄▀ ▀
▄ ▄ ▄ ▄ ▄ ▄▀ █▄▀▄ ▄ ▄ ▄ ▄▀▄ ▄ ▀ ▄ ▄▀▄ ▄
▀ ▀ ▀ ▄ ▀ ▀ ▀ ▀▄▀ ▀▄
▄ ▄ ▄ ▄▀ ▀ ▄ ▀ ▄▀ ▀▄ ▀▄▀ ▀▄ ▀ ▀▄ ▄▀ ▄▀ ▀ ▀▄ ▀ ▀▄ ▄▀ ▄
▄▀▄ ▀▄ ▀ ▄ ▄ ▄ ▄ ▀ ▄ ▄ ▄▀ ▄ ▄ ▀ ▄ ▀▄ ▄
▀ ▀ ▀ ▀ ▀ ▀▄ ▀▄ ▀ ▄ ▄ ▄ ▀ ▀ ▀ ▀ ▀
▀ ▄ ▄ ▀▄ ▄ ▄ ▄ ▄ ▄ ▀ ▀ ▄▀▄ ▀▄ ▀ ▄ ▄▀ ▄▀▄▀ ▀▄ ▄▀ ▄
▄ ▄ ▄ ▄ ▄ ▄▀▄ ▀ ▄ ▄ ▀▄▀▄ ▄ ▄ ▄ ▄ ▄ ▄
▀ ▄ ▀ ▀ ▀ ▀ ▀▄ ▀ ▀ ▀▄ ▄ ▄ ▄▀ ▀▄ ▀▄ ▀ ▀
▄▀ ▄ ▀▄ ▄ ▄▀ ▀▄ ▀ ▀ ▄ ▀ ▀ ▀ ▄ ▀▄ ▀▄▀
▀ ▄▀▄ ▀ ▀ ▀ ▀ ▀▄ ▀▄ ▄ ▄▀ ▀ ▄
▀ ▄▀ ▀ ▀ ▄ ▀ ▀ ▀ ▀ ▄▀ ▄ ▄ ▄▀ ▀▄ ▀▄▀ ▀
▀ ▄ ▄ ▄▀ ▀▄ ▄ ▄▀▄ ▄ ▀ ▄ ▄ ▀ ▀ ▀ ▄
▄ ▄ ▀ ▄ ▀▄ ▄ ▄ ▄ ▄ ▄▀ ▀▄ ▄
▄▀ ▀ ▀ ▄ ▄ ▀ ▄ ▄ ▄▀ ▀▄ ▄ ▀ ▀ ▄
▀▄ ▄ ▄ ▀ ▄ ▄ ▄ ▄▀ ▀ ▄ ▀ ▀ ▀ ▀ ▀
▄ ▄▀▄ ▄ ▀ ▄ ▀▄ ▀▄▀ ▀ ▀▄ ▄ ▀▄ ▀
▀▄▀ ▀ ▀ ▀ ▀ ▄▀ ▀ ▀ ▀ ▄▀ ▄ ▄ ▄ ▀
▄ ▀ ▀ ▄ ▀ ▀ ▄▀▄ ▀▄ ▄▀ ▄▀ ▀ ▄ ▀
▄ ▀▄ ▄▀ ▄▀▄ ▀ ▀ ▀▄▀ ▄ ▀▄▀ ▄ ▀
▄ ▀▄ ▀▄ ▄ ▀ ▀ ▄ ▄ ▀ ▀ ▄ ▄ ▄ ▀▄
▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀
1 is the starting point, 6241 numbers used, 811 primes found, largest prime: 6229
- Output:
when the following input is used
▀▄ ▄▀ ▄ ▀ ▄ ▀▄▀ ▄ ▀ ▀ ▀ ▄ ▀ ▄ ▄▀
▀ ▀ ▀▄ ▄ ▀ ▄▀ ▀ ▀▄ ▄ ▄ ▀ ▄▀
▄▀▄ ▄▀ ▀▄▀ ▄ ▄ ▀▄ ▄ ▄ ▀ ▀ ▄ ▀ ▄▀ ▄▀ ▀▄▀
▀ ▀ ▀ ▀ ▄▀ ▄ ▄ ▀ ▄ ▀ ▄▀ ▄ ▄▀ ▀▄▀ ▄
▀ ▄ ▄ ▀▄ ▀ ▄ ▄ ▀ ▄ ▄ ▀ ▀▄ ▀ ▄ ▀ ▄ ▄▀ ▄▀
▄ ▄ ▄ ▄ ▄ ▀▄▀ ▀ ▀ ▄ ▀ ▀ ▄▀ ▀ ▀▄ ▀
▀ ▄ ▀ ▀ ▀ ▀▄ ▄ ▄▀ ▄ ▀ ▄ ▄ ▄▀ ▄▀ ▄▀▄
▄▀ ▄ ▀ ▄ ▄ ▀ ▄ ▀ ▄ ▄▀ ▄ ▀ ▀ ▀
▀ ▄▀▄ ▀▄ ▀ ▀ ▀ ▀▄▀▄ ▀▄▀ ▄
▀ ▄▀ ▀ ▀ ▄ ▀▄ ▄▀ ▀ ▄▀▄ ▀▄ ▄ ▄ ▄ ▄ ▄ ▄▀ ▄ ▄ ▀
▀ ▄ ▄ ▄▀ ▀ ▀ ▄ ▀ ▄ ▄ ▀ ▄▀ ▀▄ ▄▀
▄ ▄ ▀ ▀ ▄▀▄ ▀ ▄▀▄ ▀▄ ▄▀ ▄▀ ▄ ▄ ▄
▄▀ ▀ ▀ ▀ ▀ ▄▀▄ ▀ ▄ ▄ ▀ ▄▀▄ ▄ ▄ ▄
▀▄ ▄ ▄ ▀ ▄ ▄ ▀▄ ▄ ▄ ▄ ▀ ▄ ▀▄ ▄ ▄▀ ▀ ▀
▄ ▀ ▄▀▄ ▀▄▀ ▄ ▄ ▀ ▄▀ ▀ ▀ ▀ ▀ ▀▄▀ ▀ ▀▄ ▀
▀▄▀ ▀ ▀ ▀ ▄ ▄▀ ▀ ▄▀▄▀▄ ▄ ▄ ▄ ▄ ▄
▄ ▀ ▀ ▄ ▀ ▀▄ ▄▀ ▀ ▄▀ ▀▄ ▀▄ ▀ ▄ ▀
▄ ▀ ▄ ▄▀ ▀ ▀▄▀▄ ▄▀ ▄ ▀▄ ▄▀ ▀ ▀ ▄ ▀ ▀ ▄
▀ ▄ ▄▀ ▀ ▀ ▄ ▀ ▄ ▀▄▀ ▄ ▄ ▄ ▀ ▄ ▀
▀ ▄ ▄▀ ▀▄ ▀ ▄ ▀ ▄ ▄▀▄ ▄▀ ▀▄ ▄▀ ▀▄▀ ▀ ▀ ▀
▄ ▀▄ ▄ ▄ ▄ ▄ ▄ ▄▀ ▀ ▄▀▄▀ ▀ ▀▄▀ ▀ ▀▄ ▄▀
▀ ▄ ▀ ▄ ▄ ▀ ▀ ▀▄▀ ▀ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄
▄ ▄ ▄ ▀▄ ▄ ▄ ▀▄▀▄ ▄▀▄ ▀ ▀ ▀ ▀ ▄▀ ▀▄ ▀ ▀
▄▀ ▄ ▄▀ ▄▀ ▄ ▀ ▀ ▀ ▄ ▀ ▀▄ ▀
▀ ▀ ▀▄ ▀ ▄▀▄ ▄▀ ▀ ▄▀ ▄ ▄▀ ▄▀▄ ▄ ▄ ▄ ▀ ▄ ▄
▄ ▄▀ ▀ ▄ ▄ ▄ ▄ ▄▀ ▄▀▄ ▄ ▀▄ ▀▄ ▄ ▀ ▀▄
▄ ▀ ▀▄ ▄▀ ▄ ▄ ▀▄ ▀ ▀ ▄ ▀▄▀ ▄ ▄ ▀▄ ▄ ▀▄
▀ ▀ ▀▄▀ ▀▄▀ ▄▀ ▄▀ ▄▀ ▄▀ ▄ ▀ ▀▄ ▄
▄▀ ▀ ▀▄ ▄ ▄▀ ▀▄ ▀ ▄ ▀ ▄ ▀▄ ▄
▀▄ ▄ ▄ ▄ ▀ ▀ ▄ ▄ ▄ ▀ ▀▄ ▀ ▀ ▄▀ ▀ ▀▄▀ ▀ ▄ ▀ ▀▄
▄▀ ▀ ▄ ▄ ▀ ▄ ▀ ▀ ▀ ▀▄▀ ▄▀ ▄ ▄ ▄ ▀
▄ ▀▄ ▀▄ ▄▀ ▀▄ ▀ ▄▀ ▄ ▄ ▀ ▀ ▀ ▄ ▄ ▄▀ ▀
▄ ▄ ▄▀ ▀▄ ▄ ▀ ▄ ▀ ▀ ▄ ▄ ▀ ▄ ▀▄ ▀ ▀ ▀
▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀ ▄ ▄ ▄ ▄▀ ▀ ▄▀ ▀ ▄▀ ▀
▄ ▄▀ ▀ ▀▄ ▄ ▄ ▀ ▄ ▀▄ ▀ ▀ ▄ ▄
▄▀ ▄ ▄ ▄ ▀ ▄ ▄ ▄ ▄▀ ▄ ▀ ▀▄ ▄▀
▀ ▀▄▀ ▄▀ ▀ ▄ ▀ ▀ ▄▀ ▄▀▄▀ ▄▀ ▄ ▄ ▄
▀ ▄▀ ▄ ▀▄▀ ▄ ▀ ▄ ▀ ▀▄ ▄ ▀ ▀
▀ ▄ ▄ ▄ ▀▄ ▄ ▀ ▀ ▀ ▄▀ ▀ ▀ ▀
▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀
41 is the starting point, 6241 numbers used, 805 primes found, largest prime: 6277
- Output:
with an input of 414 can be viewed at
clockwise
This REXX version is presented here to show the difference between a clockwise and a counter-clockwise Ulam (prime) spiral. <lang rexx>/*REXX pgm shows a clockwise Ulam spiral of primes in a square matrix. */ parse arg size init char . /*get the matrix size from the CL*/ if size== | size==',' then size=79 /*No size? Then use default of 79*/ if init== | init==',' then init= 1 /*No init? Then use default of 1 */ if char== then char='█' /*No char? Then use default of █ */ tot=size**2; offset=init-1 /*numbers in spiral; start offset*/ uR.=0; bR.=0 /*the upper/bottom right corners.*/
do od=1 by 2 to tot; _=od**2+1+offset; uR._=1; _=_ + od; bR._=1; end
bL.=0; uL.=0 /*the bottom/upper left corners. */
do ev=2 by 2 to tot; _=ev**2+1+offset; bL._=1; _=_ + ev; uL._=1; end
$.= bigP=0; #p=0; app=1; inc=0; r=1; $=0; minR=1; maxR=1; $=0; !.= /*──────────────────────────────────────────────construct the spiral #s.*/
do i=init for tot; r=r+inc; minR=min(minR,r); maxR=max(maxR,r)
x=isPrime(i); if x then bigP=max(bigP,i); #p=#p+x /*bigP, #primes.*/
if app then $.r=$.r || x /*append token.*/
else $.r= x || $.r /*prepend token.*/
if uR.i then do; app=1; inc=+1; iterate; end /*advance ↓ */
if bL.i then do; app=0; inc=-1; iterate; end /* " ↑ */
if bR.i then do; app=0; inc= 0; iterate; end /* " ► */
if uL.i then do; app=1; inc= 0; iterate; end /* " ◄ */
end /*i*/
do j=minR to maxR by 2; jp=j+1; $=$+1 /*fold two lines*/
do k=1 for length($.j); top=substr($.j,k,1) /*the 1st line*/
bot=word(substr($.jp,k,1) 0,1) /*2nd line*/
if top then if bot then !.$=!.$'█' /*has top & bot.*/
else !.$=!.$'▀' /*has top,¬ bot.*/
else if bot then !.$=!.$'▄' /*¬ top, has bot*/
else !.$=!.$' ' /*¬ top, ¬ bot*/
end /*k*/
end /*j*/ /* [↓] show prime# spiral matrix*/
do m=1 for $; say !.m; end /*m*/
say; say init 'is the starting point,' ,
tot 'numbers used,' #p "primes found, largest prime:" bigP
exit /*stick a fork in it, we're done.*/ /*───────────────────────────────────ISPRIME subroutine──────────────────────────────*/ isPrime: procedure; parse arg x; if x<2 then return 0 if wordpos(x,'2 3 5 7')\==0 then return 1 if x//2==0 then return 0; if x//3==0 then return 0
do j=5 by 6 until j*j>x; if x//j==0 then return 0; if x//(j+2)==0 then return 0; end
return 1</lang>
- Output:
when using the default input
▀ ▄ ▄▀ ▄ ▄ ▄ ▄ ▀ ▀ ▀ ▄ ▀ ▄ ▀ ▀ ▀ ▄ ▄
▄ ▄▀ ▀ ▄▀ ▀▄ ▄ ▀ ▀▄ ▄ ▄ ▄ ▀
▄ ▀ ▄ ▀ ▀ ▀▄ ▄▀ ▄▀ ▀▄ ▀ ▀ ▄ ▄▀
▀▄▀ ▄▀ ▀ ▀ ▀ ▀▄ ▄ ▄▀▄▀ ▀
▀ ▀▄▀ ▀ ▀▄▀▄ ▀▄ ▀ ▀ ▄ ▀▄ ▀▄ ▄ ▄▀ ▄
▄ ▄ ▄ ▀▄ ▄ ▄▀ ▄ ▀ ▄▀ ▀ ▀ ▀ ▀ ▀
▀ ▄▀ ▄ ▄ ▀ ▀ ▄ ▄ ▀▄ ▄ ▄▀ ▀ ▀ ▀ ▄
▄ ▄ ▀ ▀ ▄▀ ▄ ▄ ▀▄ ▄ ▄ ▀▄▀ ▄ ▀ ▀ ▄
▄ ▄▀▄ ▄ ▄ ▀▄ ▄ ▄ ▄ ▄ ▀ ▀ ▄
▀▄ ▀▄ ▀ ▀▄ ▄▀ ▄ ▄ ▀ ▀▄ ▀▄
▀ ▀ ▀ ▀▄ ▄ ▀ ▀ ▀ ▀ ▀ ▀▄ ▄ ▄ ▀ ▄ ▀ ▀ ▄▀
▀▄ ▄ ▀ ▄▀ ▀ ▄ ▄ ▀ ▄ ▀ ▀ ▄▀ ▀▄ ▀▄ ▄
▀▄ ▄▀ ▀ ▄▀▄ ▄▀▄ ▀ ▄ ▀▄▀ ▀ ▀ ▀ ▀
▄▀▄ ▀▄▀ ▀ ▀▄▀ ▄▀ ▀▄ ▄ ▀▄ ▄ ▀▄ ▄ ▀ ▀▄ ▄ ▄ ▄▀▄ ▀ ▄
▄ ▄ ▄ ▄ ▄ ▄▀▄ ▄▀ ▄ ▄▀ ▀ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄
▀ ▀ ▄ ▄ ▀▄▀ ▄▀▄ ▀ ▀ ▀ ▀ ▀ ▀ ▀
▀▄▀▄▀ ▀ ▄ ▄▀▄▀ ▀ ▄▀▄ ▄ ▄▀ ▄ ▀ ▄ ▄▀ ▄ ▀ ▄▀ ▄
▀ ▄ ▄▀ ▄ ▀▄ ▄ ▄ ▄ ▄▀ ▄ ▄▀▄ ▄ ▀▄ ▄ ▀▄ ▄
▄ ▀ ▀ ▀ ▀ ▀ ▀▄▀ ▄▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀
▀ ▀▄▀▄ ▄ ▀ ▀▄ ▀ ▄▀ ▀▄▀ ▄▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄
▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄▀ ▀▄▀ ▄ ▀ ▄ ▄ ▀ ▄▀
▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀ ▄ ▄▀ ▀▄▀ ▀ ▀ ▀ ▄ ▀ ▀▄
▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀▄ ▄ ▀▄ ▀▄▀ ▄ ▄ ▄▀▄ ▄ ▄ ▄ ▀ ▄
▄▀ ▄ ▄ ▄ ▄ ▄ ▄ ▀ ▄▀ ▀▄▀ ▄ ▄ ▄▀ ▄▀▄ ▀▄
▄ ▀▄▀ ▄▀ ▀▄ ▄ ▀ ▄▀ ▀ ▄▀ ▀ ▀ ▄ ▀ ▄
▀ ▀▄ ▄ ▀ ▄▀▄▀ ▄ ▄ ▄▀▄ ▄ ▀▄ ▀ ▀ ▀▄ ▀ ▄
▄▀ ▀▄ ▄▀▄ ▀ ▀ ▄ ▄▀ ▀ ▄▀ ▄ ▄ ▄ ▀ ▀
▄ ▄ ▄ ▄ ▀▄ ▀ ▀ ▀ ▄ ▄ ▀ ▀ ▀ ▄▀ ▀ ▀
▀ ▀▄ ▄ ▀▄ ▄ ▀▄ ▀▄▀▄ ▄ ▄ ▄ ▀ ▀ ▄ ▄ ▄ ▄▀▄ ▀
▄ ▄ ▄ ▄ ▄ ▀ ▀ ▀▄▀ ▄▀ ▄ ▄ ▀ ▀ ▄ ▄ ▄▀
▄ ▀ ▄ ▄▀ ▀ ▀ ▄▀ ▄ ▀ ▄ ▀ ▀ ▀ ▀ ▀▄ ▀▄▀
▀▄ ▄ ▀▄▀ ▄▀ ▀ ▀▄ ▄ ▄▀ ▄ ▀ ▀▄ ▀▄▀▄ ▀ ▄ ▄
▀ ▄ ▄ ▄ ▄ ▄ ▀ ▄▀ ▄▀ ▄▀ ▄ ▄ ▀▄ ▄▀▄ ▄
▀ ▀ ▄▀ ▀ ▀▄ ▄ ▀ ▄ ▀ ▀ ▄ ▄ ▄▀ ▀
▄▀ ▀ ▀▄ ▄▀▄ ▀ ▄ ▀ ▀ ▄▀▄ ▀ ▀▄ ▀▄ ▄ ▄
▄▀▄ ▄ ▄ ▀ ▄ ▀▄▀ ▄ ▀ ▄ ▄▀ ▀ ▀
▀ ▀ ▀ ▄ ▀ ▀ ▀▄ ▄ ▀ ▄ ▄ ▄ ▀ ▄ ▀
▀▄▀ ▄ ▀▄ ▄ ▀ ▀▄ ▄ ▀ ▄ ▀▄
▀ ▀ ▄▀ ▄▀▄▀ ▄▀ ▀ ▀▄▀ ▀▄ ▀ ▄
▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀
1 is the starting point, 6241 numbers used, 811 primes found, largest prime: 6229
zkl
Simulates turtle graphics, spiral by walking straight while holding left hand against the wall dropping prime breadcrumbs.
Using Extensible prime generator#zkl. <lang zkl>var primes=Utils.Generator(Import("sieve.zkl").postponed_sieve); var offsets=Utils.Helpers.cycle( T(0,1),T(-1,0),T(0,-1),T(1,0) ); const BLACK=0, WHITE=0xffffff, GREEN=0x00ff00, RED=0xff0000, EMPTY=0x0808080; fcn uspiral(N,n=1){
if((M:=N).isEven) M+=1; // need odd width, height
img:=PPM(M,M,EMPTY);
// collect all primes<=N*N+n
ps:=primes.filter('wrap(p){ p<=N*N+n and True or Void.Stop });
x:=N/2; y:=x; img[x,y]=GREEN; n+=1; x+=1;
while(True){
ox,oy:=offsets.next(); leftx,lefty:=offsets.peek();
while(True){
img[x,y]=( if(ps.holds(n)) WHITE else BLACK ); if(n==N*N) break(2); // all done n+=1; if(img[x+leftx,y+lefty]==EMPTY) // nothing to my left, turn left
{ x+=leftx; y+=lefty; break; }
x+=ox; y+=oy;
} } img
} uspiral(501).write(File("foo.ppm","wb"));</lang>
- Output:
A PPM image similar to that shown in Perl6 but denser. A green dot marks the center.