Some of Sunday's edits have been lost. The edits from Saturday that were reverted have been restored. Site is now hosted on prgmr.com. Thank you for your patience. This notice will be removed one week from posting. --Michael Mol 18:12, 7 March 2010 (UTC)
Arrays
From Rosetta Code
This task is about arrays. For hashes or associative arrays, please see Creating an Associative Array.
In this task, the goal is to show basic array syntax in your language. Basically, create an array, assign a value to it, and retrieve an element. (if available, show both fixed-length arrays and dynamic arrays, pushing a value into it.)
Please discuss at Village Pump: Arrays. Please merge code in from obsolete tasks Creating an Array, Assigning Values to an Array, and Retrieving an Element of an Array.
See also
[edit] Ada
procedure Array_Test is
A : array (1..20) of Integer;
begin
A := (others => 0); -- Assign whole array
A (1) := -1; -- Assign individual element
A (3..5) := (2, 4, -1); -- Assign a slice
A (3..5) := A (4..6); -- It is OK to overlap slices when assigned
end Array_Test;
Arrays are first-class objects in Ada. They can be allocated statically or dynamically as any other object. The number of elements in an array object is always constrained. Variable size arrays are provided by the standard container library. They also can be implemented as user-defined types.
[edit] ALGOL 68
PROC array_test = VOID:
(
[1:20]INT a;
a := others; # assign whole array #
a[1] := -1; # assign individual element #
a[3:5] := (2, 4, -1); # assign a slice #
[1:3]INT slice = a[3:5]; # copy a slice #
REF []INT rslice = a[3:5]; # create a reference to a slice #
print((LWB rslice, UPB slice)); # query the bounds of the slice #
rslice := (2, 4, -1); # assign to the slice, modifying original array #
[1:3, 1:3]INT matrix; # create a two dimensional array #
REF []INT hvector = matrix[2,]; # create a reference to a row #
REF []INT vvector = matrix[,2]; # create a reference to a column #
REF [,]INT block = matrix[1:2, 1:2]; # create a reference to an area of the array #
FLEX []CHAR string := "Hello, world!"; # create an array with variable bounds #
string := "shorter" # flexible arrays automatically resize themselves on assignment #
)
Arrays in ALGOL 68 are first class objects. Slices to any portion of the array can be created and then treated equivalently to arrays, even sections of a multidimensional array; the bounds are queried at run time. References may be made to portions of an array. Flexible arrays are supported, which resize themselves on assignment, but they can't be resized without destroying the data.
[edit] Argile
use std, array
(:::::::::::::::::
: Static arrays :
:::::::::::::::::)
let the array of 2 text aabbArray be Cdata{"aa";"bb"}
let raw array of real :my array: = Cdata {1.0 ; 2.0 ; 3.0} (: auto sized :)
let another_array be an array of 256 byte (: not initialised :)
let (raw array of (array of 3 real)) foobar = Cdata {
{1.0; 2.0; 0.0}
{5.0; 1.0; 3.0}
}
(: macro to get size of static arrays :)
=: <array>.length := -> nat {size of array / (size of array[0])}
printf "%lu, %lu\n" foobar.length (another_array.length) (: 2, 256 :)
(: access :)
another_array[255] = '&'
printf "`%c'\n" another_array[255]
(::::::::::::::::::
: Dynamic arrays :
::::::::::::::::::)
let DynArray = new array of 5 int
DynArray[0] = -42
DynArray = (realloc DynArray (6 * size of DynArray[0])) as (type of DynArray)
DynArray[5] = 243
prints DynArray[0] DynArray[5]
del DynArray
[edit] AutoHotkey
AutoHotkey does not have typical arrays. However, variable names can be concatenated, simulating associative arrays. Just without the syntactic sugar of '[]'. By convention, based on built-in function stringsplit, indexes are 1-based and "0" index is the length.
arrayX0 = 4 ; length
arrayX1 = first
arrayX2 = second
arrayX3 = foo
arrayX4 = bar
Loop, %arrayX0%
Msgbox % arrayX%A_Index%
source = apple bear cat dog egg fish
StringSplit arrayX, source, %A_Space%
Loop, %arrayX0%
Msgbox % arrayX%A_Index%
[edit] BASIC
Static:
DIM staticArray(10) AS INTEGER
staticArray(0) = -1
staticArray(10) = 1
PRINT staticArray(0), staticArray(10)
Dynamic (Note that BASIC dynamic arrays are not stack-based; instead, their size must be changed in the same manner as their initial declaration -- the only difference between static and dynamic arrays is the keyword used to declare them (DIM vs. REDIM). QBasic lacks the PRESERVE keyword found in some modern BASICs; resizing an array without PRESERVE zeros the values):
REDIM dynamicArray(10) AS INTEGER
dynamicArray(0) = -1
PRINT dynamicArray(0)
REDIM dynamicArray(20)
dynamicArray(20) = 1
PRINT dynamicArray(0), dynamicArray(20)
[edit] C
Fixed size static array of integers with initialization:
int myArray2[10] = { 1, 2, 0 }; /* the rest of elements get the value 0 */
float myFloats[] ={1.2, 2.5, 3.333, 4.92, 11.2, 22.0 }; /* automaticaly sizes */
When no size is given, the array is automatically sized. Typically this is how initialized arrays are defined. When this is done, you'll often see a definition that produces the number of elements in the array, as follows.
#define MYFLOAT_SIZE (sizeof(myFloats)/sizeof(myFloats[0]))
When defining autosized multidimensional arrays, all the dimensions except the first (leftmost) need to be defined. This is required in order for the compiler to generate the proper indexing for the array.
long a2D_Array[3][5]; /* 3 rows, 5 columns. */
float my2Dfloats[][3] = {
1.0, 2.0, 0.0,
5.0, 1.0, 3.0 };
#define FLOAT_ROWS (sizeof(my2Dfloats)/sizeof(my2dFloats[0])) /* OR */
#define FLOAT_ROWS (sizeof(my2Dfloats)/sizeof(float))
When the size of the array is not known at compile time, arrays may be dynamically allocated to the proper size. The malloc(), calloc() and free() functions require the header stdlib.h.
int numElements = 10;
int *myArray = (int *)malloc(sizeof(int) * numElements); /* array of 10 integers */
if ( myArray != NULL ) /* check to ensure allocation suceeded. */
{
/* allocation succeeded */
/* at the end, we need to free the allocated memory */
free(myArray);
}
/* calloc() additionally pre-initializes to all zeros */
short *myShorts = (short *)calloc( numElements, sizeof(short)); /* array of 10 */
if (myShorts != NULL)....
Once allocated, myArray can be used as a normal array.
The first element of a C array is indexed with 0. To set a value:
myArray[0] = 1;
myArray[1] = 3;
And to retrieve it (e.g. for printing, provided that the stdio.h header was included for the printf function)
printf("%d\n", myArray[1]);
The array[index] syntax can be considered as a shortcut for *(index + array) and thus the square brackets are a commutative binary operator:
*(array + index) = 1;
printf("%d\n", *(array + index));
3[array] = 5;
There's no bounds check on the indexes. Negative indexing can be implemented as in the following.
#define XSIZE 20
double *kernel = (double *)malloc(sizeof(double)*2*XSIZE+1);
if (kernel) {
kernel += XSIZE;
for (ix=-XSIZE; ix<=XSIZE; ix++) {
kernel[ix] = f(ix);
....
free(kernel-XSIZE);
}
}
C natively has no variable length arrays. Typically dynamic allocation is used and the allocated array is sized to the maximum that might be needed. A additional variable is declared and used to maintain the current number of elements used.
[edit] C++
Stack allocated fixed-size (C-style) array:
int myArray[2];
myArray[0] = 1;
myArray[1] = 3;
cout << myArray[1] << endl;
Heap allocated fixed-size array:
int* myArray = new int[10];
myArray[0] = 1;
myArray[1] = 3;
cout << myArray[1] << endl;
delete [] myArray;
Heap allocated variable-size array (std::vector) capable of bounds checks:
vector<int> myArray2;
myArray2.push_back(1);
myArray2.push_back(3);
myArray2[0] = 2;
cout << myArray2[0] << endl;
[edit] C#
int[] array = new int[10];
array[0] = 1;
array[1] = 3;
Console.WriteLine(array[0]);
Dynamic
using System;
using System.Collections;
ArrayList<int> array = new ArrayList<int>();
array.Add(1);
array.Add(3);
array[0] = 2;
Console.WriteLine(array[0]);
[edit] Common Lisp
(let ((array (make-array 10)))
(setf (aref array 0) 1
(aref array 1) 3)
(print array))
Dynamic
(let ((array (make-array 0 :adjustable t :fill-pointer 0)))
(vector-push-extend 1 array)
(vector-push-extend 3 array)
(setf (aref array 0) 2)
(print array))
[edit] D
Stack allocated fixed-size array:
import std.stdio;
int main() {
int[5]myArray;
myArray[0] = 1;
myArray[1] = 3;
writefln("Element 0: %d",myArray[0]);
writefln("Element 1: %d",myArray[1]);
return 0;
}
Heap allocated dynamic array capable of bounds checks (note that ~ is the array concat operator):
import std.stdio;
int main() {
int[]myArray;
myArray ~= 1;
myArray ~= 3;
writefln("Element 0: %d",myArray[0]);
writefln("Element 1: %d",myArray[1]);
return 0;
}
[edit] E
E's collection library emphasizes providing both mutable and immutable collections. The relevant array-like types are ConstList and FlexList.
Literal lists are ConstLists.
? def empty := []
# value: []
? def numbers := [1,2,3,4,5]
# value: [1, 2, 3, 4, 5]
? numbers.with(6)
# value: [1, 2, 3, 4, 5, 6]
? numbers + [4,3,2,1]
# value: [1, 2, 3, 4, 5, 4, 3, 2, 1]
Note that each of these operations returns a different list object rather than modifying the original. You can, for example, collect values:
? var numbers := []
# value: []
? numbers := numbers.with(1)
# value: [1]
? numbers with= 2 # shorthand for same
# value: [1, 2]
FlexLists can be created explicitly, but are typically created by diverging another list. A ConstList can be gotten from a FlexList by snapshot.
? def flex := numbers.diverge()
# value: [1, 2].diverge()
? flex.push(-3)
? flex
# value: [1, 2, -3].diverge()
? numbers
# value: [1, 2]
? flex.snapshot()
# value: [1, 2, -3]
Creating a FlexList with a specific size, generic initial data, and a type restriction:
([0] * 100).diverge(int) # contains 100 zeroes, can only contain integers
Note that this puts the same value in every element; if you want a collection of some distinct mutable objects, see N distinct objects#E.
In accordance with its guarantees of determinism, you can never have an uninitialized FlexList in E.
[edit] Factor
(cleave applies all the quotations to the initial argument (the array)) This demonstrates array litterals and writing/reading to the array
Directly in the listener :
{ 1 2 3 }
{
[ "The initial array: " write . ]
[ [ 42 1 ] dip set-nth ]
[ "Modified array: " write . ]
[ "The element we modified: " write [ 1 ] dip nth . ]
} cleave
The initial array: { 1 2 3 }
Modified array: { 1 42 3 }
The element we modified: 42
Arrays of arbitrary length can be created with the <array> word :
( scratchpad - auto ) 10 42 <array> .
{ 42 42 42 42 42 42 42 42 42 42 }
Arrays can contain different types :
{ 1 "coucou" f [ ] }
Arrays of growable length are called Vectors.
V{ 1 2 3 }
{
[ "The initial vector: " write . ]
[ [ 42 ] dip push ]
[ "Modified vector: " write . ]
} cleave
The initial vector: V{ 1 2 3 }
Modified vector: V{ 1 2 3 42 }
Vectors can also be used with set-nth and nth.
( scratchpad - auto ) V{ } [ [ 5 5 ] dip set-nth ] [ . ] bi
V{ 0 0 0 0 0 5 }
[edit] Forth
Forth has a variety of ways to allocate arrays of data as contiguous blocks of memory, though it has no built-in array handling words, favoring pointer arithmetic.
For example, a static array of 10 cells in the dictionary, 5 initialized and 5 uninitialized:
create MyArray 1 , 2 , 3 , 4 , 5 , 5 cells allot
here constant MyArrayEnd
30 array 7 cells + !
array 7 cells + @ . \ 30
: .array MyArrayEnd MyArray do I @ . cell +loop ;
[edit] Fortran
Works with: Fortran version 90 and later
Basic array declaration:
integer a (10)
integer :: a (10)
integer, dimension (10) :: a
Arrays are one-based. These declarations are equivalent:
integer, dimension (10) :: a
integer, dimension (1 : 10) :: a
Other bases can be used:
integer, dimension (0 : 9) :: a
Arrays can have any type (intrinsic or user-defined), e.g.:
real, dimension (10) :: a
type (my_type), dimension (10) :: a
Multidimensional array declaration:
integer, dimension (10, 10) :: a
integer, dimension (10, 10, 10) :: a
Allocatable array declaration:
integer, dimension (:), allocatable :: a
integer, dimension (:, :), allocatable :: a
Array allocation:
allocate (a (10))
allocate (a (10, 10))
Array deallocation:
deallocate (a)
Array initialisation:
integer, dimension (10) :: a = (/1, 2, 3, 4, 5, 6, 7, 8, 9, 10/)
integer :: i
integer, dimension (10) :: a = (/(i * i, i = 1, 10)/)
integer, dimension (10) :: a = 0
integer :: i
integer, dimension (10, 10) :: a = reshape ((/(i * i, i = 1, 100)/), (/10, 10/))
Constant array declaration:
integer :: i
integer, dimension (10), parameter :: a = (/(i * i, i = 1, 10)/)
Element assignment:
a (1) = 1
a (1, 1) = 1
Array assignment:
a = (/1, 2, 3, 4, 5, 6, 7, 8, 9, 10/)
a = (/(i * i, i = 1, 10)/)
a = reshape ((/(i * i, i = 1, 100)/), (/10, 10/))
a = 0
Array section assignment:
a (:) = (/1, 2, 3, 4, 5, 6, 7, 8, 9, 10/)
a (1 : 5) = (/1, 2, 3, 4, 5/)
a (: 5) = (/1, 2, 3, 4, 5/)
a (6 :) = (/1, 2, 3, 4, 5/)
a (1 : 5) = (/(i * i, i = 1, 10)/)
a (1 : 5)= 0
a (1, :)= (/(i * i, i = 1, 10)/)
a (1 : 5, 1)= (/(i * i, i = 1, 5)/)
Element retrieval:
i = a (1)
Array section retrieval:
a = b (1 : 10)
Size retrieval:
i = size (a)
Size along a single dimension retrieval:
i = size (a, 1)
Bounds retrieval:
i_min = lbound (a)
i_max = ubound (a)
Bounds of a multidimensional array retrieval:
a = ubound (b)
[edit] Haskell
You can read all about Haskell arrays here. The following example is taken from that page:
import Data.Array.IO
main = do arr <- newArray (1,10) 37 :: IO (IOArray Int Int)
a <- readArray arr 1
writeArray arr 1 64
b <- readArray arr 1
print (a,b)
[edit] J
In J, all data occurs in the form of rectangular (or generally orthotopic) arrays. This is true for both named and anonymous data.
1 NB. a stand-alone scalar value is an array without any axis
1
NB. invoking any array produces that array as the result
{. array=: 1 3, 6#0 NB. create, name, then get head element of the array: 1 3 0 0 0 0 0 0
1
0{array NB. another way to get the head element
1
aword=: 'there' NB. a literal array
0 1 3 2 2 { aword NB. multiple elements can be drawn in a single action
three
]twoD=: 3 5 $ 'abcdefghijklmnopqrstuvwxyz'
abcde
fghij
klmno
1{twoD NB. item 1 from twoD - a list of three items
fghij
(<2 2){twoD NB. bracket indexing is not used in J
m
'X' (0 0;1 1;2 2) } twoD NB. amend specified items
Xbcde
fXhij
klXno
Because arrays are so important in J, a large portion of the language applies to this topic.
[edit] Java
int[] array = new int[10]; //optionally, replace "new int[10]" with a braced list of ints like "{1, 2, 3}"
array[0] = 42;
System.out.println(array[3]);
Dynamic arrays can be made using Lists. Leave generics out for Java versions under 1.5:
ArrayList <Integer> list = new ArrayList <Integer>();//optionally add an initial size as an argument
list.add(5);//appends to the end of the list
list.add(1, 6);//assigns the element at index 1
System.out.println(list.get(0));
[edit] JavaScript
JavaScript arrays use the Array prototype, an Object that uses numerical indexes starting from 0 and knows its length.
var myArray = new Array();
var myArray1 = new Array(5); // gotcha: preallocated array with five empty elements, not [ 5 ].
var myArray2 = new Array("Item1","Item2");
var myArray3 = ["Item1", "Item2"]; // array literal
myArray[2] = 5;
var x = myArray[2] + myArray.length; // 8
[edit] Lisaac
+ a : ARRAY[INTEGER];
a := ARRAY[INTEGER].create 0 to 9;
a.put 1 to 0;
a.put 3 to 1;
a.item(1).print;
[edit] Logo
array 5 ; default origin is 1, every item is empty
(array 5 0) ; custom origin
make "a {1 2 3 4 5} ; array literal
setitem 1 :a "ten ; Logo is dynamic; arrays can contain different types
print item 1 :a ; ten
[edit] LSE64
10 myArray :array
0 array 5 [] ! # store 0 at the sixth cell in the array
array 5 [] @ # contents of sixth cell in array
[edit] Lua
Lua does not differentiate between arrays, lists, sets, dictionaries, maps, etc. It supports only one container: Table. Using Lua's simple yet powerful syntax, any of these containers can be emulated. All tables are dynamic. If a static array is necessary, that behavior can be created.
l = {}
l[1] = 1 -- Index starts with 1, not 0.
l[0] = 'zero' -- But you can use 0 if you want
l[10] = 2 -- Indexes need not be continuous
l.a = 3 -- Treated as l['a']. Any object can be used as index
l[l] = l -- Again, any object can be used as an index. Even other tables
for i,v in next,l do print (i,v) end
[edit] Modula-3
VAR a: ARRAY [1..10] OF INTEGER;
Defines an array of 10 elements, indexed 1 through 10.
Arrays can also be given initial values:
VAR a := ARRAY [1..10] OF INTEGER {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
VAR arr1 := ARRAY [1..10] OF INTEGER {1, ..} (* Initialize all elements to 1. *)
To retrieve an element:
VAR arr := ARRAY [1..3] OF INTEGER {1, 2, 3};
VAR myVar := a[2];
To assign a value to an element:
VAR arr := ARRAY [1..3] OF INTEGER;
arr[1] := 10;
[edit] NewLISP
This creates an array of 5 elements, initialized to nil:
(array 5)
→ (nil nil nil nil nil)
The example below creates a multi-dimensional array (a 3-element array of 4-element arrays), initialized using the values returned by the function sequence (a list containing whole numbers from 1 to 12) and stores the newly created array in a variable called myarray. The return value of the set function is the array.
(set 'myarray (array 3 4 (sequence 1 12)))
→ ((1 2 3 4) (5 6 7 8) (9 10 11 12))
[edit] OCaml
in the toplevel:
# Array.make 6 'A' ;;
- : char array = [|'A'; 'A'; 'A'; 'A'; 'A'; 'A'|]
# Array.init 8 (fun i -> i * 10) ;;
- : int array = [|0; 10; 20; 30; 40; 50; 60; 70|]
# let arr = [|0; 1; 2; 3; 4; 5; 6 |] ;;
val arr : int array = [|0; 1; 2; 3; 4; 5; 6|]
# arr.(4) ;;
- : int = 4
# arr.(4) <- 65 ;;
- : unit = ()
# arr ;;
- : int array = [|0; 1; 2; 3; 65; 5; 6|]
[edit] Oz
declare
Arr = {Array.new 1 %% lowest index
10 %% highest index
37} %% all 10 fields initialized to 37
in
{Show Arr.1}
Arr.1 := 64
{Show Arr.1}
[edit] Perl
Dynamic
my @arr;
push @arr, 1;
push @arr, 3;
$arr[0] = 2;
print $arr[0];
[edit] Perl 6
Works with: Rakudo version #22 "Thousand Oaks"
my @arr;
push @arr, 1;
push @arr, 3;
@arr[0] = 2;
say @arr[0];
[edit] PHP
[edit] Writing To An Array
[edit] Single Dimension
$NumberArray = array(0, 1, 2, 3, 4, 5, 6);
$LetterArray = array("a", "b", "c", "d", "e", "f");
[edit] Multi-Dimensional
$MultiArray = array(
array(0, 0, 0, 0, 0, 0),
array(1, 1, 1, 1, 1, 1),
array(2, 2, 2, 2, 2, 2),
array(3, 3, 3, 3, 3, 3)
);
[edit] Reading From An Array
[edit] Single Dimension
Read the 5th value in the array:
echo $NumberArray[5]; // Returns 5
echo $LetterArray[5]; // Returns f
[edit] Multi-Dimensional
Read the 2nd line, column 5
echo $MultiArray[1][5]; // 2
[edit] Print a whole array
This is useful while developing to view the contents of an array:
print_r($MultiArray);
Which would give us:
Array(
0 => array(
0 => 0
1 => 0
2 => 0
3 => 0
4 => 0
5 => 0
)
1 => array(
0 => 1
1 => 1
2 => 1
3 => 1
4 => 1
5 => 1
)
2 => array(
0 => 2
1 => 2
2 => 2
3 => 2
4 => 2
5 => 2
)
3 => array(
0 => 3
1 => 3
2 => 3
3 => 3
4 => 3
5 => 3
)
)
[edit] Set custom keys for values
This example starts the indexing from 1 instead of 0
$StartIndexAtOne = array(1 => "A", "B", "C", "D");
This example shows how you can apply any key you want
$CustomKeyArray = array("d" => "A", "c" => "B", "b" =>"C", "a" =>"D");
To read the 3rd value of the second array:
echo $CustomKeyArray["b"]; // Returns C
[edit] Other Examples
Create a blank array:
$BlankArray = array();
Set a value for the next key in the array:
$BlankArray[] = "Not Blank Anymore";
Assign a value to a certain key:
$AssignArray["CertainKey"] = "Value";
[edit] PicoLisp
PicoLisp has no built-in array data type. Lists are used instead.
(setq A '((1 2 3) (a b c) ((d e) NIL 777))) # Create a 3x3 structure
(mapc println A) # Show it
Output:
(1 2 3) (a b c) ((d e) NIL 777)
Replace 'b' with 'B' in middle row:
(set (nth A 2 2) 'B)
(mapc println A)
Output:
(1 2 3) (a B c) ((d e) NIL 777)
Insert '1' in front of the middle row:
(push (cdr A) 1)
(mapc println A)
Output:
(1 2 3) (1 a B c) ((d e) NIL 777)
Append '9' to the middle row:
(queue (cdr A) 9)
(mapc println A)
Output:
(1 2 3) (1 a B c 9) ((d e) NIL 777)
[edit] Pike
int main(){
// Initial array, few random elements.
array arr = ({3,"hi",84.2});
arr += ({"adding","to","the","array"}); // Lets add some elements.
write(arr[5] + "\n"); // And finally print element 5.
}
[edit] PL/I
/* Example of an array having fixed dimensions */
declare A(10) float initial (1, 9, 4, 6, 7, 2, 5, 8, 3, 10);
A(6) = -45;
/* Example of an array having dynamic bounds. */
get list (N);
begin;
declare B(N) float initial (9, 4, 7, 3, 8, 11, 0, 5, 15, 6);
B(3) = -11;
end;
/* Example of a dynamic array. */
declare C(N) float controlled;
get list (N);
allocate C;
C = 0;
c(7) = 12;
[edit] PowerShell
Empty array:
$a = @()
Array initialized with only one member:
$a = ,2
$a = @(2) # alternative
Longer arrays can simply be created by separating the values with commas:
$a = 1,2,3
A value can be appended to an array using the += operator:
$a += 5
Since arrays are immutable this simply creates a new array containing one more member.
Values can be retrieved using a fairly standard indexing syntax:
$a[1]
Similarly, those values can also be replaced:
$a[1] = 42
The range operator .. can be used to create contiguous ranges of integers as arrays:
$r = 1..100
Indexing for retrieval allows for arrays as well, the following shows a fairly complex example combining two ranges and an arbitrary array in the indexer:
$r[0..9+25..27+80,85,90]
Indexing from the end of the array can be done with negative numbers:
$r[-1] # last index
[edit] Prolog
Works with: SWI Prolog
Prolog Terms can be abused as array structure. Using functor/3 to create arrays and arg/3 to nondestructively retrieve and set elements.
singleassignment:-
functor(Array,array,100), % create a term with 100 free Variables as arguments
% index of arguments start at 1
arg(1 ,Array,a), % put an a at position 1
arg(12,Array,b), % put an b at position 12
arg(1 ,Array,Value1), % get the value at position 1
print(Value1),nl, % will print Value1 and therefore a followed by a newline
arg(4 ,Array,Value2), % get the value at position 4 which is a free Variable
print(Value2),nl. % will print that it is a free Variable followed by a newline
To destructively set an array element, which is the "normal" way to set an element in most other programming languages, setarg/3 can be used.
destructive:-
functor(Array,array,100), % create a term with 100 free Variables as arguments
% index of arguments start at 1
setarg(1 ,Array,a), % put an a at position 1
setarg(12,Array,b), % put an b at position 12
setarg(1, Array,c), % overwrite value at position 1 with c
arg(1 ,Array,Value1), % get the value at position 1
print(Value1),nl. % will print Value1 and therefore c followed by a newline
Lists can be used as arrays.
listvariant:-
length(List,100), % create a list of length 100
nth1(1 ,List,a), % put an a at position 1 , nth1/3 uses indexing from 1, nth0/3 from 0
nth1(12,List,b), % put an b at position 3
append(List,[d],List2), % append an d at the end , List2 has 101 elements
length(Add,10), % create a new list of length 10
append(List2,Add,List3), % append 10 free variables to List2 , List3 now has 111 elements
nth1(1 ,List3,Value), % get the value at position 1
print(Value),nl. % will print out a
[edit] PureBasic
Dim is used to create new arrays and initiate each element will be zero. An array in PureBasic can be of any types, including structured, and user defined types. Once an array is defined it can be resized with ReDim. Arrays are dynamically allocated which means than a variable or an expression can be used to size them.
;Set up an Array of 23 cells, e.g. 0-22
Dim MyArray.i(22)
MyArray(0) = 7
MyArray(1) = 11
MyArray(7) = 23
ReDim is used to 'resize' an already declared array while preserving its content. The new size can be both larger or smaller, but the number of dimension of the array can not be changed after initial creation.
;Extend the Array above to 56 items without affecting the already stored data
ReDim MyArray(55)
MyArray(22) = 7
MyArray(33) = 11
MyArray(44) = 23
;Find all 6 non-zero cells from the Array above
For i=0 To ArraySize(MyArray())
If MyArray(i)
PrintN(Str(i)+" differs from zero.")
EndIf
Next
; Now, set up a multi dimensional Array
Dim MultiArray.i(800, 600)
MultiArray(100, 200) = 640
MultiArray(130, 40) = 120
Dim MultiArray2.i(64, 128, 32)
PrintN( Str(ArraySize(MultiArray2(), 2)) ; Will tell that second dimension size is '128'
[edit] Python
Python lists are dynamically resizeable.
array = []
array.append(1)
array.append(3)
array[0] = 2
print array[0]
A simple, single-dimensional array can also be initialized thus:
myArray = [0] * size
However this will not work as intended if one tries to generalize from the syntax:
myArray = [[0]* width] * height] # DOES NOT WORK AS INTENDED!!!
This creates a list of "height" number of references to one list object ... which is a list of width instances of the number zero. Due to the differing semantics of mutables (strings, numbers) and immutables (dictionaries, lists), a change to any one of the "rows" will affect the values in all of them. Thus we need to ensure that we initialize each row with a newly generated list.
To initialize a list of lists one could use a pair of nested list comprehensions like so:
myArray = [[0 for x in range(width)] for y in range(height)]
That is equivalent to:
myArray = list()
for x in range(height):
myArray.append([0] * width)
[edit] R
Dynamic
arr <- array(1)
arr <- append(arr,3)
arr[1] <- 2
print(arr[1])
[edit] REBOL
a: [] ; Empty.
b: ["foo"] ; Pre-initialized.
Inserting and appending.
append a ["up" "down"] ; -> ["up" "down"]
insert a [left right] ; -> [left right "up" "down"]
Getting specific values.
first a ; -> left
third a ; -> "up"
last a ; -> "down"
a/2 ; -> right (Note: REBOL is 1-based.)
Getting subsequences. REBOL allows relative motion through a block (list). The list variable returns the current position to the end of the list, you can even assign to it without destroying the list.
a ; -> [left right "up" "down"]
next a ; -> [right "up" "down"]
skip a 2 ; -> ["up" "down"]
a: next a ; -> [right "up" "down"]
head a ; -> [left right "up" "down"]
copy a ; -> [left right "up" "down"]
copy/part a 2 ; -> [left right]
copy/part skip a 2 2 ; -> ["up" "down"]
[edit] Ruby
Dynamic
# create an array with one object in it
a = ['foo']
# the Array#new method allows several additional ways to create arrays
# push objects into the array
a << 1 # ["foo", 1]
a.push(3,4,5) # ["foo", 1, 3, 4, 5]
# set the value at a specific index in the array
a[0] = 2 # [2, 1, 3, 4, 5]
# a couple of ways to set a slice of the array
a[0,3] = 'bar' # ["bar", 4, 5]
a[1..-1] = 'baz' # ["bar", "baz"]
a[0] = nil # [nil, "baz"]
a[0,1] = nil # ["baz"]
# retrieve an element
puts a[0]
[edit] Scala
val array = new Array[Int](10) //optionally, replace "new Array[Int](10)" with an initializing form such as "Array(1, 2, 3, 4)"
array(0) = 42
println(array(3))
Dynamic arrays can be made using ArrayBuffers:
val arraybuffer = new scala.collection.mutable.ArrayBuffer[Int]
arraybuffer += 5 //appends to the end of the list
arraybuffer.update(0, 6);//assigns the element at index 0
println(arraybuffer)
[edit] JavaScript
JavaScript arrays use the Array prototype, an Object that uses numerical indexes starting from 0 and knows its length.
var myArray = new Array();
var myArray1 = new Array(5); // gotcha: preallocated array with five empty elements, not [ 5 ].
var myArray2 = new Array("Item1","Item2");
var myArray3 = ["Item1", "Item2"]; // array literal
myArray[2] = 5;
var x = myArray[2] + myArray.length; // 8
[edit] Scheme
Lists are more often used in Scheme than vectors.
(let ((array #(1 2 3 4 5)) ; vector literal
(array2 (make-vector 5)) ; default nil
(array3 (make-vector 5 0))) ; default 0
(vector-set! array 0 3)
(vector-ref array 0)) ; 3
[edit] Slate
slate[1]> define: #x -> #(1 2 3).
{1. 2. 3}
slate[2]> x
{1. 2. 3}
slate[3]> define: #y -> {1 + 2. 3 + 4. 5}.
{3. 7. 5}
slate[4]> y at: 2 put: 99.
99
slate[5]> y
{3. 7. 99}
slate[6]> x first
1
slate[7]> x at: 0.
1
[edit] Tcl
Tcl's lists are really dynamic array values behind the scenes. (Note that Tcl uses the term “array” to refer to an associative collection of variables.)
set ary {}
lappend ary 1
lappend ary 3
lset ary 0 2
puts [lindex $ary 0]
Note also that serialization is automatic on treating as a string:
puts $ary; # Print the whole array
[edit] UNIX Shell
Bash ("sh" or "bash" on most Unix systems) supports one-dimensional arrays, which are zero-indexed. Zero-indexing means that if the array has five items in it, the first item is at index 0, and the last item is at index 4.
Two-dimensional arrays can be accomplished using shell functions applied to arrays of array names. Basically, hiding the indirection within the shell function invocation.
You can read detailed explanations on everything concerning arrays in Bash.
To create an array:
alist=( item1 item2 item3 ) # creates a 3 item array called "alist"
declare -a list2 # declare an empty list called "list2"
declare -a list3[0] # empty list called "list3"; the subscript is ignored
# create a 4 item list, with a specific order
list5=([3]=apple [2]=cherry [1]=banana [0]=strawberry)
To obtain the number of items in an array:
count=${#alist[*]}
echo "The number of items in alist is ${#alist[*]}"
To iterate up over the items in the array:
x=0
while [[ $x < ${#alist[*]} ]]; do
echo "Item $x = ${alist[$x]}"
: $((x++))
done
To iterate down over theitems in an array:
x=${#alist[*]} # start with the number of items in the array
while [[ $x > 0 ]]; do # while there are items left
: $((x--)) # decrement first, because indexing is zero-based
echo "Item $x = ${alist[$x]}" # show the current item
done
To append to an array, use the current number of items in the array as the next index:
alist[${#alist[*]}]=new_item
To make appending easier, use a little shell function, let's call it "push", and design it to allow appending multiple values, while also preserving quoted values:
# shell function to append values to an array
# push LIST VALUES ...
push() {
local var=${1:?'Missing variable name!'}
shift
eval "\$$var=( \"\${$var[@]}\" \"$@\" )"
}
push alist "one thing to add"
push alist many words to add
To delete a single array item, the first item:
unset alist[0]
To delete and return the last item in an array (e.g., "pop" function):
# pop ARRAY -- pop the last item on ARRAY and output it
pop() {
local var=${1:?'Missing array name'}
local x ; eval "x=\${#$var[*]}"
if [[ $x > 0 ]]; then
local val ; eval "val=\"\${$var[$((--x))]}\""
unset $var[$x]
else
echo 1>&2 "No items in $var" ; exit 1
fi
echo "$val"
}
alist=(a b c)
pop alist
a
pop alist
b
pop alist
c
pop alist
No items in alist
To delete all the items in an array:
unset alist[*]
To delete the array itself (and all items in it, of course):
unset alist
