Create a two-dimensional array at runtime: Difference between revisions

 

=={{header|11l}}==

V height = 5

V myarray = [[0] * width] * height

=={{header|68000 Assembly}}==

The routine used to retrieve the input is left unimplemented.

; Array setup

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

DBRA D7,loop_destroyArray ;loop using bottom 2 bytes of the array size as a loop counter

DBRA D6,loop_destroyArray ;decrement this, D7 is $FFFF each time execution gets here so this acts as a "carry" of sorts.

 

=={{header|Ada}}==

with Ada.Text_Io;

with Ada.Float_Text_Io;

end;

-- The variable Matrix is popped off the stack automatically

{{omit from|Modula-2}}

 

=={{header|ALGOL 60}}==

comment Create a two-dimensional array at runtime - Algol 60;

integer n,m;

end;

comment array a : out of scope;

{{in}}

<pre>

 

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

print("Input two positive whole numbers separated by space and press newline:");

[read int,read int] INT array;

array[1,1]:=42;

print (array[1,1])

 

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

integer dimension1UpperBound, dimension2UpperBound;

write( "upper bound for dimension 1: " );

end

 

 

=={{header|APL}}==

Arrays are an integral part of APL. Array size, shape, and data type can be easily manipulated at runtime.

 

 

array[1;1]←73 ⍝ assign a value to location 1;1.

 

⎕ex 'array' ⍝ erase the array

 

=={{header|AppleScript}}==

AppleScript has no array, but an AppleScript list can be used in a multidimensional fashion. There's no issue with their dimensions, they grow while adding elements. Memory allocation is dynamic.

 

set c to text returned of (display dialog "Enter number of columns:" default answer 2) as integer

set array to {}

-- Destroy array (typically unnecessary since it'll automatically be destroyed once script ends).

set array to {}

 

To correct the last comment in the script above: when a script's run, the values of its properties, globals, and run-handler (''ie.'' top level) variables are saved back to the script file when the execution finishes. So variables containing bulky values like lists ideally ''should'' be set to something smaller before the end in order to prevent file bloat. Or local variables could be used, which would be the better option above as the <code>return</code> statement prevents the last line from being executed anyway.

 

=={{header|Arturo}}==

 

height: to :integer input "give me the array's height: "

 

arr\[x]\[y]: 123

 

 

{{out}}

=={{header|AutoHotkey}}==

{{works with|AutoHotkey_L}}

InputBox, data,, Enter two integers separated by a Space:`n(ex. 5 7)

StringSplit, i, data, %A_Space%

Array[i1,i2] := "that element"

 

=={{header|AutoIt}}==

$sInput = InputBox('2D Array Creation', 'Input comma separated count of rows and columns, i.e. "5,3"')

$aDimension = StringSplit($sInput, ',', 2)

MsgBox(0, 'Output', 'row[' & UBound($a2D) -1 & '], col[' & UBound($a2D, 2) -1 & ']' & @CRLF & '= ' & $a2D[ UBound($a2D) -1 ][ UBound($a2D, 2) -1 ] )

 

 

=={{header|AWK}}==

AWK has no multidimensional array; but AWK arrays (which are [[Associative array]] indeed) can be used also in a multidimensional fashion. Since AWK arrays are associative arrays, there's no issue in their dimensions: they grow while adding new key-value pair.

 

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

for(j=0; j < $2; j++) {

print idx[1] "," idx[2] "->" arr[idx[1], idx[2]]

}

 

=={{header|BASIC}}==

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

20 DIM A%(X% - 1, Y% - 1)

30 X% = RND(1) * X%

50 A%(X%, Y%) = -32767

60 PRINT A%(X%, Y%)

 

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

DIM array(a%, b%)

array(1, 1) = PI

 

==={{header|Commodore BASIC}}===

Note: Size of array may be limited by RAM availability in some Commodore machines.

15 print "Size of array:"

20 print "Columns (1-20)";:input x%

70 print "Element";nx;",";ny;"= '";a$(nx,ny);"'"

80 clr:rem clear variables from ram

 

{{out}}

</pre>

==={{header|FreeBASIC}}===

 

Dim As Integer i, j

Print

Print "Press any key to quit"

 

{{out}}

 

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

110 NUMERIC ARRAY(1 TO A,1 TO B)

120 LET ARRAY(1,1)=PI

 

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

If you dimension arrays that are extra large to make sure you can hold data, but only have a small set of data, then all the space you reserved is wasted.

This hurts performance, because memory is set aside for the number of elements in the DIM statement.

input "Enter first array dimension "; a

input "Enter second array dimension "; b

 

end

 

==={{header|PureBasic}}===

 

Define x, y

 

PrintN("Press ENTER to exit"):Input()

End ; Close down and let PureBasic delete the Console and all variables.

 

==={{header|QuickBASIC}}===

{{works with|QuickBasic|4.5}}

INPUT a, b 'inputs need to be separated by commas

DIM array (1 TO a, 1 TO b)

array(1,1) = 42

PRINT array(1,1)

 

==={{header|Run BASIC}}===

print "Enter array 2 greater than 0"; : input a2

chrArray$(1,1) = "Hello"

numArray(1,1) = 987.2

 

==={{header|Sinclair ZX81 BASIC}}===

Arrays are indexed from 1; the only limit on their size (which may be an exigent limit) is the available memory. We create an array, write to a randomly selected element and then print it out, and finally use <code>CLEAR</code> to destroy the array (and all the other variables in the program).

20 INPUT D1

30 PRINT D1

120 PRINT "ITEM ";X;", ";Y;" = ";A(X,Y)

130 CLEAR

{{out}}

<pre>1ST DIMENSION: 11

 

==={{header|Sinclair ZX Spectrum BASIC}}===

20 DIM a(rows,columns): REM defines a numeric array

30 LET a=INT (RND*rows)+1: LET c=INT (RND*columns+1): REM the array is labelled a, but the letter a is still available for variable assignment

40 LET a(a,c)=1

50 PRINT a(a,c)

 

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

Input "COLS? ",C

{R,C}→dim([A])

42→[A](1,1)

Disp [A](1,1)

 

==={{header|Visual Basic .NET}}===

 

Sub Main()

Console.WriteLine("Enter two space-delimited integers:")

Console.WriteLine(arr(0, 0))

End Sub

 

{{out}}

5 42

2</pre>

 

=={{header|C}}==

=== C99 ===

{{works with|C99}}

 

int main(int argc, char **argv) {

 

return 0;

 

=== Traditional Style ===

Allocate multi-dimensional arrays with a single call to malloc. The demonstration code builds a rank 3 array.

/*

assume this file is c.c ,

return EXIT_SUCCESS;

}

 

 

This style is supported by all 'C' compilers.

#include <stdlib.h>

int main(int argc, char **argv)

free(a1);

return 0;

This style also supports more efficient memory utilization if you're only using a portion of the

array. If you only need the upper right half of a square array, you can do something like the following.

#include <stdlib.h>

int main(int argc, char **argv)

free(a1);

return 0;

 

This approach most closely matches the C99 example, as '''alloca''' allocates on the [[stack]], rather than the [[heap]], as '''malloc''' does.

 

#include <alloca.h>

int main(int argc, char **argv)

printf("array[%d][%d] is %d\n",user1/2,user2/2,array[user1/2][user2/2]);

return 0;

 

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

class Program

{

Console.ReadLine();

}

 

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

=== With language built-in facilities ===

 

 

int main()

 

return 0;

 

=== Using std::vector from the standard library ===

 

#include <vector>

 

// the array is automatically freed at the end of main()

return 0;

 

=== Using boost::multi_array ===

{{libheader|Boost}}

#include <boost/multi_array.hpp>

 

 

return 0;

 

=== Using boost::uBLAS ===

{{libheader|Boost|from 1.29}}

{{works with|Boost|1.54}}

#include <boost/numeric/ublas/matrix.hpp>

#include <boost/numeric/ublas/io.hpp>

 

return EXIT_FAILURE;

 

=={{header|Clean}}==

 

Start :: *World -> { {Real} }

(_, dim1, console) = freadi console

(_, dim2, console) = freadi console

 

=={{header|Clojure}}==

cols (Integer/parseInt (read-line))

a (to-array-2d (repeat rows (repeat cols nil)))]

(aset a 0 0 12)

 

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

(d2 (read)))

(assert (and (typep d1 '(integer 1))

(p2 (floor d2 2)))

(setf (aref array p1 p2) t)

 

The <tt>[http://www.lispworks.com/documentation/HyperSpec/Body/m_assert.htm assert]</tt> will allow the user to reenter the dimensions if they are not positive integers.

Arrays in Component Pascal are started from zero index. No DISPOSE-like procedures because of garbage collection.

 

MODULE TestArray;

(* Implemented in BlackBox Component Builder *)

END DoTwoDim;

 

 

=={{header|Crystal}}==

 

first = gets.not_nil!.to_i32

 

arr[first][second] = random.next_int

 

=={{header|D}}==

import std.stdio, std.conv, std.string;

int nRow, nCol;

array[0][0] = 3.5;

writeln("The number at place [0, 0] is ", array[0][0]);

{{out}}

<pre>Give me the numer of rows:

=={{header|Delphi}}==

Dimensions are generated randomly, not input by user.

 

{$APPTYPE CONSOLE}

 

Readln;

 

Test run:

Column 08 = 10 rows

Column 09 = 02 rows</pre>

 

=={{header|Elena}}==

 

Typified array

public program()

var m := new Integer();

console.loadLine(n,m);

console.printLine(myArray.at(0, 0))

Jagged array

import extensions;

auto m := new Integer();

console.loadLine(n,m);

myArray2[0][0] := 2;

myArray2[1][0] := "Hello";

console.printLine(myArray2[0][0]);

console.printLine(myArray2[1][0]);

 

=={{header|Elixir}}==

defmodule TwoDimArray do

 

 

IO.puts(TwoDimArray.get(arr,2,0))

 

=={{header|Erlang}}==

-module( two_dimensional_array ).

 

New_array = set( X - 1, Y - 1, X * Y, Array ),

io:fwrite( "In position ~p ~p we have ~p~n", [X - 1, Y - 1, get( X - 1, Y - 1, New_array)] ).

{{out}}

<pre>

=={{header|ERRE}}==

In ERRE language arrays created at run-time is "dynamic arrays". For this task will be enough this code:

PROGRAM DYNAMIC

 

PRINT("Value in row";2;"and col";3;"is";A%[2,3])

END PROGRAM

You can redimension A% using pragmas:

!$ERASE A% with a subsequent

 

=={{header|Euphoria}}==

 

sequence array

array[i][j] = height + width

 

 

=={{header|F Sharp|F#}}==

 

let width = int( Console.ReadLine() )

let arr = Array2D.create width height 0

arr.[0,0] <- 42

 

=={{header|Factor}}==

Factor doesn't provide any support for easy access of 2d arrays. But since factor's written in factor, we can just add it and it's just as good :)

sequences ;

IN: rosettacode.runtime2darray

[ [ 42 { 0 0 } ] dip set-Mi,j ] ! set the { 0 0 } element to 42

[ [ { 0 0 } ] dip Mi,j . ] ! read the { 0 0 } element

 

=={{header|Forth}}==

create ( width height "name" ) over , * cells allot

does> ( x y -- addr ) dup cell+ >r @ * + cells r> + ;

 

36 0 0 test !

 

{{libheader|Forth Scientific Library}}

& my-matrix{{ 8 9 }}malloc

 

my-matrix{{ 3 4 }} @ .

 

 

=={{header|Fortran}}==

In Fortran 90 and later

 

IMPLICIT NONE

DEALLOCATE (array, STAT=errcheck)

 

 

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Frink}}==

[rows, cols] = dims = eval[input["Enter dimensions: ", ["Rows", "Columns"]]]

a = new array[dims, 0] // Create and initialize to 0

a@(rows-1)@(cols-1) = 10

println[a@(rows-1)@(cols-1)]

 

=={{header|GAP}}==

a := NullMat(2, 2);

# [ [ 0, 0 ], [ 0, 0 ] ]

 

Determinant(a);

 

=={{header|Go}}==

Arrays in Go are only one dimensional. Code below show the obvious way of composing a 2d array as an array of arrays that can be indexed as a[r][c].

 

import "fmt"

a = nil

// memory allocated earlier with make can now be garbage collected.

The technique above alocates each row separately. This might be good if you need extremely large arrays that cannot be allocated in a single piece. It might be bad though, for locality, as there would be no guarantee that the separate allocations would be localized in memory. A technique that maintains locality is this,

a := make([][]int, row)

e := make([]int, row * col)

for i := range a {

a[i] = e[i*col:(i+1)*col]

Now all rows are allocated with a single allocation. Alternatively, slice e can be used directly without going through slice a. Element r c can be accessed simply as e[r*cols+c] for example, or accessor functions can be defined such as,

func get(r, c int) int {

return e[r*cols+c]

 

=={{header|Groovy}}==

Solution:

(0..<nrows).collect { [0]*ncols }

 

Test:

 

System.in.splitEachLine(/,\s*/) { dim ->

a2d.each { println it }

println()

 

Input:

=={{header|Haskell}}==

 

 

 

=={{header|HicEst}}==

 

DLG(NameEdit=rows, NameEdit=cols, Button='OK', TItle='Enter array dimensions')

ALLOCATE(array, cols, rows)

array(1,1) = 1.234

 

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

Multiply dimensioned arrays are arrays of arrays in both languages.

 

nr := integer(args[1]) | 3 # Default to 3x3

nc := integer(args[2]) | 3

A[x][y] := &pi

write("A[",x,"][",y,"] -> ",A[x][y])

 

Sample output:

The following is only for demonstration. No real program should just assume that the user input is valid, integer, large enough etc.

read, y, prompt='Enter y size:'

d = fltarr(x,y)

;==> outputs 5.6

 

 

=={{header|J}}==

The natural ways of creating a two dimensional array, from array dimensions, in J are <code>i.</code> and <code>$</code>

 

 

To update the upper left corner of the array with the value 99, you might use <code>}</code>

 

 

And, to retrieve that value you might use <code>{</code>

 

 

Finally, J manages storage for you, so to delete the array, you could either have the name refer to a new value

 

 

or you could remove the name itself:

 

 

Putting these ideas together and adding a few frills:

 

assert. y -: 0 0 + , y NB. error except when 2 dimensions are specified

INIT=. 0 NB. array will be populated with this value

ARRAY=. NEW INDEX} ARRAY NB. use our new value at that location

INDEX { ARRAY NB. and return the value from that location

Passing two integers to <tt>task</tt> (as a list) satisfies the specifications for a two-dimensional array, but providing a longer list of integers accomplishes the same task on an array of as many dimensions as the count of integers given.

 

Example use (result should always be 1 which is the value of <code>NEW</code>):

 

 

The type of the array is determined by the type of the values used in filling the array. E.g., alternate data types are obtained by substituting any of the following lines:

'init new' =. 1r2;2r3 NB. fractions

 

=={{header|Java}}==

 

 

public class twoDimArray {

System.out.println("The number at place [0 0] is " + array[0][0]);

}

 

=={{header|JavaScript}}==

var height = Number(prompt("Enter height: "));

 

 

//cleanup array

 

=={{header|jq}}==

 

Here's a simple example.

# filled with the input element

def matrix(m;n):

# Task: create a matrix with dimensions specified by the user

# and set the [1,2] element:

 

If the above is in a file, say 2d.jq, the invocation:

<tt>jq -n -c --arg m 2 --arg n 3 -f 2d.jq </tt>

 

 

=={{header|Julia}}==

Julia supports n-dimensional arrays as native data types: `Array{T, N}`, where `T` is the type of it´s elements and `N` is the number of dimensions.

 

print(prompt)

return readline()

x[3, 3] = 5.0 # overloads `setindex!` generic function

x::Matrix # `Matrix{T}` is an alias for `Array{T, 2}`

 

Manually calling the garbage collector may or may not actually collect the array, but it will be eventually.

=={{header|Kotlin}}==

Program arguments provide dimensions of the array (4 5 in the example).

// build

val dim = arrayOf(10, 15)

// print

array.forEach { println(it.asList()) }

{{out}}

<pre>[1, 2, 3, 4, 5]

=={{header|Logo}}==

{{works with|UCB Logo}}

mdsetitem [1 1] :a2 0 ; by default, arrays are indexed starting at 1

 

=={{header|Lua}}==

 

a, b = io.read() + 0, io.read() + 0

matrix[a][b] = 5

print(matrix[a][b])

 

=={{header|M2000 Interpreter}}==

Module CheckArray {

Do {

}

CheckArray

 

=={{header|Maple}}==

This hardly covers the richness and complexity of arrays in Maple, but here goes:

> a[1,1] := 1: # assign an element

> a[2,3] := 4: # assign an element

 

> a := 'a': # unassign the name

 

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

array[[1,1]]=RandomReal[];

array[[1,1]]

 

=={{header|MATLAB}} / {{header|Octave}}==

height = input('Array Height: ');

 

 

clear array; % de-allocate (remove) array from workspace

 

 

Sample Output:

Array Height: 12

 

=={{header|Maxima}}==

n: readonly("Input x-size: ")$

m: readonly("Input y-size: ")$

/* indexing starts from 0 */

print(a[0,0]);

 

=={{header|MAXScript}}==

b = getKBValue prompt:"Enter second dimension:"

arr1 = #()

)

arr1[a][b] = 1

 

=={{header|MUMPS}}==

This example uses a two level tree to mimic an 2D array.

ARA2D

NEW X,Y,A,I,J

KILL X,Y,A,I,J

QUIT

 

=={{header|NetRexx}}==

'''Note:''' No attempt is made to validate the input.

Any errors will be handled as exceptions by the underlying JVM.

options replace format comments java crossref symbols nobinary

 

say "arry["xPos","yPos"]:" arry[xPos, yPos]

return

'''Output:'''

<pre>

 

=={{header|Nim}}==

let

echo s[0][0]

 

 

=={{header|Objeck}}==

}

}

}

 

=={{header|Objective-C}}==

{{works with|GNUstep}}

{{works with|Cocoa}}

 

int main()

}

return 0;

 

=={{header|OCaml}}==

 

let nbr2 = read_int ();;

let array = Array.make_matrix nbr1 nbr2 0.0;;

array.(0).(0) <- 3.5;;

 

or using the module [http://caml.inria.fr/pub/docs/manual-ocaml/libref/Bigarray.html Bigarray]:

 

let nbr2 = read_int ();;

let arr = Bigarray.Array2.create Bigarray.float32 Bigarray.c_layout nbr1 nbr2 ;;

arr.{0,0} <- 3.5;;

 

=={{header|ooRexx}}==

ooRexx arrays can be created with up to 999,999,999 dimensions...assuming you have enough memory to do so.

Actually it's the 'size' of the array that's limited (the product of the dimensions).

pull d1

say "enter the second dimension"

say a[10,10]

max=1000000000

{{out}}

<pre>D:\>rexx 2d

=={{header|Oz}}==

Oz does not have multi-dimensional arrays. But we can create an array of arrays (similarly to most examples on this page):

%% Read width and height from stdin

class TextFile from Open.file Open.text end

%% set and read element

Arr.1.1 := 42

 

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

my(M=matrix(m,n,i,j,0));

M[1,1]=1;

M[1,1]

 

=={{header|Pascal}}==

The following code is standard Extended Pascal (tested with <tt>gpc --extended-pascal</tt>):

 

 

type

{ get rid of array }

dispose(data);

 

=={{header|Perl}}==

Predefining an array (or multi-dimension array) size is unnecessary, Perl dynamically resizes the array to meet the requirements. Of course I'm assuming that the user is entering array size 0 based.

 

# get array sizes from provided params, but force numeric value

my $x = ($_[0] =~ /^\d+$/) ? shift : 0;

print "\n";

}

 

The above is a bit verbose, here is a simpler implementation:

 

my ($x, $y) = @_;

map {[ (0) x $x ]} 1 .. $y

> 0 0 0

> 0 1 0

 

=={{header|Phix}}==

 

=={{header|Phixmonti}}==

 

"Enter height: " input tonum nl

-1 get -1 get "Value of the last element of the last dimension: " print print drop

drop /# remove array/list from the stack #/

With syntactic sugar

 

"Enter height: " input tonum nl

( -1 -1 ) mget "Value of the last element of the last dimension: " print print drop

drop /# remove array/list from the stack #/

With more syntactic sugar

 

"Enter height: " input tonum nl

( -1 -1 ) sget "Value of the last element of the last dimension: " print print

drop /# remove array/list from the stack #/

 

=={{header|PicoLisp}}==

(let A (make (do DX (link (need DY))))

(set (nth A 3 3) 999) # Set A[3][3] to 999

(get A 3 3) ) ) # Return A[3][3]

 

Output:

<pre>(NIL NIL NIL NIL NIL)

 

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

/* First way using a controlled variable: */

 

 

free A;

 

1.00000E+0000

 

/* Second way using a BEGIN block: */

 

 

/* The array is automatically destroyed when the block terminates. */

 

6.00000E+0000 7.00000E+0000 8.00000E+0000 9.00000E+0000 1.00000E+0001

1.10000E+0001 1.20000E+0002

 

/* Third way using a PROCEDURE block: */

 

 

/* The array is automatically destroyed when the procedure terminates. */

 

1.00000E+0000 2.00000E+0000 3.00000E+0000 4.00000E+0000 5.00000E+0000

6.00000E+0000 7.00000E+0000 8.00000E+0000 9.00000E+0000 1.00000E+0001

1.10000E+0001 1.20000E+0001 1.30000E+0001 1.40000E+0001 1.50000E+0001

1.60000E+0001 1.70000E+0001 1.80000E+0001 1.90000E+0001 2.00000E+0001

 

=={{header|Pop11}}==

incharitem(charin) -> itemrep;

;;; Read sizes

ar(0,0) =>

;;; Make sure array is unreferenced

 

Pop11 is garbage collected so there is no need to destroy array. However, the array is live as long as variable ar references it. The last assignment makes sure that we loose all our references to the array turning it into garbage.

 

=={{header|PowerShell}}==

function Read-ArrayIndex ([string]$Prompt = "Enter an integer greater than zero")

{

 

$array2d = New-Object -TypeName 'System.Object[,]' -ArgumentList $x, $y

{{Out}}

<pre>

</pre>

Populate the array:

[int]$k = 1

 

0..5 | ForEach-Object -Begin {$k += 10} -Process {$array2d[$i,$_] = $k + $_}

}

This is the entire array:

for ($i = 0; $i -lt 6; $i++)

{

"{0}`t{1}`t{2}`t{3}`t{4}`t{5}" -f (0..5 | ForEach-Object {$array2d[$i,$_]})

}

{{Out}}

<pre>

</pre>

Get an element of the array:

$array2d[2,2]

{{Out}}

<pre>

33

</pre>

 

=={{header|Python}}==

{{works with|Python| 2.5 and 3.6}}

 

height = int(raw_input("Height of Array: "))

myarray = [[0] * width for i in range(height)]

myarray[0][0] = 3.5

 

'''Note:''' Some people may instinctively try to write myarray as [[0] * width] * height, but the * operator creates ''n'' references to [[0] * width]

You can also use a two element tuple to index a dictionary like so:

 

# or, in pre 2.7 versions of Python: myarray = dict(((w,h), 0) for w in range(width) for h in range(height))

myarray[(0,0)] = 3.5

 

=={{header|Quackery}}==

 

 

[ dip dup

witheach [ peek dup ]

 

[ reverse

[ dup dip

[ rot dip

repack ] is {poke} ( x { p --> { )

 

say "Reading element {1,4} of array: "

 

{{out}}

=={{header|R}}==

{{trans|C}}

dims <- as.numeric(strsplit(input, " ")[[1]])

arr <- array(dim=dims)

jj <- ceiling(dims[2]/2)

arr[ii, jj] <- sum(dims)

 

=={{header|Racket}}==

Using a vector of vectors to represent arrays:

 

#lang racket

 

 

array

 

Output:

 

Line 4: Print each line of the array.

my @array = [ '@' xx $minor ] xx $major;

@array[ *.rand ][ *.rand ] = ' ';

 

Typical run:

[@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @]

[@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @]

[@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @]

[@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @]

 

The most recent versions of Rakudo have preliminary support for 'shaped arrays'. Natively shaped arrays are a flexible feature for declaring typed, potentially multi-dimensional arrays, potentially with pre-defined

dimensions. They will make memory-efficient matrix storage and matrix operations possible.

 

my Int @array[$major;$minor] = (7 xx $minor ) xx $major;

@array[$major div 2;$minor div 2] = 42;

 

Typical run:

 

=={{header|REXX}}==

call bloat /*the BLOAT procedure does all allocations.*/

/*no more array named @ at this point. */

╚════════════════════════════════════════════════════════════════════╝*/

drop @. /*because of the PROCEDURE statement, the*/

'''output''' when the following input is entered after the prompt message: &nbsp; <tt> 30 15 </tt>

<pre>

 

=={{header|Ring}}==

See 'Enter width : ' give width

See 'Enter height : ' give height

aList = list(height) for x in aList x = list(width) next

aList[1][2] = 10 See aList[1][2] + nl

 

=={{header|Ruby}}==

w=gets.to_i

arr = Array.new(gets.to_i){Array.new(w)}

arr[1][3] = 5

 

=={{header|Rust}}==

 

fn main() {

v[0][0] = 1;

println!("{}", v[0][0]);

 

=={{header|Scala}}==

def main(args: Array[String]): Unit = {

val x = Console.readInt

println("The number at (0, 0) is "+a(0)(0))

}

 

=={{header|Scheme}}==

There is no two-dimensional array-type built in to Scheme, but there is a vector.

 

(import (scheme base)

(scheme read)

(floor (/ y 2))))

(newline)

 

{{out}}

There are SRFI libraries providing arrays. This example uses SRFI 63.

 

(import (except (scheme base) equal?)

(scheme read)

;; Retrieve and display result

(display (array-ref array (floor (/ x 2)) (floor (/ y 2)))) (newline)

 

{{out}}

 

=={{header|Seed7}}==

 

const proc: main is func

anArray[1][1] := 3;

writeln("The number at place [1, 1] is " <& anArray[1][1]);

 

Output:

 

=={{header|Sidef}}==

y.of { x.of(0) };

}

var matrix = make_matrix(x, y); # create the matrix

matrix[y/2][x/2] = 1; # write something inside it

{{out}}

<pre>

</pre>

=={{header|Simula}}==

INTEGER N,M;

M := ININT;

END;

! ARRAY A OUT OF SCOPE ;

{{in}}

<pre>10 20</pre>

99

</pre>

 

=={{header|Smalltalk}}==

{{works with|Pharo}}

m := (FillInTheBlankMorph request: 'Number of rows?') asNumber.

n := (FillInTheBlankMorph request: 'Number of columns?') asNumber.

at: (aMatrix columnCount // 2).

Transcript show: 'Entry is', e printString.

{{works with|GNU Smalltalk}}

 

Smalltalk has no problems in creating objects at runtime. I haven't found a class for multidimensional array in the standard library, so let us suppose to have a class named MultidimensionalArray.

 

num1 := stdin nextLine asInteger.

num2 := stdin nextLine asInteger.

(arr at: {i. j}) displayNl

]

 

A possible implementation for a '''Bi'''dimensionalArray class is the following (changing ''Multi'' into ''Bi'' and using this class, the previous code runs fine):

 

|biArr|

<comment: 'bidim array'>

^ (biArr at: (biDim at: 1)) at: (biDim at: 2) put: val

]

 

Instead of implementing such a class (or the MultidimensionalArray one), we can use a LookupTable class, using Array objects as keys (each element of the array will be an index for a specific ''dimension'' of the "array"). The final effect is the same as using an array (almost in the ''AWK sense'') and the approach has some advantages.

 

num1 := stdin nextLine asInteger.

num2 := stdin nextLine asInteger.

(pseudoArr at: {i. j}) displayNl.

]

 

=={{header|SNOBOL4}}==

Note: trim(input) is needed for Snobol4+.

 

output = 'Enter X,Y:'; xy = trim(input)

xy break(',') . x ',' rem . y

* # Release array for garbage collection

arr =

 

Output:

 

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

val nbr2 = valOf (TextIO.scanStream (Int.scan StringCvt.DEC) TextIO.stdIn);

val array = Array2.array (nbr1, nbr2, 0.0);

Array2.update (array, 0, 0, 3.5);

 

=={{header|Stata}}==

display "Number of columns?" _request(nc)

matrix define a=J($nr,$nc,0)

matrix a[1,2]=1.5

matrix list a

 

This is also possible in Mata, except that console input is still done from Stata:

 

mata stata display "Number of rows?" _request(nr)

mata stata display "Number of columns?" _request(nc)

a

mata drop a

 

=={{header|Swift}}==

 

print("Enter the dimensions of the array seperated by a space (width height): ")

println(array)

}

{{out}}

<pre>

=={{header|Tcl}}==

{{works with|Tcl|8.5}}

puts "Enter width:"

set width [gets stdin]

# Cleanup array

unset arr

 

=={{header|Toka}}==

Toka has no direct support for 2D arrays, but they can be created and operated on in a manner similar to normal arrays using the following functions.

 

cells malloc >r

dup cells >r

[ ( value a b address -- )

array.get array.put

 

And a short test:

10 2 3 r@ 2D-put-element #! Set element 2,3 to 10

2 3 r@ 2D-get-element #! Get the element at 2,3

 

=={{header|Ursa}}==

out "width: " console

set width (in int console)

 

set twodstream<0><0> 5

 

=={{header|VBA}}==

 

Option Explicit

 

Erase myArray

End Sub

 

=={{header|Vim Script}}==

" The optional third argument specifies the initial value

" (default is 0).

let array[rows - 1][cols - 1] = rows * cols

echo array[rows - 1][cols - 1]

 

=={{header|Wren}}==

 

var x

System.print("\na[%(x-1)][%(y-1)] = %(a[x-1][y-1])")

// make the array eligible for garbage collection

 

{{out}}

 

=={{header|XPL0}}==

def IntSize=4; \number of bytes in an integer (2 or 4 depending on version)

int X, Y, A, I;

A(X/2, Y/2):= X+Y;

IntOut(0, A(X/2, Y/2)); CrLf(0);

 

Space allocated by the Reserve intrinsic is automatically released when

 

Since the array is row major, sub-scripting works as expected: [row][col].

cols:=ask("columns: ").toInt();

array:=rows.pump(List.createLong(rows),List.createLong(cols,0).copy);

array[1][2]=123;

array.println();

The createLong method pre-allocates a list, optionally filled with a constant or computation.

{{out}}

</pre>

If you want Matrix/linear algebra, you can use the GNU Scientific Library:

rows:=ask("Rows: ").toInt();

cols:=ask("columns: ").toInt();

m[1,2]=123;

m.format().println();

Again, garbage collected.

{{out}}

 

=={{header|zonnon}}==

module Main;

type

writeln("m[0,1].> ",m[0,1])

end Main.

{{Out}}

<pre>