Zig-zag matrix: Difference between revisions

;Related tasks:

*   [[Spiral matrix]]

 

 

*   Wiktionary entry:   [https://en.wiktionary.org/wiki/antidiagonal anti-diagonals]

<br><br>

 

=={{header|360 Assembly}}==

ZIGZAGMA CSECT

USING ZIGZAGMA,R12 set base register

T DS (N*N)H t(n,n) matrix

YREGS

{{out}}

<pre>

9 11 17 20 22

10 18 19 23 24

</pre>

 

=={{header|ActionScript}}==

package

{

}

}

 

=={{header|Ada}}==

 

procedure Test_Zig_Zag is

begin

Put (Zig_Zag (5));

The function Zig_Zag generates a square matrix filled as requested by the task.

 

=={{header|Agena}}==

Tested with Agena 2.9.5 Win32

 

makeZigZag := proc( n :: number ) :: table is

print()

od

{{out}}

<pre>

 

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386}}

PROC move = (REF INT i, j)VOID: (

IF j < n THEN

[,]INT result = zig zag(dim);

FOR i TO dim DO

OD

{{out}}

(( 0, 1, 5, 6, 14),

( 2, 4, 7, 13, 15),

( 10, 18, 19, 23, 24))

</pre>

 

=={{header|ALGOL W}}==

Based on the Agena sample.

% z is returned holding a zig-zag matrix of order n, z must be at least n x n %

procedure makeZigZag ( integer value n

end

 

{{out}}

<pre>

 

{{trans|J}}

zzSq ← {zz,⍨⍵} ⍝ Square zigzag

zzSq 5

3 8 12 16 21

9 11 17 20 22

 

=={{header|AppleScript}}==

 

Here's a vector & matrix boundary detection approach to the Zig-zap matrix:

 

-- Create an empty matrix.

set end of i to return

end repeat

 

set m to {}

set i's contents to (i as string) & return

end repeat

0 1 5 6 14

2 4 7 13 15

9 11 17 20 22

10 18 19 23 24

 

 

===Recursive===

By functional composition:

on zigzagMatrix(n)

{}

end if

{{Out}}

<pre>{{0, 1, 5, 6, 14},

{9, 11, 17, 20, 22},

{10, 18, 19, 23, 24}}</pre>

 

=={{header|Applesoft BASIC}}==

110 S2 = S ^ 2 : REM SQUARED

120 H = S2 / 2 : REM HALFWAY

340 NEXT X

350 PRINT

 

=={{header|ATS}}==

(* ****** ****** *)

//

 

(* ****** ****** *)

 

=={{header|AutoHotkey}}==

{{trans|lisp}}

contributed by Laszlo on the ahk [http://www.autohotkey.com/forum/post-276307.html#276307 forum].

v := x := y := 1 ; initial values

Loop % n*n { ; for every array element

t .= "`n" ; row is complete

}

 

=={{header|AutoIt}}==

#include <Array.au3>

$Array = ZigZag(5)

Next

Return $av_array

 

=={{header|AWK}}==

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

BEGIN {

}

exit(0)

{{out}}

<pre>

 

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

DIM array%(Size%-1,Size%-1)

NEXT

PRINT

{{out}}

<pre>

10 18 19 23 24

</pre>

 

=={{header|Befunge}}==

The size, ''N'', is specified by the first value on the stack - 5 in the example below. The upper limit is constrained only by the range of the playfield cells used for variables, since we're using an algorithm that calculates the values on the fly rather than building them up in memory. On an 8 bit interpreter this means an upper limit of at least 127, but with an extended cell range the size of ''N'' can be almost unlimited.

 

v:++!\**2p01:+1g01:g02$$_>>#^4#00#+p#1:#+1#g0#0g#3<^/+ 55\_$:>55+/\|

 

{{out}}

9 11 17 20 22

10 18 19 23 24</pre>

 

=={{header|C}}==

#include <stdlib.h>

/* free(s) */

return 0;

{{out}}

<pre>% ./a.out 7

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

 

{

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

result[i, j] = start;

return result;

 

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

#include <memory> // for auto_ptr

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

{

printZigZagArray( getZigZagArray( 5 ) );

{{out}}

<pre>

 

=={{header|Ceylon}}==

value data = Array {

value zz = ZigZag(5);

zz.display();

 

=={{header|Clojure}}==

Purely functional approach.

(lazy-seq

(when-let [n (first sizes)]

( 9 11 18 23 27 32)

(10 19 22 28 31 33)

 

=={{header|CoffeeScript}}==

# Calculate a zig-zag pattern of numbers like so:

# 0 1 5

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

console.log zig_zag_matrix(n)

 

{{out}}

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

==={{trans|Java}} (but with zero-based indexes and combining the even and odd cases)===

(flet ((move (i j)

(if (< j (1- n))

(setf (values x y) (move x y))

(setf (values y x) (move y x)))

 

===An alternative approach===

; ZigZag

;

(format t "~3d" (nth j st))

(setf (nth j st) (+ (nth j st) (nth j dx)))))))

(ZigZag 5) Produces:

<pre>

=={{header|Crystal}}==

{{trans|Ruby}}

(seq=(0...n).to_a).product(seq)

.sort_by {|x,y| [x+y, (x+y).even? ? y : -y]}

end

{{out}}

<pre>

=={{header|D}}==

{{trans|Common Lisp}}

static void move(in int n, ref int i, ref int j)

pure nothrow @safe @nogc {

 

writefln("%(%(%2d %)\n%)", 5.zigZag);

{{out}}

<pre> 0 1 5 6 14

{{trans|Scala}}

Same output.

 

int[][] zigZag(in int n) pure nothrow {

void main() {

writefln("%(%(%2d %)\n%)", 5.zigZag);

 

=={{header|E}}==

 

Then the code. {{trans|D}}

def move(&i, &j) {

if (j < (n - 1)) {

}

return array

 

=={{header|Elena}}==

{{trans|C#}}

ELENA 5.0:

extension op : IntNumber

{

console.printLine(5.zigzagMatrix()).readChar()

 

=={{header|Elixir}}==

require Integer

def zigzag(n) do

end

 

 

{{out}}

9 11 17 20 22

10 18 19 23 24

</pre>

 

=={{header|Erlang}}==

-module( zigzag ).

 

next_indexes( {0, Y}, _Max ) when Y rem 2 =:= 1 -> {0, Y + 1};

next_indexes( {X, Y}, _Max ) when (X + Y) rem 2 =:= 0 -> {X + 1, Y - 1};

{{out}}

<pre>

 

=={{header|ERRE}}==

 

!$DYNAMIC

PRINT

END FOR

{{out}}

<pre> 0 1 5 6 14

=={{header|Euphoria}}==

{{trans|C#}}

sequence s

integer i, j, d, max

end function

 

{{out}}

{

 

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

//Produce a zig zag matrix - Nigel Galloway: April 7th., 2015

let zz l a =

| _ -> gng (n-1, i+1, g+1, 2)

gng (0, 0, 0, 2)

{{out}}

<pre>

[[0; 1; 5; 6; 14]

[10; 18; 19; 23; 24]]

</pre>

<pre>

[[0; 1; 5; 6; 14; 15; 27; 28]

</pre>

Let's try something a little less square man

<pre>

[[0; 1; 5; 6; 14; 15; 24; 25]

This version follows the algorithm laid out in the comments of the first JavaScript (ES5) functional example, though it is not exactly a straight translation.

{{works with|Factor|0.99 2019-03-17}}

sequences sequences.cords sequences.extras ;

IN: rosetta-code.zig-zag-matrix

: zig-zag-demo ( -- ) 5 zig-zag-matrix simple-table. ;

 

{{out}}

<pre>

The following example is an implementation of a J routine with an [http://rosettacode.org/wiki/Talk:Zig-zag_matrix#reading_the_J_examples excellent walkthrough on the talk page]. Luckily, we can mimic the "classification" step with the composition of 3 existing Factor words: <code>zip-index expand-keys-push-at values</code> and the <code>inverse-permutation</code> word is the same concept as J's grade, so this is fairly succinct.

{{works with|Factor|0.99 2020-01-23}}

math.combinatorics math.matrices prettyprint sequences ;

 

] [ group ] bi ;

 

{{out}}

<pre>

 

=={{header|Fan}}==

 

**

print(zag(8))

}

 

=={{header|Forth}}==

 

: south diag abs + cell+ ;

3 8 12 16 21

9 11 17 20 22

 

=={{header|Fortran}}==

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

IMPLICIT NONE

END DO

 

=={{header|FreeBASIC}}==

 

Dim As Integer n

Print

Print "Press any key to quit"

 

{{out}}

 

=={{header|GAP}}==

local a, i, j, k;

a := NullMat(n, n);

# [ 3, 8, 12, 16, 21 ],

# [ 9, 11, 17, 20, 22 ],

 

=={{header|Go}}==

{{trans|Groovy}} Edge direct algorithm

 

import (

}

}

{{out}}

<pre>

and calculates the transform onto the grid.

 

grid = new int[n][n]

i = 0

}

grid

 

{{out}}

Ported from the Java example

 

move = { i, j -> j < n - 1 ? [i <= 0 ? 0 : i-1, j+1] : [i+1, j] }

grid = new int[n][n]

}

grid

 

{{out}}

Ported from the Python example with some input from J

 

(0..<n*n).collect { [x:it%n,y:(int)(it/n)] }.sort { c->

[c.x+c.y, (((c.x+c.y)%2) ? c.y : -c.y)]

}.with { l -> l.inject(new int[n][n]) { a, c -> a[c.y][c.x] = l.indexOf(c); a } }

 

{{out}}

Computing the array:

 

import Text.Printf (printf)

import Data.List (sortBy)

zigZag upper = array b $ zip (sortBy compZig (range b)) [0 ..]

where

<tt>compZig</tt> compares coordinates using the order of a zigzag walk:

Displaying the array (not part of the task):

 

show2d a =

unlines

axis f = [f l .. f h]

 

 

 

Or, building a list of lists with mapAccumL:

import Data.List (mapAccumL)

import Data.Bool (bool)

putStrLn $

unlines $

{{Out}}

<pre> 0 1 5 6 14

This solution works for both Icon and Unicon.

 

n := integer(!args) | 5

every !(A := list(n)) := list(n)

then if x[2] = n then [x[1]+1, x[2]] else [max(1, x[1]-1), x[2]+1]

else if x[1] = n then [x[1], x[2]+1] else [x[1]+1, max(1, x[2]-1)]

 

{{out}}

 

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

110 LET SIZE=5

120 NUMERIC A(1 TO SIZE,1 TO SIZE)

350 NEXT

360 PRINT

 

=={{header|J}}==

 

A succinct way:

0 1 5 6 14

2 4 7 13 15

3 8 12 16 21

9 11 17 20 22

 

This version is longer, but more "mathematical" and less "procedural":

0 1 5 6 14

2 4 7 13 15

3 8 12 16 21

9 11 17 20 22

 

Leveraging a [[Talk:Zig Zag#reading_the_J_examples|useful relationship among the indices]]:

0 1 5 6 14

2 4 7 13 15

3 8 12 16 21

9 11 17 20 22

 

Furthermore, by simply ''removing'' the trailing <tt>@,~</tt>

from the solutions, they automatically generalize

to rectangular (non-square) matrices:

0 1 5

2 4 6

3 7 11

8 10 12

 

=={{header|Java}}==

{{trans|Ada}}

{

int[][] data = new int[size][size];

}

return data;

 

=={{header|JavaScript}}==

 

Subclasses the Matrix class defined at [[Matrix Transpose#JavaScript]]

this.height = n;

this.width = n;

 

z = new ZigZagMatrix(4);

{{out}}

<pre>0,1,5,6,14

====ES5====

 

 

// Read range of values into a series of 'diagonal rows'

}));

 

 

{{Out}}

 

[2, 4, 7, 13, 15],

[3, 8, 12, 16, 21],

[9, 11, 17, 20, 22],

 

====ES6====

 

 

// diagonals :: n -> [[n]]

);

 

 

{{Out}}

[2, 4, 7, 13, 15],

[3, 8, 12, 16, 21],

[9, 11, 17, 20, 22],

 

=={{header|Joy}}==

(*

From the library.

concat [step '\n putch] cons step.

 

 

=={{header|jq}}==

Infrastructure:

def matrix(m; n; init):

if m == 0 then []

(""; . + reduce range(0;$length) as $j

(""; "\(.) \($in[$i][$j] | right )" ) + "\n" ) ;

Create a zigzag matrix by zigzagging:

 

# unless m == n*n, place m at (i,j), pointing

 

# Example

{{out}}

<pre>

</pre>

=== another solution ===

#

# solve zigzag matrix by constructing list of 2n+1 column "runs"

| shiftdown # shift right runs down

| shiftleft # shift rows left

{{out}}

<pre>

=={{header|Julia}}==

=== simple solution ===

matrix = zeros(Int, n, n)

x, y = 1, 1

end

return matrix

 

{{out}}

 

'''Zig-Zag Iterator'''

immutable ZigZag

m::Int

return (s, zzs)

end

 

'''Helper Functions'''

using Formatting

 

return s

end

 

'''Main'''

n = 5

println("The n = ", n, " zig-zag matrix:")

end

println(pretty(a))

 

{{out}}

 

=={{header|Klingphix}}==

 

 

 

 

{{out}}

<pre>0 1 5 6 14

 

End</pre>

 

=={{header|Kotlin}}==

 

typealias Vector = IntArray

printMatrix(zigzagMatrix(5))

printMatrix(zigzagMatrix(10))

 

{{out}}

54 55 71 72 84 85 93 94 98 99

</pre>

 

=={{header|Lasso}}==

 

var(

'square' = array

 

$square;

 

=={{header|Lua}}==

local zigzag = {}

 

 

print(zigzag.new(5))

 

=={{header|M4}}==

 

define(`set2d',`define(`$1[$2][$3]',`$4')')

 

zigzag(`a',5)

 

{{out}}

{{trans|Stata}}

 

uses ArrayTools;

u:=Replicate(<-1,1>,n):

v:=Reshape(<v+~1,v+~2>,2*n):

a:=Matrix(n,n):

local i,v,a;

a:=zigzag1(n);

for i from 2 to n do

a[n+2-i..n,i]-=v[1..i-1]

od;

a

 

 

{{out}}

 

<pre>Matrix(6, 6, [[ 1, 2, 6, 7, 15, 16],

 

 

{{out}}

 

<pre>Matrix(6, 6, [[ 1, 2, 6, 7, 15, 16],

 

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

using a direct formula.

The lower-right half is then 'mirrored' from the upper-left half.

empty=ReplacePart[empty,{i_,j_}:>1/2 (i+j)^2-(i+j)/2-i (1-Mod[i+j,2])-j Mod[i+j,2]];

ReplacePart[empty,{i_,j_}/;i+j>size+1:> size^2-tmp[[size-i+1,size-j+1]]-1]

Ported from the java-example:

data = ConstantArray[0, {size, size}];

i = j = 1;

];

data

Examples:

gives back:

 

But! It is pretty fast for n < 10000.

 

 

%This is very unintiutive. This algorithm parameterizes the

 

{{out}}

 

=={{header|Maxima}}==

a: zeromatrix(n, n),

i: 1,

[ 3, 8, 12, 16, 21],

[ 9, 11, 17, 20, 22],

 

=={{header|MiniZinc}}==

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

int: Size;

constraint forall(n in {2*g+((Size) mod 2) | g in 1..(Size-1) div 2})(zigzag[Size,n]=zigzag[Size,n-1]+1 /\ forall(g in 1..Size-n)(zigzag[Size-g,n+g]=zigzag[Size-g+1,n+g-1]+1));

output [show2d(zigzag)];

{out}

<pre>

 

=={{header|Modula-3}}==

 

IMPORT IO, Fmt;

BEGIN

Print(Create(5));

{{out}}

<pre>

=={{header|NetRexx}}==

{{trans|REXX}}

options replace format comments java crossref savelog symbols binary

 

 

return

 

=={{header|Nim}}==

{{trans|Python}}

from strutils import align

from sequtils import newSeqWith

result.add "\n"

{{out}}

<pre> 0 1 5 6 14 15

===Direct coord to number===

This calculates the number for each coordinate directly. This allows to create very large zig-zag matrices. Generates the same output as above.

 

func sumTo(n: Natural): Natural = n * (n+1) div 2

stdout.write(coord2num(row, col, N).`$`.align(width))

stdout.write("\n")

 

=={{header|Objeck}}==

{{trans|Java}}

function : native : ZigZag(size : Int) ~ Int[,] {

data := Int->New[size, size];

return data;

}

 

=={{header|OCaml}}==

{{trans|Common Lisp}}

 

(* move takes references and modifies them directly *)

let move i j =

move y x

done;

 

=={{header|Octave}}==

{{trans|Stata}}

 

j = 1:n;

u = repmat([-1; 1], n, 1);

3 8 12 16 21

9 11 17 20 22

 

Alternate solution, filling pairs of diagonals.

 

a = zeros(n, n);

for k=1:n

3 8 12 16 21

9 11 17 20 22

 

==Inspired by Rascal==

#{

Produce a zigzag matrix. Nigel Galloway, January 26th., 2020.

11 19 20 24 25

#}

 

=={{header|ooRexx}}==

{{trans|Java}}

call printArray zigzag(3)

say

say line

end

{{out}}

<pre>

=={{header|Oz}}==

Implemented as a state machine:

%% state move success failure

States = unit(right: [ 1# 0 downLeft downInstead]

end

in

 

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

{{trans|C.23}}

my(M=matrix(n,n),i,j,d=-1,start,end=n^2-1);

while(ct--,

if(start>end,return(M))

)

 

=={{header|Pascal}}==

 

const

writeln;

end;

 

{{out}}

{{trans|Seed7}} <br>

 

Program zigzag;

{$APPTYPE CONSOLE}

 

end.

 

{{out}} Size 5

 

=={{header|Perl}}==

 

sub zig_zag {

my @zig_zag_matrix = zig_zag(5);

say join "\t", @{$_} foreach @zig_zag_matrix;

 

 

{{trans|Haskell}}

my ($w, $h, @r, $n) = @_;

 

}

 

 

=={{header|Phix}}==

{{Trans|C#}}

Alternative:

 

=={{header|Phixmonti}}==

0 Size repeat Size repeat

 

ENDFOR

nl

 

=={{header|PHP}}==

$matrix = array();

for ($i = 0; $i < $num; $i++){

}

return $matrix;

 

=={{header|PicoLisp}}==

a two-dimensional structure and is normally used

for simulations and board games.

 

(de zigzag (N)

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

(prinl) )

{{out}}

<pre> 1 2 6 7 15

 

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

/* in a zig-zag fashion. */

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

put skip edit (a(i,*)) (f(4));

end;

{{out}}

<pre> 0 1 5 6 14

=={{header|PlainTeX}}==

The code works with any etex engine.

\def\fornum#1=#2to#3(#4){%

\edef#1{\number\numexpr#2}\edef\fornumtemp{\noexpand\fornumi\expandafter\noexpand\csname fornum\string#1\endcsname

}

\zzmat{5}

 

pdf output:

and also draws lines to show the path.

 

%%BoundingBox: 0 0 300 200

/size 9 def % defines row * column (9*9 -> 81 numbers,

stroke showpage

} if

 

=={{header|PowerShell}}==

$zigzag=New-Object 'Object[,]' $n,$n

$nodd = $n -band 1

} )"

}

 

===An Alternate Display===

Display the zig-zag matrix using the <code>Format-Wide</code> cmdlet:

zigzag 5 | Format-Wide {"{0,2}" -f $_} -Column 5 -Force

{{Out}}

<pre>

 

=={{header|Prolog}}==

zig_zag(N, N).

 

print_val(V) :-

writef('%3r ', [V]).

{{out}}

<pre>?- zig_zag(5).

=={{header|PureBasic}}==

{{trans|AutoHotkey}} <br>

Protected i, v, x, y

Input()

CloseConsole()

{{out}}

<pre>Zig-zag matrix of size 5

by [http://paddy3118.blogspot.com/2008/08/zig-zag.html paddy3118].

{{Works with|Python|3}}

'''zigzag rows'''

def compare(xy):

 

 

{{out}}

<pre> 0 2 3 9 10 20

 

===Alternative version, {{trans|Common Lisp}}===

# pylint: disable=invalid-name

# pylint: disable=unused-argument

from pprint import pprint

pprint(mat)

{{out}}

 

[2, 4, 7, 13, 15],

[3, 8, 12, 16, 21],

[9, 11, 17, 20, 22],

 

===Alternative version, inspired by the Common Lisp Alternative Approach===

COLS = 9

def CX(x, ran):

print(repr(next(ran[y])).rjust(3), end = ' ')

print()

{{out}} COLS = 5 Produces:

<pre>

</pre>

=== Another alternative version ===

from __future__ import print_function

 

if __name__ == '__main__':

main(5)

<pre>

zigzag of 5:

9 11 17 20 22

10 18 19 23 24

</pre>

 

The code can probably be simplified somewhat.

 

(define odd? A -> (= 1 (MOD A 2)))

(define even? A -> (= 0 (MOD A 2)))

(range 0 N)))

(range 0 N)))

 

=={{header|R}}==

}

 

 

=={{header|Racket}}==

#lang racket

 

 

(zigzag 4)

{{out}}

'((0 2 3 9)

(1 4 8 10)

(5 7 11 14)

(6 12 13 15))

 

=={{header|Raku}}==

Using the same Turtle class as in the [[Spiral_matrix#Raku|Spiral matrix]] task:

 

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;

 

=={{header|Rascal}}==

the key way to understand a zig-zag matrix is to write down

an example with coordinates:

2 (1,0), 4 (1,1), 6 (1,2)

If you order these coordinates on the number, you create the order:

One can observe that this increases with the sum of the coordinates,

and secondly with the the first number of the coordinates.

The Rascal example uses this phenomenon:

import List;

import Set;

print("<myarray[<y,x>]>\t");}

println();}

{{out}}

{0} {1} {3} {6} {10}

{2} {4} {7} {11} {15}

{9} {13} {17} {20} {22}

{14} {18} {21} {23} {24}

 

=={{header|REXX}}==

This REXX version allows the optional specification of the &nbsp; '''start''' &nbsp; and &nbsp; '''increment''' &nbsp; values.

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

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

do c=2 for n-1; _= _ right(@.r.c, w) /*build a line for output of a row.*/

end /*c*/; say _ /* [↑] align the matrix elements. */

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

-1009 -1010 -1014 -1015

</pre>

 

=={{header|Ring}}==

# Project Zig-zag matrix

 

exec()

}

Output:

 

[http://kepkezelo.com/images/kk86ng7p4gcl7z3p7vo1.jpg Zig-Zag matrix]

 

=={{header|Ruby}}==

{{trans|Python}}

(seq=*0...n).product(seq)

.sort_by {|x,y| [x+y, (x+y).even? ? y : -y]}

end

 

{{out}}

<pre>

9 11 17 20 22

10 18 19 23 24

</pre>

 

Uses the array indices sort solution used by others here.

 

val l = for (i <- 0 until n*n) yield (i%n, i/n)

val lSorted = l.sortWith {

ar => ar.foreach(x => print("%3d".format(x)))

println

Output:

2 4 7 13 15

3 8 12 16 21

9 11 17 20 22

10 18 19 23 24

 

=={{header|Scilab}}==

{{trans|Octave}}

 

a = zeros(n, n)

for k=1:n

3. 8. 12. 16. 21.

9. 11. 17. 20. 22.

 

=={{header|Seed7}}==

 

const type: matrix is array array integer;

writeln;

end for;

 

{{out}}

=={{header|Sidef}}==

{{trans|Perl}}

 

var r = []

}

 

{{out}}

<pre>

 

=={{header|Standard ML}}==

print "\n");

fun zig lst M = List.app rowprint (lst M);

)));

 

0 1 5 6 14

2 4 7 13 15

The requested zig-zag matrix can be constructed as a correction of another zig-zag matrix, which is a square "view" of the infinite zig-zag matrix. Here is the latter:

 

j = 0::n-1

u = J(1, n, (-1, 1))

4 | 9 11 18 24 31 |

5 | 10 19 23 32 40 |

 

Now the corrected matrix, which solves the task:

 

a = zigzag1(n)

v = (1..n-1):^2

4 | 9 11 17 20 22 |

5 | 10 18 19 23 24 |

 

The correction is given by the difference:

 

[symmetric]

1 2 3 4 5

4 | 0 0 1 4 |

5 | 0 1 4 9 16 |

 

=={{header|Tcl}}==

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

set m [lrepeat $size [lrepeat $size .]]

set x 0; set dx -1

}

 

{{out}}

<pre> 0 1 5 6 14

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

{{trans|BBC BASIC}}

 

i = 1

Next

Print

{{out}}

<pre> 0 1 5 6 14

=={{header|Ursala}}==

adapted from the J solution

#import nat

 

test program (three examples):

 

{{out}}

<pre><

 

=={{header|VBA}}==

Public Sub zigzag(n)

Dim a() As Integer

Next

End Sub

 

{{out}}

=={{header|VBScript}}==

{{trans|BBC BASIC}}

 

Function ZigZag(n)

WScript.StdOut.WriteLine

Next

 

{{out}}

{{trans|Go}}

{{libheader|Wren-fmt}}

 

var zigzag = Fn.new { |n|

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

i = i + 1

 

{{out}}

 

=={{header|XPL0}}==

def N=6;

int A(N,N), X, Y, I, D;

CrLf(0);

];

 

{{out}}

 

=={{header|Yabasic}}==

DIM array(Size-1, Size-1)

 

NEXT col

PRINT

 

=={{header|zkl}}==

{{trans|Groovy}}

grid := (0).pump(n,List, (0).pump(n,List).copy).copy();

ri := Ref(0);

}

grid.pump(String,'wrap(r){("%3s"*n+"\n").fmt(r.xplode())});

{{trans|C}}

Using list comprehension (and side effects) for the double loop,

the resulting list is just thrown away,

which is easier than creating an enumerated list and sorting.

s := (0).pump(m*m,List).copy(); // copy to make writable

rn := Ref(0);

'{ s[ if(i.isOdd) j*(m-1)+i else (i-j)*m+j ] = rn.inc(); }]];

s.pump(String,T(Void.Read,m-1), ("%3s"*m+"\n").fmt);

To be pedantic, the same as above,

but using the output of the list comprehension:

rn := Ref(0);

[[(i,j); [0..m*2-1]; '{[(0).max(i-m+1) .. i.min(m-1)]};

.sort(fcn([(a,_)], [(b,_)]){ a<b }).apply("get",1)

.pump(String,T(Void.Read,m-1), ("%3s"*m+"\n").fmt);

{{out}} The results are the same:

<pre>