Spiral matrix: Difference between revisions

{{trans|Python}}

 

V m = [[0] * n] *n

V d = [(0, 1), (1, 0), (0, -1), (-1, 0)]

print()

 

 

{{out}}

For maximum compatibility, this program uses only the basic instruction set.

{{trans|BBC BASIC}}

USING SPIRALM,R13

SAVEAREA B STM-SAVEAREA(R15)

MATRIX DS H Matrix(n,n)

YREGS

{{out}}

<pre> 0 1 2 3 4

13 22 21 20 7

12 11 10 9 8</pre>

 

=={{header|Action!}}==

DEFINE MAX_MATRIX_SIZE="100"

 

Test(5)

Test(6)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Spiral_matrix.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

with Ada.Text_Io; use Ada.Text_Io;

with Ada.Integer_Text_Io; use Ada.Integer_Text_Io;

begin

Print(Spiral(5));

The following is a variant using a different algorithm (which can also be used recursively):

Result : Array_Type (1..N, 1..N);

Left : Positive := 1;

Result (Top, Left) := Index;

return Result;

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}

 

PROC spiral = (INT n)[,]INT: (

);

{{out}}

<pre>

 

{{Trans|JavaScript}} (ES6)

 

-- spiral :: Int -> [[Int]]

on unwords(xs)

intercalateS(space, xs)

{{Out}}

{| class="wikitable" style="text-align:center;width:12em;height:12em;table-layout:fixed;"

| 12 || 11 || 10 || 9 || 8

|}

 

=={{header|AutoHotkey}}==

{{trans|Python|}}

ahk forum: [http://www.autohotkey.com/forum/post-276718.html#276718 discussion]

 

Loop % n*n {

13 12 11 10 9

---------------------------

 

=={{header|AWK}}==

# syntax: GAWK -f SPIRAL_MATRIX.AWK [-v offset={0|1}] [size]

# converted from BBC BASIC

exit(0)

}

{{out}}

<pre>

 

=={{header|BBC BASIC}}==

@%=LENSTR$(N%*N%-1)+1

BotCol%=0 : TopCol%=N%-1

ENDCASE

NEXT

 

=={{header|C}}==

Note: program produces a matrix starting from 1 instead of 0, because task says "natural numbers".

#include <stdlib.h>

 

return 0;

 

Recursive method, width and height given on command line:

#include <stdlib.h>

 

}

return 0;

 

=={{header|C sharp|C#}}==

Solution based on the [[#J|J]] hints:

int[,] result = new int[n, n];

 

Console.WriteLine();

}

 

Translated proper C++ solution:

 

//generate spiral matrix for given N

}

}

 

====Spiral Matrix without using an Array====

 

using System;

using System.Collections.Generic;

}

}

{{Out}}

 

Enter order..

17 30 29 28 27 10

16 15 14 13 12 11

 

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

#include <memory> // for auto_ptr

#include <cmath> // for the ceil and log10 and floor functions

{

printSpiralArray( getSpiralArray( 5 ) );

 

C++ solution done properly:

#include <iostream>

using namespace std;

cout << endl;

}

 

=={{header|Clojure}}==

Based on the [[#J|J]] hints (almost as incomprehensible, maybe)

(let [cyc (cycle [1 n -1 (- n)])]

(->> (range (dec n) 0 -1)

true

(str " ~{~<~%~," (* n 3) ":;~2d ~>~}~%")

Recursive generation:

{{trans|Common Lisp}}

(defn spiral-matrix [m n & [start]]

(let [row (list (map #(+ start %) (range m)))]

 

(defn spiral [n m] (spiral-matrix n m 1))

 

=={{header|CoffeeScript}}==

# Let's say you want to arrange the first N-squared natural numbers

# in a spiral, where you fill in the numbers clockwise, starting from

console.log "\n----Spiral n=#{n}"

console.log spiral_matrix n

{{out}}

> coffee spiral.coffee

 

[ 19, 36, 35, 34, 33, 32, 11 ],

[ 18, 17, 16, 15, 14, 13, 12 ] ]

 

=={{header|Common Lisp}}==

{{trans|Python}}

(do ((N (* rows columns))

(spiral (make-array (list rows columns) :initial-element nil))

dy dx)

(setf x (+ x dx)

<pre>> (pprint (spiral 6 6))

 

(8 7 6))</pre>

Recursive generation:

(let ((row (list (loop for x from 0 to (1- m) collect (+ x start)))))

(if (= 1 n) row

;; test

(loop for row in (spiral 4 3) do

 

=={{header|D}}==

import std.stdio;

enum n = 5;

 

writefln("%(%(%2d %)\n%)", M);

{{out}}

<pre> 0 1 2 3 4

12 11 10 9 8</pre>

Using a generator for any rectangular array:

 

/// 2D spiral generator

foreach (r; spiralMatrix(9, 4))

writefln("%(%2d %)", r);

{{out}}

<pre> 0 1 2 3 4 5 6 7 8

 

=={{header|DCL}}==

$ max = p1 * p1

$

$ endif

$ endif

{{out}}

<pre>$ @spiral_matrix 3

 

...</pre>

 

=={{header|E}}==

 

{{E 2D utilities}}

def array := makeFlex2DArray(size, size)

var i := -1 # Counter of numbers to fill

return array

Example:

0 1 2 3 4

15 16 17 18 5

14 23 24 19 6

13 22 21 20 7

 

=={{header|Elixir}}==

{{trans|Ruby}}

def spiral_matrix(n) do

wide = length(to_char_list(n*n-1))

end

 

 

'''The other way'''

def spiral_matrix(n) do

wide = String.length(to_string(n*n-1))

end

 

 

'''Another way'''

def spiral_matrix(n) do

fmt = String.duplicate("~#{length(to_char_list(n*n-1))}w ", n) <> "~n"

end

 

 

{{out}}

 

=={{header|Euphoria}}==

integer side, curr, curr2

sequence s

end function

 

 

{{out}}

=={{header|F_Sharp|F#}}==

No fancy schmancy elegance here, just putting the numbers in the right place (though I commend the elegance)...

let sq = Array2D.create n n 0 // Set up an output array

let nCur = ref -1 // Current value being inserted

[0..(n/2 - 1)] |> Seq.iter (fun i -> Frame i) // Fill in all frames

if n &&& 1 = 1 then sq.[n/2,n/2] <- n*n - 1 // If n is odd, fill in the last single value

 

=={{header|Factor}}==

This is an implementation of Joey Tuttle's method for computing a spiral directly as a list and then reshaping it into a matrix, as described in the [http://rosettacode.org/wiki/Spiral_matrix#J J entry]. To summarize, we construct a list with <code>n*n</code> elements by following some simple rules, then take its cumulative sum, and finally its inverse permutation (or grade in J parlance). This gives us a list which can be reshaped to the final matrix.

math.ranges math.statistics prettyprint sequences

sequences.repeating ;

: spiral-demo ( -- ) 5 9 [ spiral simple-table. nl ] bi@ ;

 

{{out}}

<pre>

=={{header|Fortran}}==

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

 

IMPLICIT NONE

END DO

 

 

=={{header|FreeBASIC}}==

 

Enum Direction

Print

Print "Press any key to quit"

 

{{out}}

 

=={{header|GAP}}==

SpiralMatrix := function(n)

local i, j, k, di, dj, p, vi, vj, imin, imax, jmin, jmax;

# [ 15, 24, 25, 20, 7 ],

# [ 14, 23, 22, 21, 8 ],

 

=={{header|Go}}==

 

import (

}

}

 

=={{header|Groovy}}==

Naive "path-walking" solution:

East([0,1]), South([1,0]), West([0,-1]), North([-1,0]);

private static _n

}

M

Test:

spiralMatrix(n).each { row ->

row.each { printf "%5d", it }

}

println ()

{{out}}

<pre style="height:30ex;overflow:scroll;"> 0

=={{header|Haskell}}==

Solution based on the [[#J|J]] hints:

import Control.Monad

grade xs = map snd. sort $ zip xs [0..]

spiral n = reshape n . grade. scanl1 (+). concat $ zipWith replicate (counts n) (values n)

displayRow = putStrLn . intercalate " " . map show

 

An alternative, point-free solution based on the same J source.

 

import Control.Applicative

counts = tail . reverse . concat . map (replicate 2) . enumFromTo 1

parts = (<*>) take $ (.) <$> (map . take) <*> (iterate . drop) <*> copies

disp = (>> return ()) . mapM (putStrLn . intercalate " " . map show) . parts

 

Another alternative:

import Text.Printf (printf)

 

 

-- this is sort of hideous, someone may want to fix it

 

 

Or less ambitiously,

{{Trans|AppleScript}}

 

---------------------- SPIRAL MATRIX ---------------------

. (<> "\n|}")

. intercalate "\n|-\n"

{{Out}}

{| class="wikitable" style="text-align: right;width:12em;height:12em;table-layout:fixed;"|-

=={{header|Icon}} and {{header|Unicon}}==

At first I looked at keeping the filling of the matrix on track using /M[r,c] which fails when out of bounds or if the cell is null, but then I noticed the progression of the row and column increments from corner to corner reminded me of sines and cosines. I'm not sure if the use of a trigonometric function counts as elegance, perversity, or both. The generator could be easily modified to start at an arbitrary corner. Or count down to produce and evolute.

N := 0 < integer(\A[1]|5) # N=1... (dfeault 5)

WriteMatrix(SpiralMatrix(N))

}

return M

 

{{out}}

 

=={{header|IS-BASIC}}==

110 TEXT 80

120 INPUT PROMPT "Enter size of matrix (max. 10): ":N

530 PRINT

540 NEXT

 

=={{header|J}}==

This function is the result of

some [http://www.jsoftware.com/papers/play132.htm beautiful insights]:

 

spiral 5

14 23 24 19 6

13 22 21 20 7

Would you like [[Talk:Spiral#J|some hints]] that will allow you to reimplement it in another language?

 

{{trans|C++}}

{{works with|Java|1.5+}}

 

public static void main(String[] args) {

}

}

{{out}}

<pre> 0 1 2 3 4

===Imperative===

 

var arr = Array(edge),

x = 0, y = edge,

arr = spiralArray(edge = 5);

for (y= 0; y < edge; y++) console.log(arr[y].join(" "));

{{out}}

<pre>

Translating one of the Haskell versions:

 

 

// Spiral: the first row plus a smaller spiral rotated 90 degrees clockwise

].join('\n\n');

 

 

Output:

|}

 

 

 

====ES6====

{{Trans|Haskell}}

 

 

// spiral :: Int -> [[Int]]

const spiral = n => {

const go = (rows, cols, start) =>

)

] : [

[]

];

return go(n, n, 0);

};

 

 

 

};

 

 

 

 

 

// pred :: Enum a => a -> a

const pred = x => x - 1;

 

// reverse :: [a] -> [a]

const reverse = xs =>

 

 

// transpose :: [[a]] -> [[a]]

 

// unlines :: [String] -> String

 

 

// MAIN ---

return main();

{{Out}}

 

=={{header|jq}}==

 

'''Infrastructure''':

def matrix(m; n; init):

if m == 0 then []

elif . == [0, 1] then [ 1, 0]

else error("invalid direction: \(.)")

'''Create a spiral n by n matrix'''

# we just placed m at i,j, and we are moving in the direction d

def _next(i; j; m; d):

 

# Example

{{Out}}

$ jq -n -r -f spiral.jq

 

'''Spiral Matrix Iterator'''

immutable Spiral

m::Int

return (s, sps)

end

 

'''Helper Functions'''

using Formatting

 

return s

end

 

'''Main'''

n = 5

println("The n = ", n, " spiral matrix:")

end

println(pretty(a))

 

{{out}}

=={{header|Kotlin}}==

{{trans|C#}}

 

typealias Vector = IntArray

printMatrix(spiralMatrix(5))

printMatrix(spiralMatrix(10))

 

{{out}}

=={{header|Liberty BASIC}}==

Extended to include automatic scaling of the display scale and font. See [http://www.diga.me.uk/spiralM5.gif spiralM5]

 

UpperLeftX = 50

[quit]

close #w

 

=={{header|Lua}}==

===Original===

function sindex(y, x) -- returns the value at (x, y) in a spiral that starts at 1 and goes outwards

if y == -x and y >= x then return (2*y+1)^2 end

end

 

 

===Alternate===

If only the printed output is required, without intermediate array storage, then:

local function z(x,y)

local m = math.min(x, y, n-1-x, n-1-y)

end

end

If the intermediate array storage ''is'' required, then:

local t, z = {}, function(x,y)

local m = math.min(x, y, n-1-x, n-1-y)

end

end

{{out}}

(same for both)

=={{header|Maple}}==

 

with(ArrayTools):

 

spiralArray(5);

 

{{out}}<pre>

[ 0 1 2 3 4]

=={{header|Mathematica}} / {{header|Wolfram Language}}==

We split the task up in 2 functions, one that adds a 'ring' around a present matrix. And a function that adds rings to a 'core':

size=Length[x];

smallest=x[[1,1]];

times=If[Mod[size,2]==0,size/2-1,(size-1)/2];

Nest[AddSquareRing,start,times]

Examples:

gives back:

<math>

<math>(-spiral(n))+n^2</math>

Then depending on if n is odd or even we use either an up/down or left/right mirror transformation.

matrix = (-spiral(n))+n^2;

end

Sample Usage:

 

ans =

14 23 24 19 6

13 22 21 20 7

 

=={{header|Maxima}}==

a: zeromatrix(n, n),

vi: [1, 0, -1, 0],

[15, 24, 25, 20, 7],

[14, 23, 22, 21, 8],

 

=={{header|MiniZinc}}==

%Spiral Matrix. Nigel Galloway, February 3rd., 2020

int: Size;

constraint forall(n in 1..Size div 2)(forall(g in n..Size-n)(spiral[Size-n+1,g]=spiral[Size-n+1,g+1]+1)) /\ forall(n in 1..Size div 2)(forall(g in n+1..Size-n)(spiral[g,n]=spiral[g+1,n]+1));

output [show2d(spiral)];

{{out}}

<pre>

=={{header|NetRexx}}==

{{Trans|ooRexx}}

options replace format comments java crossref symbols binary

 

return maxNum

 

 

{{out}}

 

=={{header|Nim}}==

 

proc `$`(m: seq[seq[int]]): string =

y += dy

 

{{out}}

<pre> 0 1 2 3 4

 

=={{header|OCaml}}==

| 1, 0 -> 0, -1

| 0, 1 -> 1, 0

print_newline())

 

 

Another implementation:

let ar = Array.make_matrix n n (-1) in

let out i = i < 0 || i >= n in

Array.iter (fun v -> Array.iter (Printf.printf " %2d") v; print_newline())

 

 

=={{header|Octave}}==

{{trans|Stata}}

a = ones(n*n, 1);

u = -(i = n) * (v = ones(n, 1));

14 23 24 19 6

13 22 21 20 7

 

=={{header|ooRexx}}==

call printArray generateArray(3)

say

say line

end

{{out}}

<pre>

=={{header|Oz}}==

Simple, recursive solution:

fun {Spiral N}

%% create nested array

end

in

 

=={{header|PARI/GP}}==

 

my (M = matrix(dim, dim), p = s = 1, q = i = 0);

for (n=1, dim,

);

M

 

Output:<pre>spiral(7)

 

=={{header|Pascal}}==

type

tDir = (left,down,right,up);

end;

END.

{{out}}

<pre> 1

 

=={{header|Perl}}==

{my ($n, $x, $y, $dx, $dy, @a) = (shift, 0, 0, 1, 0);

foreach (0 .. $n**2 - 1)

foreach (spiral 5)

{printf "%3d", $_ foreach @$_;

 

=={{header|Phix}}==

Simple is better.

{{out}}

<pre>

=={{header|PicoLisp}}==

This example uses 'grid' from "lib/simul.l", which maintains a two-dimensional structure and is normally used for simulations and board games.

 

(de spiral (N)

(for This L (prin (align 3 (: val))))

(prinl) )

{{out}}

<pre> 1 2 3 4 5

 

=={{header|PL/I}}==

/* where N is the length of one side of the square. */

/* Written 22 February 2010. */

end;

 

 

=={{header|PowerShell}}==

{

# Initialize variables

Spiral-Matrix 5

""

{{out}}

<pre>1 2 3 4 5

 

=={{header|Prolog}}==

% Prolog implementation: SWI-Prolog 7.2.3

 

Sq is N*N-1, numlist(0, Sq, Ns),

create(N, EMx), spiralH(right, EMx, (0,0), Ns, Mx).

{{out}}

<pre>

=={{header|PureBasic}}==

{{trans|Fortran}}

Protected i, x = -1, y, count = size, n

Dim a(size - 1,size - 1)

Input()

CloseConsole()

{{out}}

<pre>Spiral: 2

 

=={{header|Python}}==

dx,dy = 1,0 # Starting increments

x,y = 0,0 # Starting location

print

 

{{out}}

<pre>

 

===Recursive Solution===

def spiral_part(x, y, n):

if x == -1 and y == 0:

 

for row in spiral(5):

Adding a cache for the ''spiral_part'' function it could be quite efficient.

 

 

Recursion by rotating the solution for rest of the square except the first row,

return zip(*a[::-1])

 

 

for row in spiral(5):

 

 

Another way, based on preparing lists ahead

dat = [[None] * n for i in range(n)]

le = [[i + 1, i + 1] for i in reversed(range(n))]

 

for row in spiral(5): # calc spiral and print it

 

===Functional Solutions===

{{works with|Python|2.6, 3.0}}

 

concat = itertools.chain.from_iterable

 

for row in spiral(5):

 

 

{{Works with|Python|3.7}}

{{Trans|Haskell}}

 

 

if __name__ == '__main__':

main()

{| class="wikitable" style="width:12em;height:12em;table-layout:fixed;"|-

| 0 || 1 || 2 || 3 || 4

 

=== Simple solution ===

m = [[0] * n for i in range(n)]

dx, dy = [0, 1, 0, -1], [1, 0, -1, 0]

c += 1

return m

{{out}}

16 17 18 19 6

15 24 25 20 7

14 23 22 21 8

 

=={{header|Quackery}}==

This task really lends itself to a turtle graphics metaphor.

 

[ stack ] is position ( --> s )

[ stack ] is heading ( --> s )

[ witheach

[ dup 10 < if sp echo sp ]

 

{{out}}

=={{header|R}}==

===Sequence Solution===

 

 

===Recursive Solution===

spiralv <- function(v) {

n <- sqrt(length(v))

}

spiralv(1:(n^2))

 

===Iterative Solution===

Not the most elegant, but certainly distinct from the other R solutions. The key is the observation that we need to produce n elements from left to right, then n-1 elements down, then n-1 left, then n-2 right, then n-2 down, ... . This gives us two patterns. One in the direction that we need to write and another in the number of elements to write. After this, all that is left is battling R's indexing system.

{

spiral <- matrix(0, nrow = n, ncol = n)

}

spiral

 

=={{header|Racket}}==

#lang racket

(require math)

 

(vector->matrix 4 4 (spiral 4 4))

{{out}}

(mutable-array #[#[0 1 2 3] #[11 12 13 4] #[10 15 14 5] #[9 8 7 6]])

 

=={{header|Raku}}==

===Object-oriented Solution===

Suppose we set up a Turtle class like this:

my @dv = [0,-1], [1,-1], [1,0], [1,1], [0,1], [-1,1], [-1,0], [-1,-1];

my $points = 8; # 'compass' points of neighbors on grid: north=0, northeast=1, east=2, etc.

}

$t.showmap;

 

Or we can build the spiral from inside-out like this:

 

my $t = Turtle.new(dir => ($size %% 2 ?? 4 !! 0));

my $counter = $size * $size;

}

$t.showmap;

Note that with these "turtle graphics" we don't actually have to care about the coordinate system, since the <code>showmap</code> method can show whatever rectangle was modified by the turtle. So unlike the standard inside-out algorithm, we don't have to find the center of the matrix first.

 

===Procedural Solution===

my @sm;

my $len = $n;

}

 

{{out}}

<pre> 0 1 2 3 4

Original logic borrowed (mostly) from the [[#Fortran|Fortran]] example.

===static column width===

parse arg size start . /*obtain optional arguments from the CL*/

if size =='' | size =="," then size =5 /*Not specified? Then use the default.*/

end /*col*/ /* [↑] line has an extra leading blank*/

say _ /*display a line (row) of the spiral. */

{{out|output|text=&nbsp; using the default array size of: &nbsp; '''5'''}}

<pre>

===minimum column width===

This REXX version automatically adjusts the width of the spiral matrix columns to minimize the area of the matrix display (so more elements may be shown on a display screen).

parse arg size start . /*obtain optional arguments from the CL*/

if size =='' | size =="," then size =5 /*Not specified? Then use the default.*/

if two then say substr(_, 2) /*this SUBSTR ignores the first blank. */

end /*r*/

{{out|output|text=&nbsp; (shown at ³/₄ size) &nbsp; using an array size of: &nbsp; '''36'''

<b>

 

=={{header|Ring}}==

# Project : Spiral matrix

 

exec()

}

Output:

 

 

=={{header|Ruby}}==

{{trans|Python}}

spiral = Array.new(n) {Array.new(n, nil)} # n x n array of nils

runs = n.downto(0).each_cons(2).to_a.flatten # n==5; [5,4,4,3,3,2,2,1,1,0]

end

 

{{out}}

<pre>

The other way

{{trans|D}}

m = Array.new(n){Array.new(n)}

pos, side = -1, n

 

fmt = "%#{(n*n-1).to_s.size}d " * n

 

Output as above.

 

It processes the Array which is for work without creating it.

x, y, dx, dy = -1, 0, 0, -1

fmt = "%#{(n*n-1).to_s.size}d " * n

end

 

 

=={{header|Rust}}==

 

pub fn spiral_matrix(size: usize) -> Vec<Vec<u32>> {

println!();

}

{{out}}

<pre>

 

=={{header|Scala}}==

var dir = (1,0)

var pos = (-1,0)

folds.foreach {len => fold(seq.take(len),array); seq = seq.drop(len)}

array

Explanation: if you see the sequence of numbers to spiral around as a tape to fold around, you can see this pattern on the lenght of tape segment to fold in each step:

:<math>N,\ N-1,\ N-1,\ \ldots,\ 1,\ 1</math>

=={{header|Scilab}}==

{{trans|Octave}}

a = ones(n*n, 1)

v = ones(n, 1)

14. 23. 24. 19. 6.

13. 22. 21. 20. 7.

 

=={{header|Seed7}}==

 

const type: matrix is array array integer;

begin

writeMatrix(spiral(5));

{{out}}

<pre>

=={{header|Sidef}}==

{{trans|Perl}}

var (x, y, dx, dy, a) = (0, 0, 1, 0, [])

{ |i|

spiral(5).each { |row|

row.map {"%3d" % _}.join(' ').say

{{out}}

<pre>

 

=={{header|Stata}}==

a = J(n*n, 1, 1)

u = J(n, 1, -n)

4 | 13 22 21 20 7 |

5 | 12 11 10 9 8 |

 

=={{header|Tcl}}==

Using <code>print_matrix</code> from [[Matrix Transpose#Tcl]]

namespace path {::tcl::mathop}

proc spiral size {

}

 

<pre> 0 1 2 3 4

15 16 17 18 5

=={{header|TI-83 BASIC}}==

{{trans|BBC Basic}}

DelVar [F]

{N,N}→dim([F])

G→E

End

{{out}}

<pre>[[0 1 2 3 4]

 

=={{header|TSE SAL}}==

 

// library: math: create: array: spiral: inwards <description></description> <version control></version control> <version>1.0.0.0.15</version> (filenamemacro=creamasi.s) [<Program>] [<Research>] [kn, ri, mo, 31-12-2012 01:15:43]

END

 

 

=={{header|uBasic/4tH}}==

{{trans|C}}

This recursive version is quite compact.

Input "Height: ";h

Print

Else

Return (c@)

 

=={{header|Ursala}}==

Helpful hints from the [[#J|J]] example are gratefully acknowledged. The spiral function works for any n, and results are shown for n equal to 5, 6, and 7. The results are represented as lists of lists rather than arrays.

#import nat

#import int

#cast %nLLL

 

{{out}}

<pre>

=={{header|VBScript}}==

{{trans|BBC BASIC}}

Function build_spiral(n)

botcol = 0 : topcol = n - 1

 

build_spiral(CInt(WScript.Arguments(0)))

 

{{Out}}

{{trans|Java}}

This requires VB6.

 

Sub Main()

Debug.Print arr(row, UBound(arr, 2))

Next

 

==={{header|VBA}}===

{{trans|Java}}

{{works with|VBA/Excel}}

Dim n As Integer, a As Integer, b As Integer

Dim numCsquares As Integer, sideLen As Integer, currNum As Integer

Next b

Next a

 

====Solution 2====

Const FREE = -9 'negative number indicates unoccupied cell

Dim A() As Integer

Next

{{out}}

<pre>

'''Platform:''' [[.NET]]<br>

From VB6. This requires Visual Basic .Net.

Sub Main()

print2dArray(getSpiralArray(5))

 

End Module

 

=={{header|Wren}}==

{{trans|Go}}

{{libheader|Wren-fmt}}

 

var n = 5

if (i%n == n - 1) System.print()

i = i + 1

 

{{out}}

 

=={{header|XPL0}}==

int A(N,N);

int I, J, X, Y, Steps, Dir;

until Steps = 0;

Cursor(0,N);

 

{{out}}

13 22 21 20 7

12 11 10 9 8

</pre>

 

=={{header|zkl}}==

{{trans|C}} which turns out to be the same as Ruby

sm:=(0).pump(n,List,(0).pump(n,List,False).copy); //L(L(False,False..), L(F,F,..) ...)

drc:=Walker.cycle(T(0,1,0), T(1,0,1), T(0,-1,0), T(-1,0,1)); // deltas

}

sm

spiralMatrix(n).pump(Console.println,fcn(r){ r.apply("%4d".fmt).concat() });

println("---");

{{out}}

<pre>