Arrays: Difference between revisions

This task is about arrays.

{{trans|Python}}

 

array.append(1)

array.append(3)

V width = 3

V height = 4

 

{{out}}

 

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

 

 

 

The base address can be offset by the value in a data register, to allow for assigning values to an array. The offset is always measured in bytes, so if your array is intended to contain a larger data size you will need to adjust it accordingly.

 

 

LEA myArray,A0 ;load the base address of the array into A0

LSL.W #2,D0 ;this array is intended for 32-bit values.

MOVE.L #23,D1 ;load decimal 23 into D1

 

This is the equivalent of the [[C]] code:

 

Loading an element is very similar to storing it.

 

 

;load element 4

MOVE.W #4,D0 ;load the desired offset into D0

LSL.W #2,D0 ;this array is intended for 32-bit values.

 

 

Inserting an element at a desired position is a bit more tricky. First of all, an array has no "end" in hardware. So how do you know where to stop? For this example, assume this array is currently contains 6 total elements (0,1,2,3,4,5) and we want to extend it.

 

 

;insert a new element into the 2nd slot and push everything behind it back.

MOVE.L (A0,D0),(4,A0,D0)

ADDA.L #4,A0

 

The use of the number 4 in <code>(4,A0,D0)</code> and <code>ADDA.L #4,A0</code> was because we were working with <code>MOVE.L</code> commands to store 32-bit values. If your data size was 16 bit you would replace the 4s with 2s, and if it was 8 bit you would use 1s.

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

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program areaString64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

 

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

BYTE i

 

PrintF("c(%B)=%B ",i,c(i))

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Arrays.png Screenshot from Atari 8-bit computer]

 

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

 

 

# retrieve an element

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

{{trans|Simula}}

comment arrays - Algol 60;

 

dynamic(5)

 

{{out}}

<pre>

 

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

% declare an array %

integer array a ( 1 :: 10 );

% as parameters to procedures %

% multi-dimension arrays are supported %

 

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

array[0] = 42;

Dynamic arrays can be made using <code>List</code>s. <code>List</code>s and array can be used interchangeably in Apex, e.g. any method that accepts a <code>List<String></code> will also accept a <code>String[]</code>

aList.add(5);// appends to the end of the list

aList.add(1, 6);// assigns the element at index 1

 

=={{header|APL}}==

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

 

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

=={{header|AppleScript}}==

AppleScript arrays are called lists:

 

Lists can contain any objects including other lists:

 

Items can be appended to the beginning or end of a list:

 

set beginning of any to false

set end of any to Wednesday

return any

 

Or a new list containing the items can be created through concatenation:

 

set any to false & any & Wednesday

 

However, this isn't usually as efficient and it's important to be aware of the coercion rules associated with AppleScript concatenations, which may lead to unexpected results!

List indices are 1-based and negative numbers can be used to index items from the end of the list instead of from the beginning. Items can be indexed individually or by range:

 

item -1 of any --> {1, 2, 3}

 

If required, items can be specified by class instead of the generic 'item' …

 

 

… and some fairly complex range specifiers are possible:

 

 

The length of a list can be determined in any of three ways, although only the first two below are now recommended:

 

length of any -- Property.

 

The number of items of a specific class can also be obtained:

 

 

A list's other properties are its <code>rest</code> (which is another list containing all the items except for the first) and its <code>reverse</code> (another list containing the items in reverse order).

Through AppleScriptObjC, AppleScript is also able to make use of Objective-C arrays and many of their methods, with bridging possible between lists and NSArrays:

 

use framework "Foundation" -- Allows access to NSArrays and other Foundation classes.

 

set myNSArray to current application's NSArray's arrayWithArray:myList -- Bridge the list to an NSArray.

set arrayLength to myNSArray's |count|() -- Get the array's length using its 'count' property.

 

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program areaString.s */

.Ls_magic_number_10: .word 0x66666667

 

 

=={{header|Arturo}}==

arrA: []

; retrieve an element at some index

{{out}}

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

Avail supports tuples as its primary ordered collection.

 

Tuple indices (officially referred to as "subscripts") are 1-based. One can provide an alternative if there is no element at a subscript using an else clause.

 

Tuples are immutable, however one can quickly create a new tuple with a specified element replaced.

 

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

Note: We need to use quotes in DATA

 

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

DATA "August", "September", "October", "November", "December"

PRINT dat$[i]

NEXT

 

 

2.) A modern BaCon approach to do arrays using strings

DECLARE A$[11] = {"January", "February", "March", "April", "May", \

"June", "July", "August", "September", "October", "November", "December"} TYPE STRING

INCR i

WEND

 

 

name this '''split.bac'''

 

SPLIT ARGUMENT$ BY " " TO TOK$ SIZE len_array

 

PRINT TOK$[i]

NEXT i

 

in the terminal

./split January February March April May June July August September October November December

 

Notes: if you want to take a string from the command line

 

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

20 LET A%(0) = -1

30 LET A%(11) = 1

 

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

same as Applesoft BASIC

 

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

myArray as (int) = (1, 2, 3) // Size based on initialization

fixedArray as (int) = array(int, 1) // Given size(1 in this case)

 

print myArray[0]

 

=={{header|BQN}}==

 

All arrays are variable length, and can contain any types of values.

arr ← 1‿2‿'a'‿+‿5

# General List Syntax:

 

# Modifying the array(↩):

⟨ 1 2 'a' + 5 ⟩

⟨ 1 2 'a' + 5 ⟩

+

 

[https://mlochbaum.github.io/BQN/try.html#code=IyBTdHJhbmRpbmc6CmFyciDihpAgMeKAvzLigL8nYSfigL8r4oC/NQojIEdlbmVyYWwgTGlzdCBTeW50YXg6CmFycjEg4oaQIOKfqDEsMiwnYScsKyw14p+pCuKAolNob3cgYXJyIOKJoSBhcnIxICMgYm90aCBhcnJheXMgYXJlIHRoZSBzYW1lLgrigKJTaG93IGFycgrigKJTaG93IGFycjEKCiMgVGFraW5nIG50aCBlbGVtZW50KOKKkSk6CuKAolNob3cgM+KKkWFycgoKIyBNb2RpZnlpbmcgdGhlIGFycmF5KOKGqSk6CmFyciDihqkgImhlbGxvIuKMvig04oq44oqRKSBhcnIK Try It Here!]

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

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

A Linked List for chars may be implemented like this:

#include <stdlib.h>

#include <stdio.h>

list->size = 0;

}

 

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

Example of array of 10 int types:

 

 

Example of array of 3 string types:

 

 

You can also declare the size of the array and initialize the values at the same time:

 

 

 

 

The following creates a 3x2 int matrix

 

As with the previous examples you can also initialize the values of the array, the only difference being each row in the matrix must be enclosed in its own braces.

 

 

or

 

 

 

array[0] = 1;

array[1] = 3;

 

 

Dynamic

 

using System.Collections.Generic;

 

list[0] = 2;

 

 

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

int array[0]; // instantiate int array

array << 1; // append item

[1,2,3,4,5,6,7] @=> array;

array.popBack(); // Pop last element

 

=={{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|Computer/zero Assembly}}==

===Fixed-length array===

We have finished iterating through the array when the next load instruction would be <tt>LDA ary+length(ary)</tt>.

ADD sum

STA sum

8

9

===Zero-terminated array===

BRZ done

 

9

10

 

=={{header|Crystal}}==

# create an array with one object in it

a = ["foo"]

%w(one two three) # => ["one", "two", "three"]

%i(one two three) # => [:one, :two, :three]

 

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

main(){

// Dart uses Lists which dynamically resize by default

}

 

{{out}}

<pre>

 

=={{header|DBL}}==

; Arrays for DBL version 4 by Dario B.

;

VNUM2(1:5*8)=

CLEAR VALP1(1:5*8),VALP2(1:5*10)

 

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

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

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

 

=={{header|Dragon}}==

array[0] = 42

 

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

 

var empty = []

var xs = [1, 2, 3]

//Access array elements

var x = xs[2]

 

=={{header|Déjà Vu}}==

In Déjà Vu, the relevant datatype is called list, which is basically a stack with random element access for getting and setting values.

local :l []

 

#this prints Boo

!print pop-from l

 

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

=={{header|EasyLang}}==

 

f[i] = i

.

print f[i]

 

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

array[0] := 1;

array[1] := 2;

Stack allocated array

stackAllocatedArray[0] := 1;

stackAllocatedArray[1] := 2;

Dynamic array

 

Printing an element

system'console.writeLine(stackAllocatedArray[1]);

 

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

=={{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 assignment (note that since Fortran 2003 array assignment also allocates or reallocates if necessary):

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"

 

 

 

'''[https://gambas-playground.proko.eu/?gist=5061d7f882a4768d212080e416c25e27 Click this link to run this code]'''

Dim sFixedArray As String[] = ["Rosetta", "code", "is", "a", "programming", "chrestomathy", "site"]

Dim sFixedArray1 As New String[10]

Print sFixedArray1[5] & sFixedArray1[6]

 

Output:

<pre>

 

=={{header|GAP}}==

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

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

Add(v, "added");

v;

 

=={{header|Genie}}==

/*

Arrays, in Genie

dyn.add(dyn[0]+dyn[1])

stdout.printf("dyn size: %d\n", dyn.size)

 

{{out}}

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

$array[] = 1;

echo $array[0];

 

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

let a[0] 123 # index starting at 0

let a[1] "test" # can hold different types

 

 

=={{header|HicEst}}==

 

Astat(2) = 2.22222222

 

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

 

=={{header|HolyC}}==

U8 array[10] = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10;

 

 

// Access an element

 

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

//Fixed-length arrays.

f $= array.integer[1]()

d[+] $= 2

print(d[1])

 

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

From Javascript, with the differences that Jsi treats ''typeof [elements]'' as "array", not "object".

// Create a new array with length 0

var myArray = new Array();

myArray3.length ==> 4

=!EXPECTEND!=

 

{{out}}

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

// Create a new array with length 0

{def myArray1 {A.new}}

 

and so on...

 

=={{header|lang5}}==

1 append

['foo 'bar] append

2 reshape

 

=={{header|langur}}==

Langur uses 1-based indexing.

 

val .a2 = series 4..10

val .a3 = .a1 ~ .a2

writeln ".a2[5; 0]: ", .a2[5; 0]

writeln ".a2[10; 0]: ", .a2[10; 0]

 

{{out}}

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

 

Like everything in Latitude, arrays are simply objects. In particular, arrays store their elements in numerical slots rather than traditional symbolic ones. The translation scheme used to store them enables constant-time push and pop operations on either side of the array.

foo := [1, 2, 3].

 

println: foo popBack. ;; 3

println: foo popFront. ;; "front"

 

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

For filter and foreach, the VARNAME fields are optional, LIL creates defaults inside the code block of '''x''' for filter and '''i''' for foreach if user names are not given.

 

set a [list abc def ghi]

set b [list 4 5 6]

append b [list 7 8 9]

print [count $b]

 

{{out}}

 

=={{header|Lingo}}==

put a[2] -- or: put a.getAt(2)

-- 2

a.sort()

put a

 

In addition to the 'list' type shown above, for arrays of bytes (i.e. integers between 0 and 255) there is also the bytearray data type:

 

put ba

-- <ByteArrayObject length = 2 ByteArray = 0xff, 0xff >

ba[1] = 5

put ba

 

=={{header|Lisaac}}==

a := ARRAY(INTEGER).create 0 to 9;

a.put 1 to 0;

a.put 3 to 1;

 

=={{header|Little}}==

Arrays in Little are list of values of the same type and they grow dynamically.

 

They are zero-indexed. You can use END to get the last element of an array:

puts(fruit[0]);

puts(fruit[1]);

puts(fruit[END]);

 

=={{header|Logo}}==

(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

 

=={{header|LOLCODE}}==

BTW declaring array

I HAS A array ITZ A BUKKIT

VISIBLE array'Z three

VISIBLE array'Z string

 

=={{header|LSE64}}==

0 array 5 [] ! # store 0 at the sixth cell in the array

 

=={{header|LSL}}==

LSL does not have Arrays, but it does have [http://wiki.secondlife.com/wiki/List lists] which can function similar to a one dimensional ArrayList in Java or C#.

default {

state_entry() {

llSay(0, "Deserialize a string CSV List\n(note that all elements are now string datatype)\nList=["+llList2CSV(lst)+"]\n");

}

{{out}}

<pre>

=={{header|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[1] = 1 -- Index starts with 1, not 0.

l[0] = 'zero' -- But you can use 0 if you want

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

 

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

We can copy multiple items from an array to another array (ore the same) with statement Stock. We can copy from memory to strings and place them to other address.

 

Module CheckArray {

\\ Array with parenthesis in name

}

CheckArray

===Passing Arrays By Reference===

By default arrays passed by value. Here in make() we read reference in a variable A, which interpreter put then pointer to array, so it is a kind of reference (like in C). Using & we have normal reference. A ++ operator in a pointer of array add one to each element.

Dim a(10)=1

Print a() ' 1 1 1 1 1 1 1 1 1 1

A++

End Sub

 

=={{header|Maple}}==

a := Array (1..5);

a := [ 0 0 0 0 0 ]

a := [ 9 2 3 4 5 6 ]

a[7] := 7;

 

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

a[[1]]

{{out}}

<pre>{Sin[1],Sin[2],Sin[3],Sin[4],Sin[5],Sin[6],Sin[7],Sin[8],Sin[9],Sin[10]}

Variables are not typed until they are initialized. So, if you want to create an array you simply assign a variable name the value of an array. Also, memory is managed by MATLAB so an array can be expanded, resized, and have elements deleted without the user dealing with memory. Array elements can be retrieved in two ways. The first way is to input the row and column indicies of the desired elements. The second way is to input the subscript of the array elements.

 

 

a =

 

2 35 10

 

=={{header|Maxima}}==

array(a, flonum, 20, 20, 3)$

 

 

listarray(b);

 

=={{header|Mercury}}==

Mercury's arrays are a mutable non-functional type, and therefore are slightly more troublesome than functional types to A) accept as parameters to predicates, and B) involve in higher-order code, and C) include as a member of a composite data type. All of this is still very possible, but it requires an understanding of Mercury's variable instantiation system, as you can't just have 'in' and 'out' modes for parameters that involve arrays. Mercury has a 'bt_array' module with performance characteristics very similar to that of arrays, but which is a functional type and therefore is easier to work with. Especially if you're just starting out with Mercury, going with bt_array can be a big win for 'whippitupitude'.

 

:- interface.

:- import_module io.

else

true

 

=={{header|MiniScript}}==

 

Example:

print arr[0]

 

arr.push "x"

 

=={{header|MIPS Assembly}}==

.data

array: .word 1, 2, 3, 4, 5, 6, 7, 8, 9 # creates an array of 9 32 Bit words.

li $s1, 25

sw $s1, 4($s0) # writes $s1 (25) in the second array element

lw $s2, 20($s0) # $s2 now contains 6

li $v0, 10 # end program

syscall

 

=={{header|Modula-2}}==

 

=={{header|Modula-3}}==

Defines a static array of 10 elements, indexed 1 through 10.

 

Static arrays can also be given initial values:

 

Open (dynamic) arrays can be be defined by creating a reference to an array of an unspecified size:

Defines an open array of a currently unknown size.

 

Open arrays must first be initialized via a call to the built-in function NEW, passing in the type and the size of the array.

The allocation is performed on the heap and all elements are initialized to 0:

Initializes the open array to hold 10 elements, indexed 0 through 9. Modula-3 uses garbage collection for heap allocated data by default, so once all references to the open array go out of scope, the memory it occupied is de-allocated automatically.

 

Retrieval or insertion of elements and determining array bounds is performed using the same built-in functions regardless of the array kind. Though open arrays must first be de-referenced when passing them to such functions. Assuming we have made the declarations above, we can do the following:

staticArraySize := NUMBER(staticArray);

staticArrayElement := staticArray[4];

 

openArraySize := NUMBER(openArray^); (* Note the dereference. *)

 

 

=={{header|Monte}}==

 

 

To retrieve a value:

 

 

To change a value:

 

 

Now myArray is ['a','b','c','z'].

 

=={{header|Nanoquery}}==

arr = array(10)

 

 

// display the list

{{out}}

<pre>hello, world!

 

=={{header|Neko}}==

 

 

{{out}}

 

=={{header|Nemerle}}==

using System.Console;

using System.Collections;

foreach (i in dynamic) Write($"$i\t"); // Nemerle isn't great about displaying arrays, it's better with lists though

}

 

=={{header|NetRexx}}==

'''Note:''' Dynamic arrays can be simulated via the [[Java]] [http://download.oracle.com/javase/6/docs/technotes/guides/collections/index.html Collections Framework] or by using [[NetRexx]] ''indexed strings'' (AKA: [[Creating an Associative Array|associative arrays]]).

options replace format comments java crossref symbols nobinary

 

loop x_ = 1 to cymru[0] by 1

say x_':' cymru[x_]

 

{{out}}

=={{header|NewLISP}}==

This creates an array of 5 elements, initialized to <code>nil</code>:

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.

 

=={{header|Nim}}==

x = [1,2,3,4,5,6,7,8,9,10] # type and size automatically inferred

y: array[1..5, int] = [1,2,3,4,5] # starts at 1 instead of 0

a.add(200) # append another element

echo a.pop() # pop last item, removing and returning it

 

=={{header|NS-HUBASIC}}==

20 A(1)=10

 

=={{header|NSIS}}==

NSIS does not have native support for arrays. Array support is provided by the [http://nsis.sourceforge.net/Arrays_in_NSIS NSISArray] plugin.

</div>

!include NSISArray.nsh

Function ArrayTest

Pop $0

FunctionEnd

 

=={{header|Oberon-2}}==

MODULE Arrays;

IMPORT

Dynamic

END Arrays.

 

=={{header|Objeck}}==

bundle Default {

class Arithmetic {

}

}

 

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

 

// Create an array of NSString objects.

// No nil termination is then needed.

NSArray *thirdArray = @[ @"Hewey", @"Louie", @"Dewey", @1, @2, @3 ];

 

=={{header|OCaml}}==

in the toplevel:

- : char array = [|'A'; 'A'; 'A'; 'A'; 'A'; 'A'|]

 

 

# arr ;;

 

=={{header|Oforth}}==

To create a mutable array, #new is used.

 

 

Array new dup addAll( [1, 2, 3] ) dup put( 2, 8.1 ) .

 

{{out}}

The last element in a vector is indexed by minus one, and the first element is indexed by minus length of the vector.

 

; making a vector

> #(1 2 3 4 5)

[7 8 3]])

#false

 

=={{header|ooRexx}}==

ooRexx arrays hold object references. Arrays will automatically increase in size if needed.

b = .array~new(10) -- create an array with initial size of 10

c = .array~of(1, 2, 3) -- create a 3 element array holding objects 1, 2, and 3

a[3] = "Fred" -- assign an item

b[2] = a[3] -- retrieve an item from the array

 

ooRexx provides a built-in array class that provides one- and more dimensional arrays

to all compound variables with that stem.

 

XXX.='*'

Say 'xxx.1='xxx.1 -- shows xxx.1=*

xxx.u='Joe'

Say 'xxx.u='xxx.17 -- shows xxx.u=Joe

ooRexx introduces a notation a.[x,y] where x and y can actually be expressions.

 

must not exceed 250 bytes no longer applies to ooRexx and Regina.

XXX.u.v...='something'

v='John Doe'

XXX.u.v...='some value'

z='17.John Doe...'

 

When using a stem for storing structured data, as in

it is advisable to use constant symbols such as 0first and 0last in the tail

since an accidental use of the variables first or last would render confusion.

 

=={{header|OxygenBasic}}==

 

'CREATING A STATIC ARRAY

 

'SETTING INDEX BASE

 

'FILLING PART OF AN ARRAY

 

'MAPPING AN ARRAY TO ANOTHER

float *g

print g[6] 'result 12

 

'DYNAMIC (RESIZEABLE) ARRAYS

 

=={{header|Oz}}==

 

Arr = {Array.new 1 %% lowest index

10 %% highest index

{Show Arr.1}

Arr.1 := 64

 

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

v=concat(v,7);

 

=={{header|Pascal}}==

A modification of the Delphi example:

Program ArrayDemo;

uses

writeln(DynamicArrayText);

end.

 

=={{header|Perl}}==

In-line

 

my @empty_too = ();

my $aref = ['This', 'That', 'And', 'The', 'Other'];

print $aref->[2]; # And

 

Dynamic

 

 

push @arr, 1;

$arr[0] = 2;

 

 

Two-dimensional

 

[0, 1, 2, 3],

[qw(a b c d e f g)],

[qw(! $ % & *)],

);

 

=={{header|Phix}}==

without any need to worry about memory management issues.

 

<span style="color: #000080;font-style:italic;">-- simple one-dimensional arrays:</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">s1</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">0.5</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">4.7</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">9</span><span style="color: #0000FF;">},</span> <span style="color: #000080;font-style:italic;">-- length(s1) is now 4</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">s1</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">s2</span>

 

{{out}}

 

=={{header|Phixmonti}}==

 

0 tolist /# create an empty array/list. '( )' is equivalent #/

3 2 slice /# extract the subarray/sublist [ 2 "Hello" ] #/

 

 

=={{header|PHP}}==

===Writing To An Array===

====Single Dimension====

$LetterArray = array("a", "b", "c", "d", "e", "f");

 

====Multi-Dimensional====

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)

 

====Array push====

 

array_push($arr, 'pear');

 

===Reading From An Array===

====Single Dimension====

Read the 5th value in the array:

====Multi-Dimensional====

Read the 2nd line, column 5

===Print a whole array===

This is useful while developing to view the contents of an array:

Which would give us:

0 => array(

0 => 0

5 => 3

)

=== Set custom keys for values===

This example starts the indexing from 1 instead of 0

This example shows how you can apply any key you want

 

To read the 3rd value of the second array:

 

===Other Examples===

Create a blank array:

 

Set a value for the next key in the array:

 

Assign a value to a certain key:

 

=={{header|Picat}}==

 

Here are some examples how to use arrays.

 

go =>

 

nl.

 

{{out}}

 

{{trans|Prolog}}

List = new_list(5), % create a list of length 5

nth(1,List,a), % put an a at position 1 , nth/3 uses indexing from 1

Value = List3[1], % get the value at position 1

println(value=Value). % will print out a

 

{{out}}

=={{header|PicoLisp}}==

PicoLisp has no built-in array data type. Lists are used instead.

{{out}}

<pre>(1 2 3)

((d e) NIL 777)</pre>

Replace 'b' with 'B' in middle row:

{{out}}

<pre>(1 2 3)

((d e) NIL 777)</pre>

Insert '1' in front of the middle row:

{{out}}

<pre>(1 2 3)

((d e) NIL 777)</pre>

Append '9' to the middle row:

{{out}}

<pre>(1 2 3)

 

=={{header|Pike}}==

// Initial array, few random elements.

array arr = ({3,"hi",84.2});

 

write(arr[5] + "\n"); // And finally print element 5.

 

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

declare A(10) float initial (1, 9, 4, 6, 7, 2, 5, 8, 3, 10);

 

C = 0;

c(7) = 12;

 

=={{header|Plain English}}==

Arrays are a bit of a sticking point for Plain English, because its creators have not as yet devised a sufficiently elegant way to work with them within the constraints of the language. Only lists have high-level routine support. Nevertheless, the capability to build arrays ourselves exists within the language. Following is an example of how it could be done.

 

Start up.

Write "Creating an array of 100 numbers..." on the console.

Put the number array's first element pointer into a number pointer.

Add the offset to the number pointer.

{{out}}

<pre>

 

Arrays are homogenous.

 

- - -

Fact(s == 3) // size of array 'other' is 3

other(1) = 40 // 'other' now is [10, 40, 30]

 

=={{header|PostScript}}==

%Declaring array

 

 

x 1 get

 

=={{header|PowerShell}}==

Empty array:

Array initialized with only one member:

Longer arrays can simply be created by separating the values with commas:

A value can be appended to an array using the <code>+=</code> operator:

Since arrays are immutable this simply creates a new array containing one more member.

 

Values can be retrieved using a fairly standard indexing syntax:

Similarly, those values can also be replaced:

The range operator <code>..</code> can be used to create contiguous ranges of integers as arrays:

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:

Indexing from the end of the array can be done with negative numbers:

 

=={{header|Prolog}}==

retrieve and set elements.

 

singleassignment:-

functor(Array,array,100), % create a term with 100 free Variables as arguments

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

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 ,List3,Value), % get the value at position 1

print(Value),nl. % will print out a

 

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

 

Dim MyArray.i(22)

MyArray(0) = 7

MyArray(1) = 11

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

ReDim MyArray(55)

MyArray(22) = 7

MyArray(33) = 11

For i=0 To ArraySize(MyArray())

If MyArray(i)

PrintN(Str(i)+" differs from zero.")

EndIf

Dim MultiArray.i(800, 600)

MultiArray(100, 200) = 640

 

=={{header|Python}}==

Python lists are dynamically resizeable.

 

array.append(1)

array[0] = 2

 

 

A simple, single-dimensional array can also be initialized thus:

 

 

 

 

 

To initialize a list of lists one could use a pair of nested list comprehensions like so:

 

 

That is equivalent to:

 

for x in range(height):

 

To retrieve an element in an array, use any of the following methods:

 

# Retrieve an element directly from the array.

item = array[index]

# Use the array like a stack. Note that using the pop() method removes the element.

array.pop() # Pop last item in a list

 

# Using a negative element counts from the end of the list.

 

Python produces an IndexError when accessing elements out of range:

try:

# This will cause an exception, which will then be caught.

except IndexError as e:

# Print the exception.

 

=={{header|QB64}}==

'Task

'Show basic array syntax in your language.

 

 

 

=={{header|Quackery}}==

Dynamic

 

 

arr <- append(arr,3)

arr[1] <- 2

 

 

=={{header|Racket}}==

 

;; import dynamic arrays

(gvector-ref gv 0) ; 1

(gvector-add! gv 5) ; increase size

 

=={{header|Raku}}==

At its most basic, an array in Raku is quite similar to an array in Perl 5.

 

push @arr, 1;

@arr[0] = 2;

 

===Some further exposition:===

1..Inf # natural numbers

'a'..'z' # lowercase latin letters

 

'''Sequence''': Iterable list of objects with some method to determine the next (or previous) item in the list. Reified on demand. Will try to automatically deduce simple arithmetic or geometric sequences. Pass in a code object to calculate more complex sequences.

 

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

you can even assign to it without destroying the list.

 

a ; -> [left right "up" "down"]

next a ; -> [right "up" "down"]

copy/part a 2 ; -> [left right]

copy/part skip a 2 2 ; -> ["up" "down"]

 

=={{header|Red}}==

arr2: ["apple" "orange" 1 2 3] ;create an array with data

>> insert arr1 "blue"

== "black"

>> pick arr1 2

A vector! is a high-performance series! of items.

The items in a vector! must all have the same type.

The allowable item types are: integer! float! char! percent!

Vectors of string! are not allowed.

== make vector! [20 30 70]

>> vec1/2

*** Script Error: invalid argument: 3.0

*** Where: append

 

=={{header|ReScript}}==

 

 

let _ = Js.Array2.push(arr, 4)

arr[3] = 5

 

{{out}}

<pre>

Retro has a vocabulary for creating and working with arrays.

 

needs array'

 

( Create a quote from the values in an array )

d ^array'toQuote

 

=={{header|REXX}}==

 

===simple arrays===

a.='not found' /*value for all a.xxx (so far).*/

do j=1 to 100 /*start at 1, define 100 elements*/

say 'element 50 is:' a.50

say 'element 3000 is:' a.3000

{{out}}

<pre>

 

===simple arrays, mimic other languages===

a. = 'not found' /*value for all a.xxx (so far). */

do j=1 to 100 /*start at 1, define 100 elements*/

exit /*stick a fork in it, we're done.*/

/*──────────────────────────────────A subroutine────────────────────────*/

<pre>

element 50 is: -5000

 

===simple arrays, assigned default===

a. = 00 /*value for all a.xxx (so far). */

do j=1 to 100 /*start at 1, define 100 elements*/

exit /*stick a fork in it, we're done.*/

/*──────────────────────────────────A subroutine────────────────────────*/

{{out}}

<pre>

 

===arrays with non-unity index start===

array. = 'out of range' /*define ALL elements to this. */

 

say g "squared is:" array.g

say 7000 "squared is:" array.7000

{{out}}

<pre>

 

===arrays, disjoint===

yr. = 'year not supported' /*value for all yr.xxx (so far).*/

 

year=1744

say 'DOB' year "is:" yr.year

{{out}}

<pre>

 

===sparse arrays and special indices===

yyy = -55 /*REXX must use this mechanism···*/

a.yyy = 1e9 /*··· when assigning neg indices.*/

│ identify stemmed arrays (the period). │

└────────────────────────────────────────────────────────────────────┘*/

 

=={{header|Ring}}==

Dynamic

 

a = ['foo']

 

 

# retrieve an element

 

=={{header|RLaB}}==

// 1-D (row- or column-vectors)

// Static:

 

 

 

=={{header|Robotic}}==

Robotic does not natively support arrays of any kind.

However, using [https://www.digitalmzx.net/wiki/index.php?title=Counter_interpolation Counter Interpolation], we can create a simple (faux) array.

set "index" to 0

. "Assign random values to array"

* "Value of index 50 is ('array('50')')."

end

 

You can even create multi-dimensional arrays using the Counter Interpolation method.

set "xx" to 0

set "yy" to 0

* "Value of 16,16 is ('array('16'),('16')')."

end

 

Because arrays aren't built in, there are no functions that allow you to manipulate the data you create within an array. You would have to create your own function when, for example, you want to sort numbers from least to greatest.

{{works with|ILE RPG}}

 

//-Static array

//--def of 10 el array of integers, initialised to zeros

/end-free

 

=={{header|Ruby}}==

Dynamic

 

a = ['foo']

 

 

# retrieve an element

 

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

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

chrArray$(1,1) = "Hello"

numArray(1,1) = 987.2

 

=={{header|Rust}}==

By default, arrays are immutable unless defined otherwise.

 

let mut m = [1, 2, 3]; // mutable array

 

To get the length and iterate,

 

a.len();

for e in a.iter() {

e;

 

Accessing a particular element uses subscript notation, starting from 0.

 

 

Dynamic arrays in Rust are called vectors.

 

 

However, this defines an immutable vector. To add elements to a vector, we need to define v to be mutable.

 

v.push(4);

 

=={{header|Sather}}==

a :ARRAY{INT};

-- create an array of five "void" elements

b[1] := c; -- syntactic sugar for b.aset(1, c)

-- append another array

 

=={{header|Scala}}==

Arrays are not used often in Scala, since they are mutable and act differently to other collections with respect to type erasure, but are necessary for interoperability with Java. Alternatives such as List, Seq, and Vector are more commonly used.

val a = new Array[Int](10)

 

 

// Retrieve item at element 2

Dynamic arrays can be made using <code>ArrayBuffer</code>s:

a += 5 // Append value 5 to the end of the list

 

=={{header|Scheme}}==

Lists are more often used in Scheme than vectors.

 

(array2 (make-vector 5)) ; default is unspecified

(array3 (make-vector 5 0))) ; default 0

(vector-set! array 0 3)

 

=={{header|Scratch}}==

Every type, which can be mapped to integer, can be used as index type.

 

 

const type: charArray is array [char] string; # Define an array type for arrays with char index.

array1 := array3[2 len 4]; # Assign a slice of four elements beginning with the second element.

array1 := array3 & array6; # Concatenate two arrays and assign the result to array1.

 

=={{header|Self}}==

Creating simple vectors:

 

A polymorphic vector:

 

Using a vector:

"creates an vector that holds up to 20 elements"

v: vector copySize: 20.

(v at: 9) printLine.

"put 100 as second value"

 

Enumeration:

v copy mapBy: [:each | each squared].

 

Using a squence:

"creates a new sequence"

s: sequence copyRemoveAll.

s removeFirst.

"Check size"

 

=={{header|SenseTalk}}==

set a to (1, 2, 3)

 

// Changing the values in the array

set the third item of a to "abc"

 

=={{header|Sidef}}==

var arr = [];

 

 

# retrieve an element

 

=={{header|Simula}}==

PROCEDURE STATIC;

DYNAMIC(5)

END ARRAYS.

{{out}}

<pre>

</pre>

One can write an ArrayList class like Java has in package java.util.

 

CLASS ITEM;;

 

END;

{{out}}

<pre>EXPAND TO CAPACITY 20

 

=={{header|Slate}}==

{1. 2. 3}

slate[2]> x

1

slate[7]> x at: 0.