Create a two-dimensional array at runtime: Difference between revisions
No edit summary |
m (mass lang tag) |
||
Line 65: | Line 65: | ||
With language built-in facilities: |
With language built-in facilities: |
||
<lang cpp> #include <iostream> |
|||
#include <istream> |
#include <istream> |
||
#include <ostream> |
#include <ostream> |
||
Line 90: | Line 90: | ||
delete[] array; |
delete[] array; |
||
delete[] array_data; |
delete[] array_data; |
||
} |
}</lang> |
||
Using std::vector from the standard library: |
Using std::vector from the standard library: |
||
<lang cpp> #include <iostream> |
|||
#include <istream> |
#include <istream> |
||
#include <ostream> |
#include <ostream> |
||
Line 115: | Line 115: | ||
// the array is automatically freed at the end of main() |
// the array is automatically freed at the end of main() |
||
} |
}</lang> |
||
=={{header|D}}== |
=={{header|D}}== |
||
< |
<lang d> |
||
import std.stdio: writef, writefln, readln; |
import std.stdio: writef, writefln, readln; |
||
import std.conv: toInt; |
import std.conv: toInt; |
||
Line 134: | Line 134: | ||
writefln("The number at place [0 0] is ", array[0][0]); |
writefln("The number at place [0 0] is ", array[0][0]); |
||
} |
} |
||
</ |
</lang> |
||
=={{header|Clean}}== |
=={{header|Clean}}== |
||
<lang clean> import StdEnv |
|||
Start :: *World -> { {Real} } |
Start :: *World -> { {Real} } |
||
Line 144: | Line 144: | ||
(_, dim1, console) = freadi console |
(_, dim1, console) = freadi console |
||
(_, dim2, console) = freadi console |
(_, dim2, console) = freadi console |
||
= createArray dim1 (createArray dim2 1.0) |
= createArray dim1 (createArray dim2 1.0)</lang> |
||
=={{header|Common Lisp}}== |
=={{header|Common Lisp}}== |
||
Line 161: | Line 161: | ||
=={{header|Forth}}== |
=={{header|Forth}}== |
||
<lang forth> : cell-matrix |
|||
create ( width height "name" ) over , * cells allot |
create ( width height "name" ) over , * cells allot |
||
does> ( x y -- addr ) dup cell+ >r @ * + cells r> + ; |
does> ( x y -- addr ) dup cell+ >r @ * + cells r> + ; |
||
Line 168: | Line 168: | ||
36 0 0 test ! |
36 0 0 test ! |
||
0 0 test @ . \ 36 |
0 0 test @ . \ 36</lang> |
||
{{libheader|Forth Scientific Library}} |
{{libheader|Forth Scientific Library}} |
||
<lang forth> |
|||
<pre><nowiki> |
|||
INTEGER DMATRIX my-matrix{{ |
INTEGER DMATRIX my-matrix{{ |
||
& my-matrix{{ 8 9 }}malloc |
& my-matrix{{ 8 9 }}malloc |
||
Line 179: | Line 179: | ||
& my-matrix{{ }}free |
& my-matrix{{ }}free |
||
</lang> |
|||
</nowiki></pre> |
|||
=={{header|Fortran}}== |
=={{header|Fortran}}== |
||
In Fortran 90 and later |
In Fortran 90 and later |
||
<lang fortran> PROGRAM Example |
|||
IMPLICIT NONE |
IMPLICIT NONE |
||
Line 202: | Line 202: | ||
DEALLOCATE (array, STAT=errcheck) |
DEALLOCATE (array, STAT=errcheck) |
||
END PROGRAM Example |
END PROGRAM Example</lang> |
||
=={{header|Haskell}}== |
=={{header|Haskell}}== |
||
<lang haskell> doit n m = a!(0,0) where a = array ((0,0),(n,m)) [((0,0),42)]</lang> |
|||
=={{header|IDL}}== |
=={{header|IDL}}== |
||
The following is only for demonstration. No real program should just assume that the user input is valid, integer, large enough etc. |
The following is only for demonstration. No real program should just assume that the user input is valid, integer, large enough etc. |
||
<lang idl> read, x, prompt='Enter x size:' |
|||
read, y, prompt='Enter y size:' |
read, y, prompt='Enter y size:' |
||
d = fltarr(x,y) |
d = fltarr(x,y) |
||
Line 219: | Line 219: | ||
;==> outputs 5.6 |
;==> outputs 5.6 |
||
delvar, d |
delvar, d</lang> |
||
=={{header|J}}== |
=={{header|J}}== |
||
In J, all aspects of arrays are resolved through evaluation. Everything counts as being given at run time. |
In J, all aspects of arrays are resolved through evaluation. Everything counts as being given at run time. |
||
<lang j> task=: 3 : 0 |
|||
'init new' =. 0;1 NB. values for initialization and alteration |
'init new' =. 0;1 NB. values for initialization and alteration |
||
array =. y $ init NB. create array of shape y |
array =. y $ init NB. create array of shape y |
||
Line 230: | Line 230: | ||
array =. new element } array NB. amend that element to new value |
array =. new element } array NB. amend that element to new value |
||
element { array NB. return value of changed element |
element { array NB. return value of changed element |
||
) |
)</lang> |
||
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. |
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. |
||
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: |
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: |
||
<lang j> 'init new' =. ' ';'x' NB. literals |
|||
'init new' =. 1r2;2r3 NB. fractions |
'init new' =. 1r2;2r3 NB. fractions |
||
'init new' =. a: ; <<'Rosetta' NB. boxes |
'init new' =. a: ; <<'Rosetta' NB. boxes</lang> |
||
=={{header|Java}}== |
=={{header|Java}}== |
||
<lang java> import java.util.Scanner; |
|||
public class twoDimArray { |
public class twoDimArray { |
||
Line 253: | Line 253: | ||
System.out.println("The number at place [0 0] is " + array[0][0]); |
System.out.println("The number at place [0 0] is " + array[0][0]); |
||
} |
} |
||
} |
}</lang> |
||
=={{header|Logo}}== |
=={{header|Logo}}== |
||
{{works with|UCB Logo}} |
{{works with|UCB Logo}} |
||
<lang logo> make "a2 mdarray [5 5] |
|||
mdsetitem [1 1] :a2 0 ; by default, arrays are indexed starting at 1 |
mdsetitem [1 1] :a2 0 ; by default, arrays are indexed starting at 1 |
||
print mditem [1 1] :a2 ; 0 |
print mditem [1 1] :a2 ; 0</lang> |
||
=={{header|MAXScript}}== |
=={{header|MAXScript}}== |
||
Line 276: | Line 276: | ||
=={{header|OCaml}}== |
=={{header|OCaml}}== |
||
<lang ocaml> let nbr1 = read_int ();; |
|||
let nbr2 = read_int ();; |
let nbr2 = read_int ();; |
||
let array = Array.make_matrix nbr1 nbr2 0.0;; |
let array = Array.make_matrix nbr1 nbr2 0.0;; |
||
array.(0).(0) <- 3.5;; |
array.(0).(0) <- 3.5;; |
||
print_float array.(0).(0); print_newline ();; |
print_float array.(0).(0); print_newline ();;</lang> |
||
=={{header|Pascal}}== |
=={{header|Pascal}}== |
||
Line 287: | Line 287: | ||
The following code is standard Extended Pascal (tested with <tt>gpc --extended-pascal</tt>): |
The following code is standard Extended Pascal (tested with <tt>gpc --extended-pascal</tt>): |
||
<lang pascal> program array2d(input, output); |
|||
type |
type |
||
Line 312: | Line 312: | ||
{ get rid of array } |
{ get rid of array } |
||
dispose(data); |
dispose(data); |
||
end. |
end.</lang> |
||
Line 320: | Line 320: | ||
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. |
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. |
||
<lang perl> sub make_array($ $){ |
|||
# get array sizes from provided params, but force numeric value |
# get array sizes from provided params, but force numeric value |
||
my $x = ($_[0] =~ /^\d+$/) ? shift : 0; |
my $x = ($_[0] =~ /^\d+$/) ? shift : 0; |
||
Line 338: | Line 338: | ||
print "\n"; |
print "\n"; |
||
} |
} |
||
} |
}</lang> |
||
=={{header|Pop11}}== |
=={{header|Pop11}}== |
||
<lang pop11> vars itemrep; |
|||
incharitem(charin) -> itemrep; |
incharitem(charin) -> itemrep; |
||
;;; Read sizes |
;;; Read sizes |
||
Line 352: | Line 352: | ||
ar(0,0) => |
ar(0,0) => |
||
;;; Make sure array is unreferenced |
;;; Make sure array is unreferenced |
||
0 -> ar; |
0 -> ar;</lang> |
||
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 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. |
||
Line 377: | Line 377: | ||
=={{header|Ruby}}== |
=={{header|Ruby}}== |
||
puts 'Enter width and height: ' |
<lang ruby> puts 'Enter width and height: ' |
||
w=gets.to_i |
w=gets.to_i |
||
arr = Array.new(gets.to_i){Array.new(w)} |
arr = Array.new(gets.to_i){Array.new(w)} |
||
arr[1][3] = 5 |
arr[1][3] = 5 |
||
p arr[1][3] |
p arr[1][3]</lang> |
||
=={{header|Tcl}}== |
=={{header|Tcl}}== |
||
Line 399: | Line 399: | ||
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. |
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. |
||
<lang toka> [ ( x y -- address ) |
|||
cells malloc >r |
cells malloc >r |
||
dup cells >r |
dup cells >r |
||
Line 412: | Line 412: | ||
[ ( value a b address -- ) |
[ ( value a b address -- ) |
||
array.get array.put |
array.get array.put |
||
] is 2D-put-element |
] is 2D-put-element</lang> |
||
And a short test: |
And a short test: |
||
<lang toka> 5 5 2D-array >r #! Create an array and save the pointer to it |
|||
10 2 3 r@ 2D-put-element #! Set element 2,3 to 10 |
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 |
2 3 r@ 2D-get-element #! Get the element at 2,3 |
||
r> drop #! Discard the pointer to the array |
r> drop #! Discard the pointer to the array</lang> |
Revision as of 09:46, 9 April 2009
You are encouraged to solve this task according to the task description, using any language you may know.
Data Structure
This illustrates a data structure, a means of storing data within a program.
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.
Ada
<lang ada>
with Ada.Text_Io; use Ada.Text_Io; with Ada.Float_Text_Io; use Ada.Float_Text_Io; with Ada.Integer_Text_Io; use Ada.Integer_Text_Io; procedure Two_Dimensional_Arrays is type Matrix_Type is array(Positive range <>, Positive range <>) of Float; Dim_1 : Positive; Dim_2 : Positive; begin Get(Item => Dim_1); Get(Item => Dim_2); -- Create an inner block with the correctly sized array declare Matrix : Matrix_Type(1..Dim_1, 1..Dim_2); begin Matrix(1, Dim_2) := 3.14159; Put(Item => Matrix(1, Dim_2), Fore => 1, Aft => 5, Exp => 0); New_Line; end; -- The variable Matrix is popped off the stack automatically end Two_Dimensional_Arrays;
</lang>
ALGOL 68
main:( 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]) )
BASIC
CLS 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) ERASE array
C
<lang c>
- include <stdio.h>
int main(int argc, char **argv) {
int user1 = 0, user2 = 0; printf("Enter two integers. Space delimited, please: "); scanf("%d %d",&user1, &user2); int array[user1][user2]; array[user1/2][user2/2] = user1 + user2; printf("array[%d][%d] is %d\n",user1/2,user2/2,array[user1/2][user2/2]);
return 0;
} </lang>
C++
With language built-in facilities:
<lang cpp> #include <iostream>
#include <istream> #include <ostream> int main() { // read values int dim1, dim2; std::cin >> dim1 >> dim2; // create array double* array_data = new double[dim1*dim2]; double** array = new double*[dim1]; for (int i = 0; i < dim1; ++i) array[i] = array_data + dim2*i; // write element array[0][0] = 3.5; // output element std::cout << array[0][0] << std::endl; // get rid of array delete[] array; delete[] array_data; }</lang>
Using std::vector from the standard library:
<lang cpp> #include <iostream>
#include <istream> #include <ostream> #include <vector> int main() { // read values int dim1, dim2; std::cin >> dim1 >> dim2; // create array std::vector<std::vector<double> > array(dim1, std::vector<double>(dim2)); // write element array[0][0] = 3.5; // output element std::cout << array[0][0] << std::endl; // the array is automatically freed at the end of main() }</lang>
D
<lang d> import std.stdio: writef, writefln, readln; import std.conv: toInt; import std.string: strip;
void main() {
writef("Give me the numer of rows: "); int nrow = toInt(readln().strip());
writef("Give me the numer of columns: "); int ncol = toInt(readln().strip());
auto array = new float[][](nrow, ncol); array[0][0] = 3.5; writefln("The number at place [0 0] is ", array[0][0]);
} </lang>
Clean
<lang clean> import StdEnv
Start :: *World -> { {Real} } Start world # (console, world) = stdio world (_, dim1, console) = freadi console (_, dim2, console) = freadi console = createArray dim1 (createArray dim2 1.0)</lang>
Common Lisp
(let ((d1 (read)) (d2 (read))) (assert (and (typep d1 '(integer 1)) (typep d2 '(integer 1))) (d1 d2)) (let ((array (make-array (list d1 d2) :initial-element nil)) (p1 0) (p2 (floor d2 2))) (setf (aref array p1 p2) t) (print (aref array p1 p2))))
The assert will allow the user to reenter the dimensions if they are not positive integers.
Forth
<lang forth> : cell-matrix
create ( width height "name" ) over , * cells allot does> ( x y -- addr ) dup cell+ >r @ * + cells r> + ; 5 5 cell-matrix test 36 0 0 test ! 0 0 test @ . \ 36</lang>
<lang forth>
INTEGER DMATRIX my-matrix{{ & my-matrixTemplate:8 9malloc 8 my-matrixTemplate:3 4 ! my-matrixTemplate:3 4 @ . & my-matrix{{ }}free
</lang>
Fortran
In Fortran 90 and later <lang fortran> PROGRAM Example
IMPLICIT NONE INTEGER :: rows, columns, errcheck INTEGER, ALLOCATABLE :: array(:,:) WRITE(*,*) "Enter number of rows" READ(*,*) rows WRITE(*,*) "Enter number of columns" READ(*,*) columns ALLOCATE (array(rows,columns), STAT=errcheck) ! STAT is optional and is used for error checking array(1,1) = 42 WRITE(*,*) array(1,1) DEALLOCATE (array, STAT=errcheck) END PROGRAM Example</lang>
Haskell
<lang haskell> doit n m = a!(0,0) where a = array ((0,0),(n,m)) [((0,0),42)]</lang>
IDL
The following is only for demonstration. No real program should just assume that the user input is valid, integer, large enough etc.
<lang idl> read, x, prompt='Enter x size:'
read, y, prompt='Enter y size:' d = fltarr(x,y) d[3,4] = 5.6 print,d[3,4] ;==> outputs 5.6 delvar, d</lang>
J
In J, all aspects of arrays are resolved through evaluation. Everything counts as being given at run time. <lang j> task=: 3 : 0
'init new' =. 0;1 NB. values for initialization and alteration array =. y $ init NB. create array of shape y element =. < ? $ array NB. pick an atom of the array at random array =. new element } array NB. amend that element to new value element { array NB. return value of changed element )</lang>
Passing two integers to task (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.
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: <lang j> 'init new' =. ' ';'x' NB. literals
'init new' =. 1r2;2r3 NB. fractions 'init new' =. a: ; <<'Rosetta' NB. boxes</lang>
Java
<lang java> import java.util.Scanner;
public class twoDimArray { public static void main(String[] args) { Scanner in = new Scanner(System.in); int nbr1 = in.nextInt(); int nbr2 = in.nextInt(); double[][] array = new double[nbr1][nbr2]; array[0][0] = 42.0; System.out.println("The number at place [0 0] is " + array[0][0]); } }</lang>
Logo
<lang logo> make "a2 mdarray [5 5]
mdsetitem [1 1] :a2 0 ; by default, arrays are indexed starting at 1 print mditem [1 1] :a2 ; 0</lang>
MAXScript
a = getKBValue prompt:"Enter first dimension:" b = getKBValue prompt:"Enter second dimension:" arr1 = #() arr2 = #() arr2[b] = undefined for i in 1 to a do ( append arr1 (deepCopy arr2) ) arr1[a][b] = 1 print arr1[a][b]
OCaml
<lang ocaml> let nbr1 = read_int ();;
let nbr2 = read_int ();; let array = Array.make_matrix nbr1 nbr2 0.0;; array.(0).(0) <- 3.5;; print_float array.(0).(0); print_newline ();;</lang>
Pascal
The following code is standard Extended Pascal (tested with gpc --extended-pascal):
<lang pascal> program array2d(input, output);
type tArray2d(dim1, dim2: integer) = array[1 .. dim1, 1 .. dim2] of real; pArray2D = ^tArray2D; var d1, d2: integer; data: pArray2D; begin { read values } readln(d1, d2); { create array } new(data, d1, d2); { write element } data^[1,1] := 3.5; { output element } writeln(data^[1,1]); { get rid of array } dispose(data); end.</lang>
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.
<lang perl> sub make_array($ $){
# get array sizes from provided params, but force numeric value my $x = ($_[0] =~ /^\d+$/) ? shift : 0; my $y = ($_[0] =~ /^\d+$/) ? shift : 0; # define array, then add multi-dimensional elements my @array; $array[0][0] = 'X '; # first by first element $array[5][7] = 'X ' if (5 <= $y and 7 <= $x); # sixth by eighth element, if the max size is big enough $array[12][15] = 'X ' if (12 <= $y and 15 <= $x); # thirteenth by sixteenth element, if the max size is big enough # loop through the elements expected to exist base on input, and display the elements contents in a grid foreach my $dy (0 .. $y){ foreach my $dx (0 .. $x){ (defined $array[$dy][$dx]) ? (print $array[$dy][$dx]) : (print '. '); } print "\n"; } }</lang>
Pop11
<lang pop11> vars itemrep;
incharitem(charin) -> itemrep; ;;; Read sizes vars n1 = itemrep(), n2= itemrep(); ;;; Create 0 based array vars ar = newarray([0 ^(n1 - 1) 0 ^(n2 - 1)], 0); ;;; Set element value 15 -> ar(0, 0); ;;; Print element value ar(0,0) => ;;; Make sure array is unreferenced 0 -> ar;</lang>
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.
Python
<lang python>width = int(raw_input("Width of myarray: ")) height = int(raw_input("Height of Array: ")) myarray = [[0] * width for i in xrange(height)] myarray[0][0] = 3.5 print myarray[0][0]</lang>
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:
<lang python>myarray = dict(((w,h), 0) for w in range(width) for h in range(height))
- or, in Python 3: myarray = {(w,h): 0 for w in range(width) for h in range(height)}
myarray[(0,0)] = 3.5 print myarray[(0,0)]</lang>
Ruby
<lang ruby> puts 'Enter width and height: '
w=gets.to_i arr = Array.new(gets.to_i){Array.new(w)} arr[1][3] = 5 p arr[1][3]</lang>
Tcl
<lang tcl>package require Tcl 8.5
puts "enter dimension:" set dim1 [gets stdin] puts "enter dimension:" set dim2 [gets stdin] set l [lrepeat $dim1 [lrepeat $dim2 {}]] lset l end end aValue puts [lindex $l end end] unset l</lang>
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.
<lang toka> [ ( x y -- address )
cells malloc >r dup cells >r [ r> r> r> 2dup >r >r swap malloc swap i swap array.put >r ] iterate r> r> nip ] is 2D-array [ ( a b address -- value ) array.get array.get ] is 2D-get-element [ ( value a b address -- ) array.get array.put ] is 2D-put-element</lang>
And a short test:
<lang toka> 5 5 2D-array >r #! Create an array and save the pointer to it
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 r> drop #! Discard the pointer to the array</lang>