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

{{data structure}}

Get two integers from the user, then create a two-dimensional array where the two dimensions have the sizes given by those numbers, and which can be accessed in the most natural way possible. Write some element of that array, and then output that element. Finally destroy the array if not done by the language itself.

 

=={{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 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 {}

 

 

=={{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}}==

{{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|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++}}==

 

 

int main()

delete[] array;

delete[] array_data;

 

 

#include <vector>

 

 

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

 

{{libheader|Boost}}

 

typedef boost::multi_array<double, 2> two_d_array_type;

two_d_array_type A(boost::extents[dim1][dim2]);

 

A[0][0] = 3.1415;

 

std::cout << A[0][0] << std::endl;

 

 

}

 

=={{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|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 07 = 04 rows

Column 08 = 10 rows

 

=={{header|Elena}}==

Typified array

 

 

 

=={{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>

In position 3 4 we have 20

</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|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|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.

 

 

 

 

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).

 

{{out}}

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

[3, 4, 5, 6, 7]

[4, 5, 6, 7, 8]</pre>

 

=={{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|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

 

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}}==

w = readLineFromStdin("Width: ").parseInt()

h = readLineFromStdin("Height: ").parseInt()

 

 

=={{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.

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|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.

Pop11 arrays may have arbitrary lower bounds, since we are given only size we create 0 based array.

 

 

 

 

 

 

=={{header|Python}}==

 

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

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|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:

Enter a number for the bottom-right: 9

'#(#(1 0 0) #(0 0 0) #(0 0 9))

</pre>

 

=={{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>

· · · · · 30~6 · 30~8 30~9 · · · · · ·

</pre>

 

=={{header|Ruby}}==

w=gets.to_i

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

arr[1][3] = 5

 

 

=={{header|Scala}}==

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

val x = Console.readInt

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

}

 

=={{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>

[[0, 0, 0, 0], [0, 0, 1, 0], [0, 0, 0, 0]]

</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|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|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|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

zkl doesn't have a native array type but lists of lists can do the same thing. It is garbage collected so things are cleaned up implicitly.

 

 

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

{{out}}

<pre>

Rows: 3

columns: 4

</pre>