Arrays: Difference between revisions

This task is about arrays.

*   [[Two-dimensional array (runtime)]]

<br><br>

 

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

ARRAYS PROLOG

* we use TA array with 1 as origin. So TA(1) to TA(20)

J DC F'4'

YREGS

 

=={{header|8051 Assembly}}==

<li>In external RAM - element retrieval/altering is most efficiently done sequentially, necessary for large arrays or peripherals</ul>

Dynamic (resizable) arrays are possible to implement, but are error-prone since bounds checking must be done by the programmer.

myarray db 'Array' ; db = define bytes - initializes 5 bytes with values 41, 72, 72, etc. (the ascii characters A,r,r,a,y)

myarray2 dw 'A','r','r','a','y' ; dw = define words - initializes 5 words (1 word = 2 bytes) with values 41 00 , 72 00, 72 00, etc.

pop dph

 

 

=={{header|8th}}==

 

Arrays are declared using JSON syntax, and are dynamic (but not sparse)

[ 1 , 2 ,3 ] \ an array holding three numbers

1 a:@ \ this will be '2', the element at index 1

\ arrays don't have to be homogenous:

[1,"one", 2, "two"]

 

=={{header|ABAP}}==

There are no real arrays in ABAP but a construct called internal tables.

TYPES: tty_int TYPE STANDARD TABLE OF i

WITH NON-UNIQUE DEFAULT KEY.

cl_demo_output=>display( itab ).

cl_demo_output=>display( itab[ 2 ] ).

 

{{out}}

 

=={{header|ACL2}}==

(assign array-example

(compress1 'array-example

 

;; Get a[5]

 

=={{header|ActionScript}}==

var array1:Array = new Array(10);

//creates an array with the values 1, 2

array2.push(4);

//get and remove the last element of an array

=={{header|Ada}}==

 

 

-- Ada array indices may begin at any value, not just 0 or 1

 

-- Ada arrays may be indexed by enumerated types, which are

Centered : Arr (-50..50) := (0 => 1, Others => 0);

 

begin

 

A := (others => 0); -- Assign whole array

-- Assign whole array, different values

A (1) := -1; -- Assign individual element

A (3..5) := (2, 4, -1); -- Assign a constant slice

A (3..5) := A (4..6); -- It is OK to overlap slices when assigned

 

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.

 

=={{header|Aikido}}==

Aikido arrays (or vectors) are dynamic and not fixed in size. They can hold a set of any defined value.

var arr1 = [1,2,3,4] // initialize with array literal

var arr2 = new [10] // empty array of 10 elements (each element has value none)

var arr7 = arr1 & arr2 // intersection

 

 

=={{header|Aime}}==

The aime ''list'' is a heterogeneous, dynamic sequence. No special creation procedure, only declaration is needed:

Values (numbers, strings, collections, functions, etc) can be added in a type generic fashion:

l_append(l, "arrays");

The insertion position can be specified:

More aptly, values (of selected types) can be inserted in a type specific fashion:

Similarly, values can be retrieved in a type generic fashion:

or is type specific fashion:

 

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

(

[1:20]INT a;

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.

 

=={{header|AmigaE}}==

da: PTR TO CHAR,

la: PTR TO CHAR

-> "deallocating" the array

IF la <> NIL THEN END la[100]

 

=={{header|AntLang}}==

arr: <1;2;3>

 

 

/ Get the nth element (index origin = 0)

 

=={{header|APL}}==

Arrays in APL are one dimensional matrices, defined by seperating variables with spaces. For example:

 

=={{header|App Inventor}}==

All supported data types may be stored in a List.

[https://lh4.googleusercontent.com/-5y13nsUEj1U/UunGAhuqWEI/AAAAAAAAJ7U/i2IL5v6EQ5I/w631-h658-no/Capture.PNG Basic List blocks]

 

=={{header|AppleScript}}==

AppleScript arrays are called lists:

 

Lists can contain any objects including other lists:

 

=={{header|Arendelle}}==

=={{header|Argile}}==

{{works with|Argile|1.0.0}}

(:::::::::::::::::

DynArray[5] = 243

prints DynArray[0] DynArray[5]

 

{{works with|Argile|1.1.0}}

let x = @["foo" "bar" "123"]

print x[2]

 

 

=={{header|AutoHotkey}}==

{{works with|AutoHotkey_L}}

The current, official build of AutoHotkey is called AutoHotkey_L. In it, arrays are called Objects, and associative/index based work hand-in-hand.

myArray[1] := "foo"

myArray[2] := "bar"

 

; Push a value onto the array

AutoHotkey Basic (deprecated) did not have typical arrays.

However, variable names could be concatenated, simulating associative arrays.

By convention, based on built-in function stringsplit, indexes are 1-based and "0" index is the length.

arrayX1 = first

arrayX2 = second

StringSplit arrayX, source, %A_Space%

Loop, %arrayX0%

 

=={{header|AutoIt}}==

Create an userdefined array.

#include <Array.au3> ;Include extended Array functions (_ArrayDisplay)

 

 

_ArrayDisplay($aInputs) ;Display the Array

 

=={{header|AWK}}==

An ordered array just uses subscripts as integers. Array subscripts can start at 1, or any other integer. The built-in split() function makes arrays that start at 1.

 

# to make an array, assign elements to it

array[1] = "first"

print " " i ": " array[i]

}

 

{{out}}

 

=={{header|Axe}}==

2→{L₁+1}

3→{L₁+2}

Disp {L₁+1}►Dec,i

Disp {L₁+2}►Dec,i

 

=={{header|Babel}}==

There are two kinds of array in Babel: value-arrays and pointer-arrays. A value-array is a flat array of data words. A pointer-array is an array of pointers to other things (including value-arrays). You can create a data-array with plain square-brackets. You can create a value-array with the [ptr ] list form:

 

 

 

 

===Get a single array element===

 

 

{{Out}}

Changing a value-array element:

 

 

{{Out}}

Changing a pointer-array element:

 

 

{{Out}}

===Select a range of an array===

 

 

{{Out}}

You can concatenate arrays of same type:

 

 

 

Concatenation creates a new array - it does not add to an array in-place. Instead, Babel provides operators and standard utilities for converting an array to a list in order to manipulate it, and then convert back.

Convert a value-array to a list of values:

 

 

{{Out}}

Convert a list of values to a value-array:

 

 

{{Out}}

Convert a pointer-array to a list of pointers:

 

 

{{Out}}

Convert a list of pointers to a pointer-array:

 

 

{{Out}}

 

To learn more about manipulating arrays and lists in Babel, type "help !" (no quotes) and follow the instructions to load the man.sp file.

 

=={{header|BASIC}}==

 

The default array base (lower bound) can be set with OPTION BASE. If OPTION BASE is not set, the base may be either 0 or 1, depending on implementation. The value given in DIM statement is the upper bound. If the base is 0, then DIM a(100) will create an array containing 101 elements.

 

Alternatively, the lower and upper bounds can be given while defining the array:

 

Dynamic arrays:

'$DYNAMIC

DIM SHARED myArray(-10 TO 10, 10 TO 30) AS STRING

REDIM SHARED myArray(20, 20) AS STRING

myArray(1,1) = "Item1"

 

'''Array Initialization'''

BASIC does not generally have option for initializing arrays to other values, so the initializing is usually done at run time.

DATA and READ statements are often used for this purpose:

DATA January, February, March, April, May, June, July

DATA August, September, October, November, December

FOR m=1 TO 12

READ month$(m)

 

{{works with|FreeBASIC}}

 

FreeBASIC has an option to initialize array while declaring it.

 

20 REM ELEMENT NUMBERS TRADITIONALLY START AT ONE

30 DIM A%(11): REM ARRAY OF ELEVEN INTEGER ELEMENTS

50 LET A%(11) = 1

60 PRINT A%(1), A%(11)

 

{{works with|qbasic}}

===Static===

 

 

staticArray(0) = -1

staticArray(10) = 1

 

 

===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 (<code>DIM</code> vs. <code>REDIM</code>). [[QBasic]] lacks the <code>PRESERVE</code> keyword found in some modern BASICs; resizing an array without <code>PRESERVE</code> zeros the values.

 

 

dynamicArray(0) = -1

 

dynamicArray(20) = 1

 

=={{header|BASIC256}}==

dim numbers(10)

for t = 0 to 9

print numbers[t] + "=" + words$[t]

next t

 

=={{header|Batch File}}==

Arrays can be approximated, in a style similar to REXX

 

@echo off

setlocal ENABLEDELAYEDEXPANSION

echo %1 = %2

goto :eof

 

{{out}}

 

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

DIM array(6), array%(6), array$(6)

PRINT array(2) TAB(16) array(3) TAB(32) array(4)

PRINT array%(2) TAB(16) array%(3) TAB(32) array%(4)

 

=={{header|bc}}==

 

The following is a transcript of an interactive session:

g[3] = 42

/* Look at some other elements in g */

123

g[3]

 

=={{header|BML}}==

'''Note:''' Variables in BML can either be placed in a prefix group($, @, and &) or in the world. Placing variables in the world is not recommended since it can take large sums of memory when using said variable.

 

% Define an array(containing the numbers 1-3) named arr in the group $

in $ let arr hold 1 2 3

% There is no automatic garbage collection

delete $arr

 

=={{header|Bracmat}}==

To delete and array (and therefore the variable with the array's name), call <code>tbl</code> with a size <code>0</code>.

 

& 5:?(30$mytable)

& 9:?(31$mytable)

| out$"mytable is gone"

)

{{out}}

<pre>5

9

mytable is gone</pre>

 

=={{header|Brainf***}}==

Note that Brainf*** does not natively support arrays, this example creates something that's pretty close, with access of elements at each index, altering elements, and changing size of list at runtime.

 

===========[

ARRAY DATA STRUCTURE

return back by finding leftmost null then decrementing pointer

twice then decrement our NEWVALUE cell

 

=={{header|C}}==

Fixed size static array of integers with initialization:

 

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.

 

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.

float my2Dfloats[][3] = {

1.0, 2.0, 0.0,

5.0, 1.0, 3.0 };

 

When the size of the array is not known at compile time, arrays may be dynamically

allocated to the proper size. The <code>malloc()</code>, <code>calloc()</code> and <code>free()</code> functions require the header <code>stdlib.h</code>.

int *myArray = malloc(sizeof(int) * numElements); /* array of 10 integers */

if ( myArray != NULL ) /* check to ensure allocation succeeded. */

/* calloc() additionally pre-initializes to all zeros */

short *myShorts = calloc( numElements, sizeof(short)); /* array of 10 */

 

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:

 

And to retrieve it (e.g. for printing, provided that the <tt>stdio.h</tt> header was included for the printf function)

 

The <tt>array[index]</tt> syntax can be considered as a shortcut for <tt>*(index + array)</tt> and

thus the square brackets are a commutative binary operator:

printf("%d\n", *(array + index));

 

There's no bounds check on the indexes. Negative indexing can be implemented as in the following.

double *kernel = malloc(sizeof(double)*2*XSIZE+1);

if (kernel) {

free(kernel-XSIZE);

}

 

In C99, it is possible to declare arrays with a size that is only known at runtime (e.g. a number input by the user).

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. In C, arrays may be dynamically resized if they were allocated:

int *array = malloc (sizeof(int) * 20);

....

array = realloc(array, sizeof(int) * 40);

 

 

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

<code>std::vector<T></code> is a resizable array of <code>T</code> objects.

The memory for the array will be allocated from the heap (unless a custom allocator is used).

#include <vector>

 

demonstrate(fixed_size_array);

demonstrate(dynamic_array);

 

=={{header|Ceylon}}==

{{works with|Ceylon|1.3.0}}

 

ArrayList

list.push("hello again");

print(list);

 

=={{header|Clean}}==

===Lazy array===

Create a lazy array of strings using an array denotation.

Create a lazy array of floating point values by sharing a single element.

Create a lazy array of integers using an array (and also a list) comprehension.

===Strict array===

Create a strict array of integers.

===Unboxed array===

Create an unboxed array of characters, also known as <tt>String</tt>.

 

=={{header|Clipper}}==

Clipper arrays aren't divided to fixed-length and dynamic. Even if we declare it with a certain dimensions, it can be resized in the same way as it was created dynamically. The first position in an array is 1, not 0, as in some other languages.

Local arr1 := { { "NITEM","N",10,0 }, { "CONTENT","C",60,0} }

// Create an empty array

 

// Array can be dynamically resized:

Items, including nested arrays, can be added to existing array, deleted from it, assigned to it

Aadd( arr1, { "LBASE","L",1,0 } )

// Delete the first item of arr3, The size of arr3 remains the same, all items are shifted to one position, the last item is replaced by Nil:

ADel( arr1, 1 )

// Assigning a value to array item

Retrieve items of an array:

// The retrieved item can be nested array, in this case it isn't copied, the pointer to it is assigned

There is a set of functions to manage arrays in Clipper, including the following:

AFill( arr4, 0, 5, 20 )

//Copy 10 items from arr4 to arr3[2], starting from the first position:

//Duplicate the whole or nested array:

arr5 := AClone( arr1 )

 

=={{header|Clojure}}==

;is, instead clojure creates a new array with an added value using (conj...)

;in the example below the my-list does not change.

 

user=> (conj my-vec 300) ;adding to a vector always adds to the end of the vector

 

=={{header|COBOL}}==

In COBOL, arrays are called ''tables''. Also, indexes begin from 1.

PROGRAM-ID. arrays.

 

 

GOBACK

 

=={{header|CoffeeScript}}==

array1[0] = "Dillenidae"

array1[1] = "animus"

 

array2 = ["Cepphus", "excreta", "Gansu"]

 

=={{header|ColdFusion}}==

Creating a one-dimensional Array:

 

Creating a two-dimensional Array in CFScript:

arr2 = ArrayNew(2);

''ColdFusion Arrays are '''NOT''' zero-based, they begin at index '''1'''''

 

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

 

(setf (aref array 0) 1

(aref array 1) 3)

 

Dynamic

 

(vector-push-extend 1 array)

(vector-push-extend 3 array)

(setf (aref array 0) 2)

 

Creates a one-dimensional array of length 10. The initial contents are undefined.

Creates a two-dimensional array with dimensions 10x20.

<tt>make-array</tt> may be called with a number of optional arguments.

(make-array 20 :initial-element nil)

; Makes an integer array of 4 elements containing 1 2 3 and 4 initially which can be resized

 

=={{header|Component Pascal}}==

 

 

MODULE TestArray;

(* Implemented in BlackBox Component Builder *)

END DoTwoDim;

 

 

=={{header|D}}==

 

import std.stdio, core.stdc.stdlib;

writeln("D) Element 0: ", array4[0]);

writeln("D) Element 1: ", array4[1]);

{{out}}

<pre>A) Element 0: 1

D) Element 1: 3</pre>

One more kind of built-in array:

 

void main() {

writeln("E) Element 0: ", vector5.array[0]);

writeln("E) Element 1: ", vector5.array[1]);

{{out}}

<pre>E) Element 0: 1

 

=={{header|Dao}}==

a = [ 1, 2, 3 ] # a vector

b = [ 1, 2; 3, 4 ] # a 2X2 matrix

d = a[1]

e = b[0,1] # first row, second column

 

 

 

 

 

 

 

 

=={{header|Delphi}}==

This example creates a static and dynamic array, asks for a series of numbers storing them in the static one, puts in the dynamic one the numbers in reverse order, concatenates the number in two single string variables and display those strings in a popup window.

procedure TForm1.Button1Click(Sender: TObject);

var

StaticArrayText,

DynamicArrayText: string;

begin

// Setting the length of the dynamic array the same as the static one

SetLength(DynamicArray, Length(StaticArray));

// Asking random numbers storing into the static array

begin

InputBox('Random number',

'Enter a random number for position',

end;

// Storing entered numbers of the static array in reverse order into the dynamic

begin

end;

// Displaying both arrays (#13#10 = Carriage Return/Line Feed)

ShowMessage(StaticArrayText + #13#10 + DynamicArrayText);

 

=={{header|DWScript}}==

 

// dynamic array, extensible, this a reference type

var d : array of Integer;

// inline array constructor, works for both static and dynamic arrays

s := [1, 2, 3];

 

=={{header|E}}==

Literal lists are <code>ConstList</code>s.

 

# value: []

 

 

? numbers + [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:

 

# value: []

 

 

? numbers with= 2 # shorthand for same

 

FlexLists can be created explicitly, but are typically created by ''diverging'' another list. A ConstList can be gotten from a FlexList by ''snapshot''.

 

# value: [1, 2].diverge()

 

 

? flex.snapshot()

 

Creating a FlexList with a specific size, generic initial data, and a type restriction:

 

 

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.

 

=={{header|EGL}}==

 

'''Fixed-length array'''

array int[10]; //optionally, add a braced list of values. E.g. array int[10]{1, 2, 3};

array[1] = 42;

SysLib.writeStdout(array[1]);

{{out}}

<pre>

 

=={{header|Eiffel}}==

class

APPLICATION

my_static_array: ARRAY [STRING]

end

 

=={{header|Elena}}==

Static array

Generic array

Dynamic array

 

Printing an element

 

=={{header|Elixir}}==

The elixir language has array-like structures called ''tuples''. The values of tuples occur sequentially in memory, and can be of any type. Tuples are represented with curly braces:

 

 

Elements of tuples are indexed numerically, starting with zero.

 

elem(ret, 0) == :ok

put_elem(ret, 2, "pi") # => {:ok, "fun", "pi"}

 

Elements can be appended to tuples with <tt>Tuple.append/2</tt>, which returns a new tuple, without having modified the tuple given as an argument.

 

 

New tuple elements can be inserted with <tt>Tuple.insert/3</tt>, which returns a new tuple with the given value inserted at the indicated position in the tuple argument.

 

 

Elixir also has structures called ''lists'', which can contain values of any type, and are implemented as linked lists. Lists are represented with square brackets:

 

 

Lists can be indexed, appended, added, subtracted, and list elements can be replaced, updated, and deleted. In all cases, new lists are returned without affecting the list being operated on.

 

my_list ++ [4, :five] # => [1, :two, "three", 4, :five]

 

List.delete(my_list, :two) # => [1, "three"]

my_list -- ["three", 1] # => [:two]

 

Lists have a ''head'', being the first element, and a ''tail'', which are all the elements of the list following the head.

 

[:apple, :banana, :cherry]

iex(2)> hd(fruit)

true

iex(5)> tl(fruit) == [:banana, :cherry]

 

=={{header|Erlang}}==

%% Create a fixed-size array with entries 0-9 set to 'undefined'

A0 = array:new(10).

{'EXIT',{badarg,_}} = (catch array:set(18, true, A3)).

{'EXIT',{badarg,_}} = (catch array:get(18, A3)).

 

=={{header|ERRE}}==

 

=={{header|Euphoria}}==

--Arrays task for Rosetta Code wiki

--User:Lnettnay

end for

? dynarray

{{out}}

<pre>

{10,9,8,7,6,5,4,3,2,1,1,4,9,16,25,36,49,64,81,100}

</pre>

 

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

'''Fixed-length arrays:'''

val it : char [] = [|'A'; 'A'; 'A'; 'A'; 'A'; 'A'|]

> Array.init 8 (fun i -> i * 10) ;;

val it : unit = ()

> arr;;

 

'''Dynamic arrays:'''

 

If dynamic arrays are needed, it is possible to use the .NET class <code>System.Collections.Generic.List<'T></code> which is aliased as <code>Microsoft.FSharp.Collections.ResizeArray<'T></code>:

val arr : ResizeArray<int>

> arr.Add(42);;

Parameter name: index ...

> arr;;

 

=={{header|Factor}}==

 

Directly in the listener :

{

[ "The initial array: " write . ]

[ "Modified array: " write . ]

[ "The element we modified: " write [ 1 ] dip nth . ]

The initial array: { 1 2 3 }

Modified array: { 1 42 3 }

{ 1 "coucou" f [ ] }

Arrays of growable length are called Vectors.

{

[ "The initial vector: " write . ]

[ [ 42 ] dip push ]

[ "Modified vector: " write . ]

The initial vector: V{ 1 2 3 }

Modified vector: V{ 1 2 3 42 }

For example, a static array of 10 cells in the dictionary, 5 initialized and 5 uninitialized:

 

here constant MyArrayEnd

 

MyArray 7 cells + @ . \ 30

 

 

: array ( n -- )

create

5fillMyArray

.MyArray \ 1 2 3 4 5 0 30 0 0 0

: array create dup , dup cells here swap 0 fill cells allot ;

: [size] @ ;

5fillMyArray

.MyArray \ 1 2 3 4 5 0 30 0 0 0

 

=={{header|Fortran}}==

 

Basic array declaration:

Arrays are one-based. These declarations are equivalent:

Other bases can be used:

Arrays can have any type (intrinsic or user-defined), e.g.:

Multidimensional array declaration:

Allocatable array declaration:

Array allocation:

Array deallocation:

Array initialisation:

Constant array declaration:

Element assignment:

Array section assignment:

Element retrieval:

Array section retrieval:

Size retrieval:

Size along a single dimension retrieval:

Bounds retrieval:

Bounds of a multidimensional array retrieval:

 

=={{header|FreeBASIC}}==

 

'''The default lower bound is always 0'''

' compile with: FBC -s console -exx to have boundary checks.

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre> The first dimension has a lower bound of 1 and a upper bound of 2

=={{header|Frink}}==

In Frink, all arrays are dynamically resizable. Arrays can be created as literals or using <CODE>new array</CODE>

a = new array

a@0 = 10

 

b = [1, 2, 3]

 

=={{header|Futhark}}==

Multidimensional regular arrays are a built-in datatype in Futhark. They can be written as array literals:

 

[1, 2, 3]

 

Or created by an assortment of built-in functions:

 

replicate 5 3 == [3,3,3,3,3]

iota 5 = [0,1,2,3,4]

 

Uniqueness types are used to permit in-place updates without violating referential transparency. For example, we can write a function that writes an element to a specific index of an array as such:

 

fun update(as: *[]int, i: int, x: int): []int =

let as[i] = x

in x

 

Semantically the <code>update</code> function returns a new array, but the compiler is at liberty to re-use the memory where array <code>as</code> is stored, rather than create a copy as is normally needed in pure languages. Whenever the compiler encounters a call <code>update(as,i,x)</code>, it checks that the <code>as</code> is not used again. This prevents the in-place update from being observable, except through the return value of <code>modify</code>.

 

=={{header|Gambas}}==

In Gambas, there is no need to dimension arrays. The first element of an array is numbered zero, and the DIM statement is optional and can be omitted:

 

DIM mynumbers AS INTEGER[]

myfruits AS STRING[]

myfruits[0] = "apple"

myfruits[1] = "banana"

 

=={{header|GAP}}==

v := [ 10, 7, "bob", true, [ "inner", 5 ] ];

# [ 10, 7, "bob", true, [ "inner", 5 ] ]

Add(v, "added");

v;

 

=={{header|GML}}==

====Example of Fixed Length Array====

Array containing a space (" "), "A", "B", and "C":

array[1] = 'A'

array[2] = 'B'

 

====Example of Arbitrary Length Array====

Array containing the set of all natural numbers from 1 through k:

 

===2-Dimensional Array Examples===

====Example of Fixed Length Array====

Array containing the multiplication table of 1 through 4 by 1 through 3:

array[1,2] = 2

array[1,3] = 3

array[3,2] = 6

array[3,3] = 9

 

====Example of Arbitrary Length Array====

Array containing the multiplication table of 1 through k by 1 through h:

for(j = 1; j <= h; j += 1)

 

=={{header|Go}}==

 

import (

// the cap()=10 array is no longer referenced

// and would be garbage collected eventually.

{{out}}

<pre>len(a) = 5

In Golfscript, arrays are created writing their elements between []. Arrays can contain any kind of object. Once created, they are pushed on the stack, as any other object.

 

10,:a; # assign to a [0 1 2 3 4 5 6 7 8 9]

a 0= puts # pick element at index 0 (stack: 0)

a 10+puts # append 10 to the end of a

 

Append and prepend works for integers or arrays only, since only in these cases the result is coerced to an array.

=={{header|Groovy}}==

Arrays and lists are synonymous in Groovy. They can be initialized with a wide range of operations and Groovy enhancements to the Collection and List classes.

def a = [0] * 100 // list of 100 zeroes

def b = 1..9 // range notation

d.each { print "["; it.each { elt -> printf "%7.1f ", elt }; println "]" }

println()

 

{{out}}

 

Here is a more interesting example showing a function that creates and returns a square identity matrix of order N:

(1..n).collect { i -> (1..n).collect { j -> i==j ? 1.0 : 0.0 } }

 

Test program:

def i15 = identity(15)

 

i2.each { print "["; it.each { elt -> printf "%4.1f ", elt }; println "]" }

println()

 

{{out}}

Groovy, like every other C-derived language in the known universe, uses ZERO-based array/list indexing.

 

 

println strings

strings[10] = 'strawberries'

 

 

{{out}}

Negative indices are valid. They indicate indexing from the end of the list towards the start.

 

 

{{out}}

Groovy lists can be resequenced and subsequenced by providing lists or ranges of indices in place of a single index.

 

println strings[0..4]

 

{{out}}

Graphical User Interface Support Script does not have variables or array storage of its own. However, it can make use of installed applications, so it is possible to utilize an installed spreadsheet application to create and manipulate arrays. Here we assume that a spreadsheet is installed and create an array containing three names:

 

 

=={{header|GW-BASIC}}==

(GW-BASIC User's Guide)

 

20 DIM A(9) ' Array with size 10 (9 is maximum subscript), all elements are set to 0

30 FOR I = 0 TO 9

70 A(4) = 400 ' Set 4th element of array

80 PRINT A(4)

 

=={{header|Harbour}}==

Harbour arrays aren't divided to fixed-length and dynamic. Even if we declare it with a certain dimensions, it can be resized in the same way as it was created dynamically. The first position in an array is 1, not 0, as in some other languages.

local arr1 := { { "NITEM", "N", 10, 0 }, { "CONTENT", "C", 60, 0 } }

// Create an empty array

 

// Array can be dynamically resized:

Items, including nested arrays, can be added to existing array, deleted from it, assigned to it

AAdd( arr1, { "LBASE", "L", 1, 0 } )

// Delete the first item of arr3, The size of arr3 remains the same, all items are shifted to one position, the last item is replaced by Nil:

ADel( arr1, 1 )

// Assigning a value to array item

Retrieve items of an array:

// The retrieved item can be nested array, in this case it isn't copied, the pointer to it is assigned

There is a set of functions to manage arrays in Clipper, including the following:

AFill( arr4, 0, 5, 20 )

// Copy 10 items from arr4 to arr3[ 2 ], starting from the first position:

// Duplicate the whole or nested array:

arr5 := AClone( arr1 )

 

=={{header|Haskell}}==

You can read all about Haskell arrays [http://haskell.org/haskellwiki/Arrays here]. The following example is taken from that page:

 

main = do arr <- newArray (1,10) 37 :: IO (IOArray Int Int)

writeArray arr 1 64

b <- readArray arr 1

 

=={{header|HicEst}}==

 

Astat(2) = 2.22222222

 

ALIAS(Astat, n-1, last2ofAstat, 2)

 

 

==Icon and Unicon==

==={{header|Icon}}===

 

procedure main()

S := A[-8 -: -3] # S is [30, 40, 50]

S := A[-5 +: -3] # S is [30, 40, 50]

 

==={{header|Unicon}}===

This Icon solution works in Unicon.

# insert and delete work on lists allowing changes in the middle

# possibly others

{{improve|Unicon|Need code examples for these extensions}}

 

=={{header|Io}}==

foo at(1) println // bar

foo append("Foobarbaz")

foo println

 

<pre>Io> foo := list("foo", "bar", "baz")

=={{header|J}}==

In J, all data occurs in the form of rectangular (or generally [[wp:Hyperrectangle|orthotopic]]) arrays. This is true for both named and anonymous data.

1

NB. invoking any array produces that array as the result

Xbcde

fXhij

Because arrays are so important in J, a large portion of the language applies to this topic.

 

=={{header|Java}}==

=={{header|JavaScript}}==

JavaScript arrays are Objects that inherit from Array prototype and have a special length property that is always one higher than the highest non–negative integer index. Methods inherited from Array.prototype are mostly generic and can be applied to other objects with a suitable length property and numeric property names.

Note that if the Array constructor is provided with one argument, it is treated as specifying the length of the new array, if more than one argument is supplied, they are treated as members of the new array.

var myArray = new Array();

 

// Elisions are supported, but are buggy in some implementations

var y = [0,1,,]; // length 3, or 4 in buggy implementations

 

=={{header|jq}}==

jq arrays have the same syntax as JSON arrays, and there are similarities with Javascript arrays. For example, the index origin is 0; and if a is an array and if n is an integer less than the array's length, then a[n] is the n-th element. The length of any array, a, can be ascertained using the length filter: a|length.

 

[]

 

a[1:] # => [1,2,3,4]

a[2:4] # => [2,3]

 

=={{header|Julia}}==

Julia has both heterogeneous arrays and typed arrays.

#undef

#undef

in push! at array.jl:488

 

 

=={{header|KonsolScript}}==

Array:New array[3]:Number;

 

array[0] = 5; //assign value

Konsol:Log(array[0]) //retrieve value and display

 

=={{header|Kotlin}}==

var a = arrayOf(1, 2, 3, 4)

println(a.asList())

println(a.asList())

println(a.reversedArray().asList())

{{out}}

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

=={{header|LabVIEW}}==

{{VI snippet}}<br/>[[File:LabVIEW Arrays.png]]

 

=={{header|lang5}}==

1 append

['foo 'bar] append

2 reshape

 

=={{header|Lasso}}==

Lasso Array [http://lassoguide.com/operations/containers.html?#array] objects store zero or more elements and provide random access to those elements by position. Positions are 1-based integers. Lasso Arrays will grow as needed to accommodate new elements. Elements can be inserted and removed from arrays at any position. However, inserting an element anywhere but at the end of an array results in all subsequent elements being moved down.

 

local(array1) = array

 

// Insert item at specific position

 

=== Static Arrays ===

Lasso also supports Static Arrays[http://lassoguide.com/operations/containers.html#staticarray]. A Lasso staticarray is a container object that is not resizable. Staticarrays are created with a fixed size. Objects can be reassigned within the staticarray, but new positions cannot be added or removed.

 

local(mystaticArray) = staticarray('a','b','c','d','e')

 

 

// Create an empty static array with a length of 32

 

=={{header|LFE}}==

 

Using the LFE REPL, you can explore arrays in the following manner:

; Create a fixed-size array with entries 0-9 set to 'undefined'

> (set a0 (: array new 10))

in (array get 2)

 

 

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

DATA is READ into variables. It cannot be READ directly into arrays.

<br>To fill arrays with DATA items, first READ the item into a variable, then use that variable to fill an index of the array.

dim Array(10)

 

print Array( 0), Array( 10)

 

 

=={{header|Lisaac}}==