Ulam spiral (for primes): Difference between revisions

 

 

 

 

 

 

Sometimes, the starting number can be specified to show more visual striking patterns (of prime densities).

 

 

 

|-

| <big><big>'''65'''</big></big> || <big><big>'''64'''</big></big> || <big><big>'''63'''</big></big> || <big><big>'''62'''</big></big> || <big><big>'''61'''</big></big> || <big><big>'''60'''</big></big> || <big><big>'''59'''</big></big> || <big><big>'''58'''</big></big> || <big><big>'''57'''</big></big>

|}

 

|-

| <big><big>''' '''</big></big> || <big><big>''' '''</big></big> || <big><big>''' '''</big></big> || <big><big>''' '''</big></big> || <big><big>'''61'''</big></big> || <big><big>''' '''</big></big> || <big><big>'''59'''</big></big> || <big><big>''' '''</big></big> || <big><big>''' '''</big></big>

|}

 

|-

|-

|-

|-

|-

|-

|-

|-

|-

|}

 

 

 

 

You should demonstrate the generator by showing at Ulam prime spiral large enough to (almost) fill your terminal screen.

 

 

<br><br>

 

=={{header|Ada}}==

The specification of package generic_ulam is as follows:

 

Size: Positive;

-- determines the size of the square

-- and New_Line N times

 

Here is the implementation:

subtype Index is Natural range 0 .. Size-1;

end Print_Spiral;

 

The folowing implementation prints a 29*29 spiral with the primes represented as numbers, and a 10*10 spiral with the primes as boxes. It uses the generic function Prime_Numbers.Is_Prime, as specified in [[Prime decomposition#Ada]].

 

 

procedure Ulam is

NL;

Visual.Print_Spiral;

 

{{out}}

<> <> <>

<> <> </pre>

 

=={{header|C}}==

#include <stdio.h>

#include <stdint.h>

int mx = abs(x), my = abs(y);

int l = 2 * max(mx, my);

 

return pow(l - 1, 2) + d;

return 0;

}

{{out}}

Run with a side-length of 29

 

The following shows a spiral that's not necessarily square, which has questionable merit:

#include <stdlib.h>

 

}

return 0;

 

=={{header|C++}}==

#include <iostream>

#include <string>

ulam.display( '#' );

return 0;

{{out}}

<pre>

# # # # #

# # # #

</pre>

 

=={{header|D}}==

{{trans|python}}

 

int cell(in int n, int x, int y, in int start=1) pure nothrow @safe @nogc {

void main() {

35.showSpiral;

{{out}}

<pre> # # # #

===Alternative Version===

This generates a PGM image, using the module from the Grayscale Image Task;

 

uint cell(in uint n, int x, int y, in uint start=1) pure nothrow @safe @nogc {

 

img.savePGM("ulam_spiral.pgm");

 

=={{header|EchoLisp}}==

The plot libray includes a '''plot-spiral''' function. The nice result is here : [http://www.echolalie.org/echolisp/help.html#plot-spiral EchoLisp Ulam spiral] .

(lib 'plot)

 

(define (ulam n nmax) (if ( prime? n) *red* (gray (// n nmax))))

(plot-spiral ulam 1000) ;; range [0...1000]

 

=={{header|Elixir}}==

{{trans|Ruby}}

defp cell(n, x, y, start) do

y = y - div(n, 2)

Ulam.show_spiral(9)

Ulam.show_spiral(25)

 

{{out}}

 

=={{header|ERRE}}==

 

!$INTEGER

!$DIM SPIRAL$[N,N]

GEN_ULAM(N,1)

{{out}}

<pre>

--- * --- --- --- * --- --- ---

* --- --- --- --- --- * --- ---

</pre>

 

{{works with|Fortran|95 and later}}

Only works with odd sized squares

implicit none

 

end if

end function

Output:

<pre> O O O O O O O

===But if you can use complex numbers...===

Notice that there each move comes in pairs, lengths 1,1, 2,2, 3,3, 4,4, ... with a quarter turn for each move. The order of the work area must be an odd number so that there is a definite middle element to start with and the worm fits between the bounds of the work area rather than striking one wall and leaving tiles unused.

SUBROUTINE ULAMSPIRAL(START,ORDER) !Idle scribbles can lead to new ideas.

Careful with phasing: each lunge's first number is the second placed along its direction.

INTEGER ORDER !MUST be an odd number, so there is a middle.

INTEGER L,M,N !Counters.

COMPLEX WAY,PLACE !Just so.

CHARACTER*1 SPLOT(0:1) !Tricks for output.

CALL ULAMSPIRAL(1,49)

END

 

 

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

"math"

"fmt"

)

 

 

const (

)

 

dir := RIGHT

y := n / 2

var x int

 

 

switch dir {

}

 

}

 

}

 

 

func main() {

 

=={{header|Haskell}}==

import Data.Numbers.Primes

 

 

 

 

 

 

 

 

 

 

=={{header|J}}==

Let's start with our implementation of [[Spiral_matrix#J|spiral]]:

 

 

We can get a spiral starting with 1 in the center of the square by subtracting these values from the square of our size argument:

 

0 1 2 3 4

15 16 17 18 5

11 2 1 6 19

12 3 4 5 18

 

Next, we want to determine which of these numbers are prime:

 

0 0 1 0 0

0 0 0 1 0

1 1 0 0 1

0 1 0 1 0

 

And, finally, we want to use these values to select from a pair of characters:

 

o

o

oo o

o o

 

If we want our spiral to start with some value other than 1, we'd add that value - 1 to our numbers right before the prime check. For this, we want a function which returns 0 when there's no left argument and one less than the left argument when it that value present. We can use : for this -- it takes two verbs, the left of which is used when no left argument is present and the right one is used when a left argument is present. (And note that in J, : is a token forming character, so we will need to leave a space to the left of : so that it does not form a different token):

 

0

3 (0: :(<:@[)) ''

 

We also want to specify that our initial computations only respect the right argument, and we should maybe add a space after every character to get more of a square aspect ratio in typical text displays:

 

 

And here it is in action:

 

o o

o o o

o o o o

o

 

To transform these spirals to the orientation which has recently been added as a part of the task, you could flip them horizontally (|."1) and vertically (|.)

=={{header|Java}}==

{{works with|Java|1.5+}}

 

public class Ulam{

}

}

{{out}}

<pre>[ --- --- --- --- 61 --- 59 --- ---]

[ --- * --- --- --- * --- --- ---]

[ * --- --- --- --- --- * --- ---]</pre>

 

=={{header|Kotlin}}==

{{trans|Java}}

require(n > 1)

var dir = Direction.RIGHT

var y = n / 2

var x = if (n % 2 == 0) y - 1 else y // shift left for even n's

 

when (dir) {

}

 

}

}

}

 

 

fun main(args: Array<String>) {

 

 

}

 

 

 

{{out}}

 

=={{header|Pascal}}==

 

In the first part of the source are some support routines, from way back in the 1980s, written when the mainframe terminals only offered capitals and the habit lingered. They are there only so as to facilitate some gestures towards checking. The remainder is simple enough, and uses complex numbers to follow the spiral, which of course have to be implemented via ad-hoc code as they're not supported by the compiler. The scheme could be recast into the (line,column) form, counting downwards for the screen line, but array(i,j) = (x,y) means less standing upside down when devising the arithmetic for the directions, at the cost of a "downto" loop for output. An even more tricky scheme would be to ascertain N from (line,column) as the lines were written rather than compute the whole spiral first. Such a function exists.

Program Ulam; Uses crt;

{Concocted by R.N.McLean (whom God preserve), ex Victoria university, NZ.}

Until (wot <= 0) or (wot > Mstyle); {Alas, "Enter" must be pressed.}

END.

 

 

 

 

 

 

}

 

 

{{out}}

</pre>

 

=={{header|PicoLisp}}==

 

(de ceil (A)

(ulam 9) )

 

{{out}}

<pre>

_ . _ _ _ . _ _ _

. _ _ _ _ _ . _ _

</pre>

 

=={{header|Python}}==

from __future__ import print_function, division

from math import sqrt

show_spiral(9, symbol='', space=' - ')

# for filling giant terminals

{{out}}

<pre>

- 43 - - - 47 - - -

73 - - - - - 79 - -

</pre>

 

{{trans|Python}}

 

(require (only-in math/number-theory prime?))

(define ((cell-fn n (start 1)) x y)

(let* ((y (- y (quotient n 2)))

(x (- x (quotient (sub1 n) 2)))

(l (* 2 (if (> (abs x) (abs y)) (abs x) (abs y))))

(+ (sqr (- l 1)) d start -1)))

(define (show-spiral n

#:symbol (smb "# ")

#:start (start 1)

#:space (space (and smb (make-string (string-length smb) #\space))))

(define cell (cell-fn n start))

(define print-cell

(display (if p? (~a #:width max-len i #:align 'right) space))

(display #\space)))))

(define c (cell x y))

(define p? (prime? c))

(print-cell c p?))

(newline))

(show-spiral 9 #:symbol #f)

(show-spiral 10 #:symbol "♞" #:space "♘") ; black are the primes

(show-spiral 50 #:symbol "*" #:start 42)

; for filling giant terminals

 

{{out}}

♘♘♘♞♘♘♘♘♘♘