I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# Arrays

Arrays
You are encouraged to solve this task according to the task description, using any language you may know.

For hashes or associative arrays, please see Creating an Associative Array.

For a definition and in-depth discussion of what an array is, see Array.

Show basic array syntax in your language.

Basically, create an array, assign a value to it, and retrieve an element   (if available, show both fixed-length arrays and dynamic arrays, pushing a value into it).

Please discuss at Village Pump:   Arrays.

## 11l

Translation of: Python
`[Int] arrayarray.append(1)array.append(3)array[0] = 2print(array[0])  // retrieve first element in an arrayprint(array.last) // retrieve last element in an arrayprint(array.pop())  // pop last item in an arrayprint(array.pop(0)) // pop first item in an array V size = 10V myArray = [0] * size // create single-dimensional arrayV width = 3V height = 4V myArray2 = [[0] * width] * height // create array of arrays`
Output:
```2
3
3
2
```

## 360 Assembly

`*        Arrays                    04/09/2015ARRAYS   PROLOG*        we use TA array with 1 as origin. So TA(1) to TA(20)*        ta(i)=ta(j)         L      R1,J               j         BCTR   R1,0               -1         SLA    R1,2               r1=(j-1)*4  (*4 by shift left)         L      R0,TA(R1)          load r0 with ta(j)         L      R1,I               i         BCTR   R1,0               -1         SLA    R1,2               r1=(i-1)*4  (*4 by shift left)         ST     R0,TA(R1)          store r0 to ta(i)         EPILOG* Array of 20 integers (32 bits) (4 bytes)TA       DS     20F* Initialized array of 10 integers (32 bits)TB       DC     10F'0'* Initialized array of 10 integers (32 bits)TC       DC     F'1',F'2',F'3',F'4',F'5',F'6',F'7',F'8',F'9',F'10'* Array of 10 integers (16 bits)TD       DS     10H* Array of 10 strings of 8 characters (initialized)TE       DC     10CL8' '* Array of 10 double precision floating point reals (64 bits)TF       DS     10D*I        DC     F'2'J        DC     F'4'         YREGS         END    ARRAYS`

## 6502 Assembly

### One-Dimensional Arrays

An array is little more than just a contiguous section of memory. Whether or not an array is mutable depends solely on whether it is defined in ROM or RAM. The syntax will be discussed in further detail in the Two-Dimensional Arrays section.

`Array:db 5,10,15,20,25,30,35,40,45,50`

Side note: Some systems, such as the Nintendo Entertainment System or other ROM cartridge-based computers, cannot use the above declaration to initialize an array in RAM at assemble time; only in ROM. While the label "Array" can be given to an arbitrary RAM location on any system, you won't be able to define a data block in RAM the same way you would on an assembly program meant to run on the Apple II or Commodore 64 for example. The examples below will still work on any system, you just won't be able to "see" the array before running the program, if that makes sense. Clearing the system ram will suffice to initialize the array to zero.

Looking up a value in an array is fairly straightforward. The best addressing modes for doing so are `LDA \$????,x`,`LDA \$????,y`, and `LDA (\$??),y`. In this case, x or y represents the index into the array. To put it in terms of C:

` char foo(){char array[5] = {3,6,9,12,15};return array[2];}`

would (theoretically) compile to the following in 6502 Assembly:

` foo:          LDX #2        ;load the desired indexLDA array,x   ;load the second (zero-indexed) entry in array, i.e. 9RTS           ;return. The return value is stored in A. array:        ;this is the array we're reading from.db 3,6,9,12,15`

### Arrays in the Zero Page - A Word of Warning

One important thing to note is a hardware bug involving `LDA \$??,x`. If the sum of \$?? and x would exceed 255, instead of continuing past \$100, the CPU will actually wrap around back to \$00. This does not happen with absolute addressing modes or indexed indirect with Y. Here's an example:

`LDX #\$80LDA \$80,x   ;evaluates to LDA \$00LDA \$0480,x ;evaluates to LDA \$0500`

If you really want to read from an array in the zero page like this (and chances are you won't since that array also starts to overlap with the hardware stack), you can use an absolute addressing mode in the zero page. Beware - some assemblers will forcibly optimize `LDA \$00??` into `LDA \$??` so you may have to inline the bytecode for it directly. If you stick to arrays outsize the zero page you don't need to worry about index wraparound.

### Arrays of 16-Bit Data

You can have arrays of 16-bit data as well as 8-bit ones. There are a few ways to do this, and we'll go over the "naive" way first:

`wordArray:dw \$ABCD,\$BEEF,\$CAFE,\$DADA`

The 6502 is little-endian, so the above would be exactly the same as the following:

`wordArray:db \$CD,\$AB,\$EF,\$BE,\$FE,\$CA,\$DA,\$DA`

To properly index a 16-bit array that's formatted as in the above example, you'll need to double your index. In this example, we'll be loading the offset of `\$BEEF`:

`LDX #2            ;load the 1st (zero-indexed) WORD from the array (which is why this is 2 not 1)LDA wordArray,X   ;evaluates to LDA #\$EFSTA \$00           ;store in a zero page temporary variableINX               ;point X to the high byteLDA wordArray,X   ;evaluates to LDA #\$BESTA \$01           ;store in a different zero page temporary variable. If your word data is a pointer you want to dereference,                   ;you'll need to store the low byte in \$nn and the high byte in \$nn+1 like I did here.`

There are a few downsides in 6502 assembly to storing word data in this format. A minor one is the need to double your index. This isn't a big deal, it doesn't take long to do that. The bigger problem is that the 6502 has a soft array length cap of 256 bytes. If your code is running in ROM and you're not able to use self-modifying code to adjust the base address, or you're not willing to use the slower `LDA (\$??),y`, you're mostly limited to 256 bytes or 128 words.

However, if you split the word table into two byte tables, you can actually get more bang for your buck, and it takes the same amount of memory no matter which way you store the data.

`wordArray_Lo:db \$CD,\$EF,\$FE,\$DA wordArray_Hi:db \$AB,\$BE,\$CA,\$DA    ;both this version and the above versions are 8 bytes of memory.`

If both wordArray_Lo and wordArray_Hi were 256 bytes each, you'd be able to index both of them no problem, where you wouldn't be able to do that if it were one array. Let's try loading `\$BEEF` again:

`LDX #1               ;with split arrays we DON'T need to double our index.LDA wordArray_Lo,x   ;evaluates to LDA #\$EFSTA \$00LDA wordArray_Hi,x   ;evaluates to LDA #\$BESTA \$01`

Both tables share the same index, which means you can do the lookup without destroying your index (not that it was that difficult to retrieve the original index to begin with), but on 8-bit computers you want to be as efficient as possible, using the hardware's strengths to your advantage. Splitting your "wider" arrays into multiple 8-bit tables is often the best approach.

### Two-Dimensional Arrays

I'll let you in on a little secret: two-dimensional arrays don't exist. This is just as true for modern computers as it is the 6502. In the first section I had this example of an array:

`Array:db 5,10,15,20,25,30,35,40,45,50`

In the eyes of the CPU, this is the same as ANY of the following:

`Array:db 5db 10db 15db 20db 25db 30db 35db 40db 45db 50`
`Array:db 5,10db 15,20db 25,30db 35,40db 45,50`

or any other way to write it you can imagine. All that matters is the order of the bytes in the array - as long as that is the same you can write it however you want. It's best to write it in the way it's meant to be interpreted, however. But in order to explain that to the computer you'll need a little bit of finesse. Let's pretend that the "correct" interpretation is this 5 by 2 array:

`Array:db 5,10db 15,20db 25,30db 35,40db 45,50`

For this example, we want row 3 and column 1 (zero-indexed for both) which means we want to load 40.

` LDA #3       ;desired rowASL A        ;Times 2 bytes per row (if the array's row size wasn't a multiple of 2 we'd need to actually do multiplication)             ;which the 6502 doesn't have in hardware but can be simulated by repeated adding.CLCADC #1       ;desired column (since it's 1 byte per column, we can skip the part where we multiply desired column by bytes per column)TAX          ;move A to X so we can use it as the index LDA Array,x  ;evaluates to LDA #40`

You may be wondering, why not just treat the array as though it were one-dimensional? Reason is, you won't always know in advance what you want from your array, it may depend on 2 variables in your program (such as X/Y coordinates, etc.), so you might need to use this method rather than just treating it as linear data.

## 68000 Assembly

Creating an array is as simple as declaring its base address. Note that all bounds checking must be done by the programmer and is not built in by default. You also will need to have some sort of knowledge about what is stored nearby, so that you don't clobber it.

`MOVE.L #\$00100000,A0      ;define an array at memory address \$100000`

Defining an array in ROM (or RAM if you're making a program that is loaded from disk) is very simple:

`;8-bit dataMyArray:DC.B 1,2,3,4,5DC.B 6,7,8,9,10DC.B 11,12,13,14,15EVEN ;needed to ensure proper alignment after a byte array with an odd number of entries. ;16-bit dataMyArrayW:DC.W 1,2,3,4,5DC.W 6,7,8,9,10DC.W 11,12,13,14,15 ;32-bit dataMyArrayL:DC.L 1,2,3,4,5DC.L 6,7,8,9,10DC.L 11,12,13,14,15 `

Strings are also arrays and most assemblers accept single or double quotes. The following are equivalent:

`MyString:DC.B "Hello World",0even MyString2:DC.B 'H','e','l','l','o',' ','W','o','r','l','d',0even`

The assembler will automatically substitute each letter with its ASCII equivalent. Notice the lack of quotes around the null terminator 0. If it had quotes, it would be assembled as 0x30 instead of 0. Not good if your printing routine expects a 0 as the terminator byte.

The above declarations are useful as compile-time constants or mutable pre-loaded values. Whether an array is mutable or not depends solely on whether it is stored in ROM or RAM.

Side note: Some systems, such as the Sega Genesis or other ROM cartridge-based computers, cannot use the above declaration to initialize an array in RAM at assemble time; only in ROM. While an array can be declared at any arbitrary RAM location on any system, you won't be able to define a data block in RAM the same way you would on an assembly program meant to run on the Macintosh or Commodore Amiga for example. The examples below will still work on any system, you just won't be able to "see" the array before running the program, if that makes sense. A simple alternative can be to define the array in ROM then copy it to RAM and work with it there.

The data type associated with the elements of an array is determined by the move operation used to assign elements to an array. The language does not prohibit you from storing 8-bit data into an array intended for 32-bit values.

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.

`myArray equ \$240000 LEA myArray,A0     ;load the base address of the array into A0MOVE.W #3,D0       ;load the desired offset into D0LSL.W #2,D0        ;this array is intended for 32-bit values.MOVE.L #23,D1      ;load decimal 23 into D1MOVE.L D1,(A0,D0)  ;store #23 into the 3rd slot of the array (arrays are zero-indexed in assembly)`

This is the equivalent of the C code:

`int myArray[];myArray[3] = 23;`

`myArray equ \$240000 ;load element 4LEA myArray,A0     ;load the base address of the array into A0MOVE.W #4,D0       ;load the desired offset into D0LSL.W #2,D0        ;this array is intended for 32-bit values.MOVE.L (A0,D0),D1  ;load the 4th element into D1.`

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.

`myArray equ \$240000 ;insert a new element into the 2nd slot and push everything behind it back. LEA myArray,A0     ;load the base address of the array into A0MOVE.W #2,D0       ;offset into 2nd slotLSL.W #2,D0        ;this array is intended for 32-bit values.MOVE.L #46,D1      ;this is our new element.   MOVE.L (A0,D0),(4,A0,D0) ;store the 2nd element into the 3rd slotADDA.L #4,A0             ;increment to next slot.MOVE.L (A0,D0),(4,A0,D0) ;store the 3nd element into the 4th slotADDA.L #4,A0             ;increment to next slot.MOVE.L (A0,D0),(4,A0,D0) ;store the 4th element into the 5th slotADDA.L #4,A0             ;increment to next slot.MOVE.L (A0,D0),(4,A0,D0) ;store the 5th element into the 6th slot LEA myArray,A0           ;restore the base addressMOVE.L D1,(A0,D0)        ;store the new 2nd element over the 2nd slot. ;for a larger array we can use the following loop:MOVE.W #3,D2       ;array length minus starting offset minus 1 LOOP:MOVE.L (A0,D0),(4,A0,D0)ADDA.L #4,A0DBRA D2,LOOP`

The use of the number 4 in `(4,A0,D0)` and `ADDA.L #4,A0` was because we were working with `MOVE.L` 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.

## 8051 Assembly

There are three types of fixed-length arrays:
• In the code segment - array elements are constant; good for strings, elements are easily indexed
• In internal RAM - good for small arrays; elements are easily indexed
• In external RAM - element retrieval/altering is most efficiently done sequentially, necessary for large arrays or peripherals

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

`; constant array (elements are unchangeable) - the array is stored in the CODE segmentmyarray 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.; how to read index a of the array        push acc        push dph        push dpl        mov dpl,#low(myarray) ; location of array        mov dph,#high(myarray)        movc a,@a+dptr	; a = element a        mov r0, a	; r0 = element a        pop dpl        pop dph        pop acc		; a = original index again ; array stored in internal RAM (A_START is the first register of the array, A_END is the last); initalise array data (with 0's)	push 0	mov r0, #A_STARTclear:	mov @r0, #0	inc r0	cjne r0, #A_END, clear	pop 0; how to read index r1 of array	push psw	mov a, #A_START	add a, r1	; a = memory location of element r1	push 0	mov r0, a	mov a, @r0	; a = element r1	pop 0	pop psw; how to write value of acc into index r1 of array	push psw	push 0	push acc	mov a, #A_START	add a, r1	mov r0, a	pop acc	mov @r0, a	; element r1 = a	pop 0	pop psw ; array stored in external RAM (A_START is the first memory location of the array, LEN is the length); initalise array data (with 0's)	push dph	push dpl	push acc	push 0	mov dptr, #A_START	clr a	mov r0, #LENclear:	movx @dptr, a	inc dptr	djnz r0, clear	pop 0	pop acc	pop dpl	pop dph; how to read index r1 of array	push dph	push dpl	push 0	mov dptr, #A_START-1	mov r0, r1	inc r0loop:	inc dptr	djnz r0, loop	movx a, @dptr	; a = element r1	pop 0	pop dpl	pop dph; how to write value of acc into index r1 of array	push dph	push dpl	push 0	mov dptr, #A_START-1	mov r0, r1	inc r0loop:	inc dptr	djnz r0, loop	movx @dptr, a	; element r1 = a	pop 0	pop dpl	pop dph  `

## 8th

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

` [ 1 , 2  ,3 ] \ an array holding three numbers1 a:@       \ this will be '2', the element at index 1drop1 123 a:@ \ this will store the value '123' at index 1, so now.              \ will print [1,123,3] [1,2,3] 45 a:push\ gives us [1,2,3,45]\ and empty spots are filled with null:[1,2,3] 5 15 a:!\ gives [1,2,3,null,15] \ arrays don't have to be homogenous:[1,"one", 2, "two"] `

## AArch64 Assembly

Works with: as version Raspberry Pi 3B version Buster 64 bits
` /* ARM assembly AARCH64 Raspberry PI 3B *//*  program areaString64.s   */ /*******************************************//* Constantes file                         *//*******************************************//* for this file see task include a file in language AArch64 assembly*/.include "../includeConstantesARM64.inc"/*******************************************//* Initialized data                        *//*******************************************/.dataszMessStringsch:   .ascii "The string is at item : @ \n"szCarriageReturn:  .asciz "\n"szMessStringNfound: .asciz "The string is not found in this area.\n" /* areas strings  */szString1:  .asciz "Apples"szString2:  .asciz "Oranges"szString3:  .asciz "Pommes"szString4:  .asciz "Raisins"szString5:  .asciz "Abricots" /* pointer items area 1*/tablesPoi1:pt1_1:        .quad szString1pt1_2:        .quad szString2pt1_3:        .quad szString3pt1_4:        .quad szString4ptVoid_1:     .quad 0ptVoid_2:     .quad 0ptVoid_3:     .quad 0ptVoid_4:     .quad 0ptVoid_5:     .quad 0 szStringSch:  .asciz "Raisins"szStringSch1: .asciz "Ananas"/*******************************************//* UnInitialized data                      *//*******************************************/.bsssZoneConv:       .skip 30/*******************************************//*  code section                           *//*******************************************/.text.global main main:                      // entry of program                            // add string 5 to area    ldr x1,qAdrtablesPoi1  // begin pointer area 1    mov x0,0               // counter1:                         // search first void pointer    ldr x2,[x1,x0,lsl 3]   // read string pointer address item x0 (4 bytes by pointer)    cmp x2,0               // is null ?    cinc x0,x0,ne          // no increment counter    bne 1b                 // and loop                            // store pointer string 5 in area  at position x0    ldr x2,qAdrszString5   // address string 5    str x2,[x1,x0,lsl 3]   // store address                             // display string at item 3    mov x2,2               // pointers begin in position 0     ldr x1,qAdrtablesPoi1  // begin pointer area 1    ldr x0,[x1,x2,lsl 3]    bl affichageMess    ldr x0,qAdrszCarriageReturn    bl affichageMess                            // search string in area     ldr x1,qAdrszStringSch    //ldr x1,qAdrszStringSch1  // uncomment for other search : not found !!    ldr x2,qAdrtablesPoi1  // begin pointer area 1    mov x3,02:                         // search     ldr x0,[x2,x3,lsl 3]   // read string pointer address item x0 (4 bytes by pointer)    cbz x0,3f              // is null ?  end search    bl comparString    cmp x0,0               // string = ?    cinc x3,x3,ne          // no increment counter    bne 2b                 // and loop    mov x0,x3              // position item string    ldr x1,qAdrsZoneConv   // conversion decimal    bl conversion10S    ldr x0,qAdrszMessStringsch    ldr x1,qAdrsZoneConv     bl strInsertAtCharInc  // insert result at @ character    bl affichageMess    b 100f3:                         // end search  string not found    ldr x0,qAdrszMessStringNfound    bl affichageMess 100:                       // standard end of the program    mov x0,  0             // return code    mov x8,EXIT            // request to exit program    svc 0                  // perform the system callqAdrtablesPoi1:         .quad tablesPoi1qAdrszMessStringsch:    .quad szMessStringschqAdrszString5:          .quad szString5qAdrszStringSch:        .quad szStringSchqAdrszStringSch1:       .quad szStringSch1qAdrsZoneConv:          .quad sZoneConvqAdrszMessStringNfound: .quad szMessStringNfoundqAdrszCarriageReturn:   .quad  szCarriageReturn/************************************/       /* Strings comparaison              *//************************************/      /* x0 et x1 contains strings addresses *//* x0 return 0 if equal *//* return -1 if string x0 < string x1 *//* return 1  if string x0 > string x1 */comparString:    stp x2,lr,[sp,-16]!         // save  registers    stp x3,x4,[sp,-16]!         // save  registers    mov x2,#0                   // indice1:        ldrb w3,[x0,x2]             // one byte string 1    ldrb w4,[x1,x2]             // one byte string 2    cmp w3,w4    blt 2f                      // less    bgt 3f                      // greather    cmp w3,#0                   // 0 final    beq 4f                      // equal and end    add x2,x2,#1                //     b 1b                        // else loop2:    mov x0,#-1                  // less    b 100f3:    mov x0,#1                   // greather    b 100f4:    mov x0,#0                   // equal    b 100f100:    ldp x3,x4,[sp],16           // restaur  2 registers    ldp x2,lr,[sp],16           // restaur  2 registers    ret                         // return to address lr x30/********************************************************//*        File Include fonctions                        *//********************************************************//* for this file see task include a file in language AArch64 assembly */.include "../includeARM64.inc" `

## 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. DATA(itab) = VALUE tty_int( ( 1 )                            ( 2 )                            ( 3 ) ). INSERT 4 INTO TABLE itab.APPEND 5 TO itab.DELETE itab INDEX 1. cl_demo_output=>display( itab ).cl_demo_output=>display( itab[ 2 ] ). `
Output:
```2
3
4
5

3
```

## ACL2

`;; Create an array and store it in array-example(assign array-example        (compress1 'array-example                   (list '(:header :dimensions (10)                                   :maximum-length 11)))) ;; Set a[5] to 22(assign array-example        (aset1 'array-example               (@ array-example)               5               22)) ;; Get a[5](aref1 'array-example (@ array-example) 5)`

## Action!

`PROC Main()  BYTE i   ;array storing 4 INT items with initialized values  ;negative values must be written as 16-bit unsigned numbers  INT ARRAY a=[3 5 71 65535]   ;array storing 4 CARD items whithout initialization of values  CARD ARRAY b(3)   ;array of BYTE items without allocation,  ;it may be used as an pointer for another array  BYTE ARRAY c   ;array of 1+7 CHAR items or a string  ;the first item stores length of the string  CHAR ARRAY s="abcde"   PrintE("Array with initialized values:")  FOR i=0 TO 3  DO    PrintF("a(%I)=%I ",i,a(i))  OD  PutE() PutE()   PrintE("Array before initialization of items:")  FOR i=0 TO 3  DO    PrintF("b(%I)=%B ",i,b(i))  OD  PutE() PutE()   FOR i=0 TO 3  DO    b(i)=100+i  OD  PrintE("After initialization:")  FOR i=0 TO 3  DO    PrintF("b(%I)=%B ",i,b(i))  OD  PutE() PutE()   PrintE("Array of chars. The first item stores the length of string:")  FOR i=0 TO s(0)  DO    PrintF("s(%B)='%C ",i,s(i))  OD  PutE() PutE()   PrintE("As the string:")  PrintF("s=""%S""%E%E",s)   c=s  PrintE("Unallocated array as a pointer to another array. In this case c=s:")  FOR i=0 TO s(0)  DO    PrintF("c(%B)=%B ",i,c(i))  ODRETURN`
Output:
```Array with initialized values:
a(0)=3 a(1)=5 a(2)=71 a(3)=-1

Array before initialization of items:
b(0)=0 b(1)=0 b(2)=0 b(3)=0

After initialization:
b(0)=100 b(1)=101 b(2)=102 b(3)=103

Array of chars. The first item stores the length of string:
s(0)='┐ s(1)='a s(2)='b s(3)='c s(4)='d s(5)='e

As the string:
s="abcde"

Unallocated array as a pointer to another array. In this case c=s:
c(0)=5 c(1)=97 c(2)=98 c(3)=99 c(4)=100 c(5)=101
```

## ActionScript

`//creates an array of length 10var array1:Array = new Array(10);//creates an array with the values 1, 2var array2:Array = new Array(1,2);//arrays can also be set using array literalsvar array3:Array = ["foo", "bar"];//to resize an array, modify the length propertyarray2.length = 3;//arrays can contain objects of multiple types.array2[2] = "Hello";//get a value from an arraytrace(array2[2]);//append a value to an arrayarray2.push(4);//get and remove the last element of an arraytrace(array2.pop());`

`procedure Array_Test is    A, B : array (1..20) of Integer;    -- Ada array indices may begin at any value, not just 0 or 1   C : array (-37..20) of integer    -- Ada arrays may be indexed by enumerated types, which are    -- discrete non-numeric types   type Days is (Mon, Tue, Wed, Thu, Fri, Sat, Sun);   type Activities is (Work, Fish);   type Daily_Activities is array(Days) of Activities;   This_Week : Daily_Activities := (Mon..Fri => Work, Others => Fish);    -- Or any numeric type   type Fingers is range 1..4; -- exclude thumb   type Fingers_Extended_Type is array(fingers) of Boolean;   Fingers_Extended : Fingers_Extended_Type;    -- Array types may be unconstrained. The variables of the type   -- must be constrained   type Arr is array (Integer range <>) of Integer;   Uninitialized : Arr (1 .. 10);   Initialized_1 : Arr (1 .. 20) := (others => 1);   Initialized_2 : Arr := (1 .. 30 => 2);   Const         : constant Arr := (1 .. 10 => 1, 11 .. 20 => 2, 21 | 22 => 3);   Centered      : Arr (-50..50) := (0 => 1, Others => 0);    Result        : Integerbegin    A := (others => 0);     -- Assign whole array   B := (1 => 1, 2 => 1, 3 => 2, others => 0);                            -- Assign whole array, different values    A (1) := -1;            -- Assign individual element   A (2..4) := B (1..3);   -- Assign a slice   A (3..5) := (2, 4, -1); -- Assign a constant slice   A (3..5) := A (4..6);   -- It is OK to overlap slices when assigned    Fingers_Extended'First := False; -- Set first element of array   Fingers_Extended'Last := False;  -- Set last element of array end Array_Test;`

Arrays are first-class objects in Ada. They can be allocated statically or dynamically as any other object. The number of elements in an array object is always constrained. Variable size arrays are provided by the standard container library. They also can be implemented as user-defined types.

## 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 literalvar arr2 = new [10]   // empty array of 10 elements (each element has value none)var arr3 = new int [40]  // array of 40 integersvar arr4 = new Object (1,2) [10]   // array of 10 instances of Object arr1.append (5)   // add to arrayvar b = 4 in arr1   // check for inclusionarr1 <<= 2           // remove first 2 elements from arrayvar arrx = arr1[1:3]   // get slice of arrayvar s = arr1.size()  // or sizeof(arr1)delete arr4[2]     // remove an element from an array var arr5 = arr1 + arr2   // append arraysvar arr6 = arr1 | arr2    // unionvar arr7 = arr1 & arr2   // intersection  `
1. retrieve an element

puts a[0]

## Aime

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

`list l;`

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

`l_append(l, 3);l_append(l, "arrays");l_append(l, pow);`

The insertion position can be specified:

`l_push(l, 3, .5);l_push(l, 4, __type(l));`

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

`l_p_integer(l, 5, -1024);l_p_real(l, 6, 88);`

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

`l_query(l, 5);`

or is type specific fashion:

`l_q_real(l, 6);l_q_text(l, 1);`

## ALGOL 60

Translation of: Simula
`begincomment arrays - Algol 60;   procedure static;  begin    integer array x[0:4];    x[0]:=10;    x[1]:=11;    x[2]:=12;    x[3]:=13;    x[4]:=x[0];    outstring(1,"static at 4: ");    outinteger(1,x[4]);    outstring(1,"\n")  end static;   procedure dynamic(n); value n; integer n;  begin    integer array x[0:n-1];    x[0]:=10;    x[1]:=11;    x[2]:=12;    x[3]:=13;    x[4]:=x[0];    outstring(1,"dynamic at 4: ");    outinteger(1,x[4]);    outstring(1,"\n")  end dynamic;   static;  dynamic(5) end arrays `
Output:
```static at 4:  10
dynamic at 4:  10
```

## ALGOL 68

`PROC array_test = VOID:(  [1:20]INT a;  a := others;                           # assign whole array #  a[1] := -1;                            # assign individual element #  a[3:5] := (2, 4, -1);                  # assign a slice #  [1:3]INT slice = a[3:5];               # copy a slice #   REF []INT rslice = a[3:5];             # create a reference to a slice #  print((LWB rslice, UPB slice));        # query the bounds of the slice #  rslice := (2, 4, -1);                  # assign to the slice, modifying original array #   [1:3, 1:3]INT matrix;                  # create a two dimensional array #  REF []INT hvector = matrix[2,];        # create a reference to a row #  REF []INT vvector = matrix[,2];        # create a reference to a column #  REF [,]INT block = matrix[1:2, 1:2];   # create a reference to an area of the array #   FLEX []CHAR string := "Hello, world!"; # create an array with variable bounds #  string := "shorter"                    # flexible arrays automatically resize themselves on assignment #)`

Arrays in ALGOL 68 are first class objects. Slices to any portion of the array can be created and then treated equivalently to arrays, even sections of a multidimensional array; the bounds are queried at run time. References may be made to portions of an array. Flexible arrays are supported, which resize themselves on assignment, but they can't be resized without destroying the data.

## ALGOL W

`begin    % declare an array %    integer array a ( 1 :: 10 );    % set the values %    for i := 1 until 10 do a( i ) := i;    % change the 3rd element %    a( 3 ) := 27;    % display the 4th element %    write( a( 4 ) ); % would show 4 %    % arrays with sizes not known at compile-time must be created in inner-blocks or procedures %    begin        integer array b ( a( 3 ) - 2 :: a( 3 ) ); % b has bounds 25 :: 27 %        for i := a( 3 ) - 2 until a( 3 ) do b( i ) := i    end    % arrays cannot be part of records and cannot be returned by procecures though they can be passed %    % as parameters to procedures                                                                     %    % multi-dimension arrays are supported                                                            %end.`

## AmigaE

`DEF ai[100] : ARRAY OF CHAR, -> static    da: PTR TO CHAR,    la: PTR TO CHAR PROC main()  da := New(100)  -> or  NEW la[100]  IF da <> NIL    ai[0] := da[0]    -> first is 0    ai[99] := da[99]  -> last is "size"-1    Dispose(da)  ENDIF  -> using NEW, we must specify the size even when  -> "deallocating" the array  IF la <> NIL THEN END la[100]ENDPROC`

## AntLang

`/ Create an immutable sequence (array)arr: <1;2;3> / Get the head an tail parth: head[arr]t: tail[arr] / Get everything except the last element and the last elementnl: first[arr]l: last[arr] / Get the nth element (index origin = 0)nth:arr[n]`

## Apex

`Integer[] array = new Integer[10]; // optionally, append a braced list of Integers like "{1, 2, 3}"array[0] = 42;System.debug(array[0]); // Prints 42`

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

`List <Integer> aList = new List <Integer>(); // optionally add an initial size as an argumentaList.add(5);// appends to the end of the listaList.add(1, 6);// assigns the element at index 1System.debug(list[0]); // Prints 5, alternatively you can use list.get(0)`

## APL

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

`+/ 1 2 3`
Is equivalent to
`1 + 2 + 3`
We're folding function
`+`
over the array
`1 2 3`

## App Inventor

Arrays in App Inventor are represented with Lists. Lists may be nested to any level and contain other Lists. All supported data types may be stored in a List. Basic List blocks

## AppleScript

AppleScript arrays are called lists:

` set empty to {} set ints to {1, 2, 3}`

Lists can contain any objects including other lists:

` set any to {1, "foo", 2.57, missing value, ints}`

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

`set any to {1, "foo", 2.57, missing value, {1, 2, 3}}set beginning of any to falseset end of any to Wednesdayreturn any--> {false, 1, "foo", 2.57, missing value, {1, 2, 3}, Wednesday}`

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

`set any to {1, "foo", 2.57, missing value, {1, 2, 3}}set any to false & any & Wednesday--> {false, 1, "foo", 2.57, missing value, {1, 2, 3}, 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!

Items can't be removed from lists, but new lists can be created without them.

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:

`set any to {1, "foo", 2.57, missing value, {1, 2, 3}}item -1 of any --> {1, 2, 3}items 1 thru 3 of any --> {1, "foo", 2.57}`

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

`set any to {false, 1, "foo", 2.57, missing value, {1, 2, 3}, Wednesday}number 2 of any -- 2.57 (ie. the second number in the list)`

… and some fairly complex range specifiers are possible:

`set any to {false, 1, "foo", 2.57, missing value, 5, 4, 12.0, 38, {1, 2, 3}, 7, Wednesday}integers from text 1 to list 1 of any --> {5, 4, 38}`

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

`count any -- Command.length of any -- Property.number of any -- Property.`

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

`count any's realslength of any's integers`

A list's other properties are its `rest` (which is another list containing all the items except for the first) and its `reverse` (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 AppleScript version "2.4" -- Mac OS 10.10 (Yosemite) or later.use framework "Foundation" -- Allows access to NSArrays and other Foundation classes. set myList to {1, "foo", 2.57, missing value, {1, 2, 3}} -- AppleScript list.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.--> 5`

## Arendelle

```// Creating an array as [ 23, 12, 2, 5345, 23 ]
// with name "space"

( space , 23; 12; 2; 5345; 23 )

// Getting the size of an array:

"Size of array is | @space? |"

// Appending array with 54

( space[ @space? ] , 54 )

// Something else fun about arrays in Arendelle
// for example when you have one like this:
//
//    space -> [ 23, 34, 3, 6345 ]
//
// If you do this on the space:

( space[ 7 ] , 10 )

// Arendelle will make the size of array into
// 8 by appending zeros and then it will set
// index 7 to 10 and result will be:
//
//    space -> [ 23, 34, 3, 6345, 0, 0, 0, 10 ]

// To remove the array you can use done keyword:

( space  , done )```

## Argile

Works with: Argile version 1.0.0
`use std, array (::::::::::::::::: : Static arrays : :::::::::::::::::)let the array of 2 text aabbArray be Cdata{"aa";"bb"}let raw array of real :my array: = Cdata {1.0 ; 2.0 ; 3.0} (: auto sized :)let another_array be an array of 256 byte (: not initialised :)let (raw array of (array of 3 real)) foobar = Cdata {  {1.0; 2.0; 0.0}  {5.0; 1.0; 3.0}} (: macro to get size of static arrays :)=: <array>.length := -> nat {size of array / (size of array[0])}printf "%lu, %lu\n" foobar.length (another_array.length) (: 2, 256 :) (: access :)another_array[255] = '&'printf "`%c'\n" another_array[255]  (:::::::::::::::::: : Dynamic arrays : ::::::::::::::::::)let DynArray = new array of 5 intDynArray[0] = -42DynArray = (realloc DynArray (6 * size of DynArray[0])) as (type of DynArray)DynArray[5] = 243prints DynArray[0] DynArray[5]del DynArray`
Works with: Argile version 1.1.0
`use std, arraylet x = @["foo" "bar" "123"]print x[2]x[2] = "abc"`

## ARM Assembly

Works with: as version Raspberry Pi
` /* ARM assembly Raspberry PI  *//*  program areaString.s   */ /* Constantes    */.equ STDOUT, 1     @ Linux output console.equ EXIT,   1     @ Linux syscall.equ WRITE,  4     @ Linux syscall/* Initialized data */.dataszMessStringsch: .ascii "The string is at item : "sZoneconv:		 .fill 12,1,' 'szCarriageReturn:  .asciz "\n"szMessStringNfound: .asciz "The string is not found in this area.\n" /* areas strings  */szString1:  .asciz "Apples"szString2:  .asciz "Oranges"szString3:  .asciz "Pommes"szString4:  .asciz "Raisins"szString5:  .asciz "Abricots" /* pointer items area 1*/tablesPoi1:pt1_1:	    .int szString1pt1_2:	    .int szString2pt1_3:	    .int szString3pt1_4:	    .int szString4ptVoid_1: .int 0ptVoid_2: .int 0ptVoid_3: .int 0ptVoid_4: .int 0ptVoid_5: .int 0 szStringSch:	.asciz "Raisins"szStringSch1:	.asciz "Ananas" /* UnInitialized data */.bss  /*  code section */.text.global main main:                /* entry of program  */    push {fp,lr}    /* saves 2 registers */     @@@@@@@@@@@@@@@@@@@@@@@@    @ add string 5 to area   @@@@@@@@@@@@@@@@@@@@@@@@    ldr r1,iAdrtablesPoi1  @ begin pointer area 1    mov r0,#0    @ counter1:   @ search first void pointer    ldr r2,[r1,r0,lsl #2]    @ read string pointer address item r0 (4 bytes by pointer)    cmp r2,#0                @ is null ?    addne r0,#1             @ no increment counter    bne 1b                  @ and loop     @ store pointer string 5 in area  at position r0    ldr r2,iAdrszString5  @ address string 5    str r2,[r1,r0,lsl #2]    @ store address      @@@@@@@@@@@@@@@@@@@@@@@@    @ display string at item 3    @@@@@@@@@@@@@@@@@@@@@@@@    mov r2,#2        @ pointers begin in position 0     ldr r1,iAdrtablesPoi1  @ begin pointer area 1    ldr r0,[r1,r2,lsl #2]    bl affichageMess    ldr r0,iAdrszCarriageReturn    bl affichageMess     @@@@@@@@@@@@@@@@@@@@@@@@    @ search string in area     @@@@@@@@@@@@@@@@@@@@@@@@    ldr r1,iAdrszStringSch    //ldr r1,iAdrszStringSch1  @ uncomment for other search : not found !!    ldr r2,iAdrtablesPoi1  @ begin pointer area 1    mov r3,#0  2:   @ search     ldr r0,[r2,r3,lsl #2]    @ read string pointer address item r0 (4 bytes by pointer)    cmp r0,#0                @ is null ?    beq 3f        @ end search    bl comparaison    cmp r0,#0                @ string = ?    addne r3,#1             @ no increment counter    bne 2b                  @ and loop    mov r0,r3             @ position item string    ldr r1,iAdrsZoneconv   @ conversion decimal    bl conversion10S    ldr r0,iAdrszMessStringsch    bl affichageMess    b 100f3:   @ end search  string not found    ldr r0,iAdrszMessStringNfound    bl affichageMess 100:   /* standard end of the program */    mov r0, #0                  @ return code    pop {fp,lr}                 @restaur 2 registers    mov r7, #EXIT              @ request to exit program    swi 0                       @ perform the system calliAdrtablesPoi1:		.int tablesPoi1iAdrszMessStringsch:   .int szMessStringschiAdrszString5:		.int szString5iAdrszStringSch:	.int szStringSchiAdrszStringSch1:   .int szStringSch1iAdrsZoneconv:       .int sZoneconviAdrszMessStringNfound:  .int szMessStringNfoundiAdrszCarriageReturn:  .int  szCarriageReturn/******************************************************************//*     display text with size calculation                         */ /******************************************************************//* r0 contains the address of the message */affichageMess:    push {fp,lr}    			/* save  registres */     push {r0,r1,r2,r7}    		/* save others registers */    mov r2,#0   				/* counter length */1:      	/* loop length calculation */    ldrb r1,[r0,r2]  			/* read octet start position + index */    cmp r1,#0       			/* if 0 its over */    addne r2,r2,#1   			/* else add 1 in the length */    bne 1b          			/* and loop */                                /* so here r2 contains the length of the message */    mov r1,r0        			/* address message in r1 */    mov r0,#STDOUT      		/* code to write to the standard output Linux */    mov r7, #WRITE             /* code call system "write" */    swi #0                      /* call systeme */    pop {r0,r1,r2,r7}     		/* restaur others registers */    pop {fp,lr}    				/* restaur des  2 registres */     bx lr	        			/* return  *//***************************************************//*   conversion register signed décimal     *//***************************************************//* r0 contient le registre   *//* r1 contient l adresse de la zone de conversion */conversion10S:    push {r0-r5,lr}    /* save des registres */    mov r2,r1       /* debut zone stockage */    mov r5,#'+'     /* par defaut le signe est + */    cmp r0,#0       /* nombre négatif ? */    movlt r5,#'-'     /* oui le signe est - */    mvnlt r0,r0       /* et inversion en valeur positive */    addlt r0,#1    mov r4,#10   /* longueur de la zone */1: /* debut de boucle de conversion */    bl divisionpar10 /* division  */    add r1,#48        /* ajout de 48 au reste pour conversion ascii */	    strb r1,[r2,r4]  /* stockage du byte en début de zone r5 + la position r4 */    sub r4,r4,#1      /* position précedente */    cmp r0,#0         bne 1b	       /* boucle si quotient different de zéro */    strb r5,[r2,r4]  /* stockage du signe à la position courante */    subs r4,r4,#1   /* position précedente */    blt  100f         /* si r4 < 0  fin  */    /* sinon il faut completer le debut de la zone avec des blancs */    mov r3,#' '   /* caractere espace */	2:    strb r3,[r2,r4]  /* stockage du byte  */    subs r4,r4,#1   /* position précedente */    bge 2b        /* boucle si r4 plus grand ou egal a zero */100:  /* fin standard de la fonction  */    pop {r0-r5,lr}   /*restaur desregistres */    bx lr    /***************************************************//*   division par 10   signé                       *//* Thanks to http://thinkingeek.com/arm-assembler-raspberry-pi/*  /* and   http://www.hackersdelight.org/            *//***************************************************//* r0 contient le dividende   *//* r0 retourne le quotient */	/* r1 retourne le reste  */divisionpar10:	  /* r0 contains the argument to be divided by 10 */   push {r2-r4}   /* save registers  */   mov r4,r0    ldr r3, .Ls_magic_number_10 /* r1 <- magic_number */   smull r1, r2, r3, r0   /* r1 <- Lower32Bits(r1*r0). r2 <- Upper32Bits(r1*r0) */   mov r2, r2, ASR #2     /* r2 <- r2 >> 2 */   mov r1, r0, LSR #31    /* r1 <- r0 >> 31 */   add r0, r2, r1         /* r0 <- r2 + r1 */   add r2,r0,r0, lsl #2   /* r2 <- r0 * 5 */   sub r1,r4,r2, lsl #1   /* r1 <- r4 - (r2 * 2)  = r4 - (r0 * 10) */   pop {r2-r4}   bx lr                  /* leave function */   bx lr                  /* leave function */.Ls_magic_number_10: .word 0x66666667  `

## Arturo

`; empty  arrayarrA: [] ; array with initial valuesarrB: ["one" "two" "three"] ; adding an element to an existing arrayarrB: arrB ++ "four"print arrB ; another way to add an elementappend 'arrB "five"print arrB ; retrieve an element at some indexprint arrB\1`
Output:
```one two three four
one two three four five
two```

## 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 := Object() ; could use JSON-syntax sugar like {key: value}myArray[1] := "foo"myArray[2] := "bar"MsgBox % myArray[2] ; Push a value onto the arraymyArray.Insert("baz")`

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.

`arrayX0 = 4      ; lengtharrayX1 = firstarrayX2 = secondarrayX3 = fooarrayX4 = barLoop, %arrayX0%  Msgbox % arrayX%A_Index%source = apple bear cat dog egg fishStringSplit arrayX, source, %A_Space%  Loop, %arrayX0%  Msgbox % arrayX%A_Index%`

## AutoIt

Create an userdefined array.

` #include <Array.au3> ;Include extended Array functions (_ArrayDisplay) Local \$aInputs[1] ;Create the Array with just 1 element While True ;Endless loop	\$aInputs[UBound(\$aInputs) - 1] = InputBox("Array", "Add one value") ;Save user input to the last element of the Array	If \$aInputs[UBound(\$aInputs) - 1] = "" Then ;If an empty string is entered, then...		ReDim \$aInputs[UBound(\$aInputs) - 1] ;...remove them from the Array and...		ExitLoop ;... exit the loop!	EndIf	ReDim \$aInputs[UBound(\$aInputs) + 1] ;Add an empty element to the ArrayWEnd _ArrayDisplay(\$aInputs) ;Display the Array `

## Avail

Avail supports tuples as its primary ordered collection.

`tup ::= <"aardvark", "cat", "dog">;`

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.

`<"pinch", "tsp", "tbsp", "cup">[4] \\ "cup"<3, 2, 1>[100] else [0]`

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

`<"sheep", "wheat", "wood", "brick", "stone">[5] → "ore"`

## AWK

Every array in AWK is an associative array. AWK converts each array subscript to a string, so a[33], a["33"] and a[29 + 4] are the same element.

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.

`BEGIN {  # to make an array, assign elements to it  array[1] = "first"  array[2] = "second"  array[3] = "third"  alen = 3  # want the length? store in separate variable   # or split a string  plen = split("2 3 5 7 11 13 17 19 23 29", primes)  clen = split("Ottawa;Washington DC;Mexico City", cities, ";")   # retrieve an element  print "The 6th prime number is " primes[6]   # push an element  cities[clen += 1] = "New York"   dump("An array", array, alen)  dump("Some primes", primes, plen)  dump("A list of cities", cities, clen)} function dump(what, array, len,    i) {  print what;   # iterate an array in order  for (i = 1; i <= len; i++) {    print "  " i ": " array[i]  }}`
Output:
```The 6th prime number is 13
An array
1: first
2: second
3: third
Some primes
1: 2
2: 3
3: 5
4: 7
5: 11
6: 13
7: 17
8: 19
9: 23
10: 29
A list of cities
1: Ottawa
2: Washington DC
3: Mexico City
4: New York```

## Axe

`1→{L₁}2→{L₁+1}3→{L₁+2}4→{L₁+3}Disp {L₁}►Dec,iDisp {L₁+1}►Dec,iDisp {L₁+2}►Dec,iDisp {L₁+3}►Dec,i`

## Babel

### Create an array

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:

`[1 2 3]`
`[ptr 1 2 3]`

### Get a single array element

`[1 2 3] 1 th ;`
Output:
`[val 0x2 ]`

### Change an array element

Changing a value-array element:

`[1 2 3] dup 1 7 set ; `
Output:
`[val 0x1 0x7 0x3 ]`

Changing a pointer-array element:

`[ptr 1 2 3] dup 1 [ptr 7] set ;`
Output:
`[ptr [val 0x1 ] [val 0x7 ] [val 0x3 ] ]`

### Select a range of an array

`[ptr 1 2 3 4 5 6] 1 3 slice ;`
Output:
`[ptr [val 0x2 ] [val 0x3 ] ]`

### Add a new element to an array

You can concatenate arrays of same type:

`[1 2 3] [4] cat`
`[ptr 1 2 3] [ptr 4] cat`

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 between arrays and lists

Convert a value-array to a list of values:

`[1 2 3] ar2ls lsnum !`
Output:
`( 1 2 3 )`

Convert a list of values to a value-array:

`(1 2 3) ls2lf ;`
Output:
`[val 0x1 0x2 0x3 ]`

Convert a pointer-array to a list of pointers:

`[ptr 'foo' 'bar' 'baz'] ar2ls lsstr !`
Output:
`( "foo" "bar" "baz" )`

Convert a list of pointers to a pointer-array:

`(1 2 3) bons ;`
Output:
`[ptr [val 0x1 ] [val 0x2 ] [val 0x3 ] ]`

## BaCon

1.) Historical BASIC way to do arrays with BaCon Note: We need to use quotes in DATA

` DATA "January", "February", "March", "April", "May", "June", "July"DATA "August", "September", "October", "November", "December" LOCAL dat\$[11]FOR i = 0 TO 11    READ dat\$[i]    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 i = 0'---dynamic index  the end of an array is always null terminated	WHILE (A\$[i] ISNOT NULL) 		PRINT A\$[i]		INCR i	WEND `

3.)Alternatively, using the command line to pass the input name this split.bac

` SPLIT ARGUMENT\$ BY " " TO TOK\$ SIZE len_array FOR i = 1 TO len_array - 1	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 and split it up into an array we use the built in SPLIT command

## BASIC

Works with: QuickBasic version 4.5
Works with: PB version 7.1

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.

` OPTION BASE 1 DIM myArray(100) AS INTEGER `

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

` DIM myArray(-10 TO 10) AS INTEGER `

Dynamic arrays:

` 'Specify that the array is dynamic and not static: '\$DYNAMIC DIM SHARED myArray(-10 TO 10, 10 TO 30) AS STRING REDIM SHARED myArray(20, 20) AS STRING myArray(1,1) = "Item1" myArray(1,2) = "Item2" `

Array Initialization

Arrays are initialized to zero or zero length strings when created. 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:

` DIM month\$(12) DATA January, February, March, April, May, June, July DATA August, September, October, November, December FOR m=1 TO 12    READ month\$(m) NEXT m `
Works with: FreeBASIC

FreeBASIC has an option to initialize array while declaring it.

` Dim myArray(1 To 2, 1 To 5) As Integer => {{1, 2, 3, 4, 5}, {1, 2, 3, 4, 5}} `
`10 REM TRANSLATION OF QBASIC STATIC VERSION20 REM ELEMENT NUMBERS TRADITIONALLY START AT ONE30 DIM A%(11): REM ARRAY OF ELEVEN INTEGER ELEMENTS40 LET A%(1) = -150 LET A%(11) = 160 PRINT A%(1), A%(11)70 END`
Works with: qbasic

### Static

`DIM staticArray(10) AS INTEGER staticArray(0) = -1staticArray(10) = 1 PRINT staticArray(0), staticArray(10)`

### Dynamic

Note that BASIC dynamic arrays are not stack-based; instead, their size must be changed in the same manner as their initial declaration -- the only difference between static and dynamic arrays is the keyword used to declare them (`DIM` vs. `REDIM`). QBasic lacks the `PRESERVE` keyword found in some modern BASICs; resizing an array without `PRESERVE` zeros the values.

`REDIM dynamicArray(10) AS INTEGER dynamicArray(0) = -1PRINT dynamicArray(0) REDIM dynamicArray(20) dynamicArray(20) = 1PRINT dynamicArray(0), dynamicArray(20)`

### Applesoft BASIC

`10 DIM A%(11): REM ARRAY OF TWELVE INTEGER ELEMENTS20 LET A%(0) = -130 LET A%(11) = 140 PRINT A%(0), A%(11)`

### Commodore BASIC

same as Applesoft BASIC

## BASIC256

`# numeric arraydim numbers(10)for t = 0 to 9  numbers[t] = t + 1next t # string arraydim words\$(10)# assigning an array with a listwords\$ = {"one","two","three","four","five","six","seven","eight","nine","ten"} gosub display # resize arrays (always preserves values if larger)redim numbers(11)redim words\$(11)numbers[10] = 11words\$[10] = "eleven"gosub display end display:# display arrays# using ? to get size of arrayfor t = 0 to numbers[?]-1  print numbers[t] + "=" + words\$[t]next treturn`

## Batch File

Arrays can be approximated, in a style similar to REXX

`::arrays.cmd@echo offsetlocal ENABLEDELAYEDEXPANSIONset array.1=1set array.2=2set array.3=3set array.4=4for /L %%i in (1,1,4) do call :showit array.%%i !array.%%i!set c=-27call :mkarray marry 5 6 7 8for /L %%i in (-27,1,-24) do call :showit "marry^&%%i" !marry^&%%i!endlocalgoto :eof :mkarrayset %1^&%c%=%2set /a c += 1shift /2if "%2" neq "" goto :mkarraygoto :eof :showitecho %1 = %2goto :eof `
Output:
```array.1 = 1
array.2 = 2
array.3 = 3
array.4 = 4
"marry&-27" = 5
"marry&-26" = 6
"marry&-25" = 7
"marry&-24" = 8```

## BBC BASIC

`      REM Declare arrays, dimension is maximum index:      DIM array(6), array%(6), array\$(6)       REM Entire arrays may be assigned in one statement:      array() = 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7      array%() = 0, 1, 2, 3, 4, 5, 6      array\$() = "Zero", "One", "Two", "Three", "Four", "Five", "Six"       REM Or individual elements may be assigned:      array(2) = PI      array%(3) = RND      array\$(4) = "Hello world!"       REM Print out sample array elements:      PRINT array(2)  TAB(16) array(3)  TAB(32) array(4)      PRINT array%(2) TAB(16) array%(3) TAB(32) array%(4)      PRINT array\$(2) TAB(16) array\$(3) TAB(32) array\$(4)`

## bc

There are 26 arrays available (named 'a' to 'z') with all elements initialized to zero and an installation-specific maximum size (in GNU bc you can find out the limits of your installation (`BC_DIM_MAX`) by invoking the `limits` command). Array identifiers are always followed by square brackets ('[', ']') and need not be declared/defined before usage. Indexing starts at zero.

The following is a transcript of an interactive session:

`/* Put the value 42 into array g at index 3 */g[3] = 42/* Look at some other elements in g */g[2]0g[4342]0/* Look at the elements of another array */a[543]0/* Array names don't conflict with names of ordinary (scalar) identifiers */g0g = 123g123g[3]42`

## 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 % Replace the value at index 0 in array to "Index 0"set \$arr index 0 to "Index 0" % Will display "Index 0"display \$arr index 0 % There is no automatic garbage collectiondelete \$arr `

## Boo

` myArray as (int) = (1, 2, 3) // Size based on initializationfixedArray as (int) = array(int, 1) // Given size(1 in this case) myArray[0] = 10 myArray = myArray + fixedArray // Append arrays print myArray[0] `

## BQN

Arrays are the central data type of BQN, since it is an array language.

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

`# Stranding:arr ← 1‿2‿'a'‿+‿5# General List Syntax:arr1 ← ⟨1,2,'a',+,5⟩•Show arr ≡ arr1 # both arrays are the same.•Show arr•Show arr1 # Taking nth element(⊑):•Show 3⊑arr # Modifying the array(↩):arr ↩ "hello"⌾(4⊸⊑) arr`
`1⟨ 1 2 'a' + 5 ⟩⟨ 1 2 'a' + 5 ⟩+⟨ 1 2 'a' + "hello" ⟩`

## Bracmat

In Bracmat, an array is not a variable, but a stack of variables. In fact, local variables in functions are elements in arrays. Global variables are the zeroth element in such arrays. You can explicitly create an array of a specific size using the `tbl` function. Indexing is done by using the syntax `integer\$name`. Indexing is modulo the size of the array. A negative integer counts from the end of the array and backwards. The last used index is remembered by the array. Arrays can grow and shrink by calling `tbl` with other values. When shrinking, the values of the upper elements are lost. When growing, the current values are kept and the new elements are initialised with `0`. To delete and array (and therefore the variable with the array's name), call `tbl` with a size `0`.

`( tbl\$(mytable,100)& 5:?(30\$mytable)& 9:?(31\$mytable)& out\$(!(30\$mytable))& out\$(!(-169\$mytable))      { -169 mod 100 == 31 }& out\$!mytable               { still index 31 }& tbl\$(mytable,0)& (!mytable & out\$"mytable still exists"  | out\$"mytable is gone"  ));`
Output:
```5
9
9
mytable is gone```

## 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 AUTHOR: Keith StellyesWRITTEN: June 2016 This is a zero-based indexing array data structure, it assumes the following precondition: >INDEX<|NULL|VALUE|NULL|VALUE|NULL|VALUE|NULL (Where >< mark pointer position, and | separates addresses) It relies heavily on [>] and [<] both of which are idioms forfinding the next left/right null HOW INDEXING WORKS:It runs a loop _index_ number of times, setting that many nullsto a positive, so it can be skipped by the mentioned idioms. Basically, it places that many "milestones". EXAMPLE:If we seek index 2, and our array is {1 , 2 , 3 , 4 , 5} FINDING INDEX 2:   (loop to find next null, set to positive, as a milestone   decrement index) index  2  |0|1|0|2|0|3|0|4|0|5|0  1  |0|1|1|2|0|3|0|4|0|5|0  0  |0|1|1|2|1|3|0|4|0|5|0 ===========] =======UNIT TEST======= SET ARRAY {48 49 50}>>++++++++++++++++++++++++++++++++++++++++++++++++>>+++++++++++++++++++++++++++++++++++++++++++++++++>>++++++++++++++++++++++++++++++++++++++++++++++++++<<<<<<++ Move back to index and set it to 2======================= ===RETRIEVE ELEMENT AT INDEX=== =ACCESS INDEX=[>>[>]+[<]<-] loop that sets a null to a positive for each iteration              First it moves the pointer from index to first value               Then it uses a simple loop that finds the next null              it sets the null to a positive (1 in this case)               Then it uses that same loop reversed to find the first                 null which will always be one right of our index                 so we decrement our index               Finally we decrement pointer from the null byte to our              index and decrement it >>            Move pointer to the first value otherwise we can't loop [>]<          This will find the next right null which will always be right              of the desired value; then go one left  .             Output the value (In the unit test this print "2" [<[-]<]       Reset array ===ASSIGN VALUE AT INDEX=== STILL NEED TO ADJUST UNIT TESTS NEWVALUE|>INDEX<|NULL|VALUE etc [>>[>]+[<]<-] Like above logic except it empties the value and doesn't reset>>[>]<[-]  [<]<          Move pointer to desired value note that where the index was stored              is null because of the above loop [->>[>]+[<]<] If NEWVALUE is GREATER than 0 then decrement it & then find the               newly emptied cell and increment it [>>[>]<+[<]<<-] Move pointer to first value find right null move pointer left                 then increment where we want our NEWVALUE to be stored then                 return back by finding leftmost null then decrementing pointer                 twice then decrement our NEWVALUE cell `

## C

Fixed size static array of integers with initialization:

`int myArray2[10] = { 1, 2, 0 }; /* the rest of elements get the value 0 */float myFloats[] ={1.2, 2.5, 3.333, 4.92, 11.2, 22.0 }; /* automatically sizes */`

When no size is given, the array is automatically sized. Typically this is how initialized arrays are defined. When this is done, you'll often see a definition that produces the number of elements in the array, as follows.

`#define MYFLOAT_SIZE (sizeof(myFloats)/sizeof(myFloats[0]))`

When defining autosized multidimensional arrays, all the dimensions except the first (leftmost) need to be defined. This is required in order for the compiler to generate the proper indexing for the array.

`long a2D_Array[3][5];    /* 3 rows, 5 columns. */float my2Dfloats[][3] = {    1.0, 2.0, 0.0,   5.0, 1.0, 3.0 };#define FLOAT_ROWS (sizeof(my2Dfloats)/sizeof(my2dFloats[0]))`

When the size of the array is not known at compile time, arrays may be dynamically allocated to the proper size. The `malloc()`, `calloc()` and `free()` functions require the header `stdlib.h`.

`int numElements = 10;int *myArray = malloc(sizeof(int) * numElements);  /* array of 10 integers */if ( myArray != NULL )   /* check to ensure allocation succeeded. */{  /* allocation succeeded */  /* at the end, we need to free the allocated memory */  free(myArray);}                    /* calloc() additionally pre-initializes to all zeros */short *myShorts = calloc( numElements, sizeof(short)); /* array of 10 */ if (myShorts != NULL)....`

Once allocated, myArray can be used as a normal array.

The first element of a C array is indexed with 0. To set a value:

`myArray[0] = 1;myArray[1] = 3;`

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

`printf("%d\n", myArray[1]);`

The array[index] syntax can be considered as a shortcut for *(index + array) and thus the square brackets are a commutative binary operator:

`*(array + index) = 1;printf("%d\n", *(array + index));3[array] = 5;`

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

`#define XSIZE 20double *kernel = malloc(sizeof(double)*2*XSIZE+1);if (kernel) {   kernel += XSIZE;   for (ix=-XSIZE; ix<=XSIZE; ix++) {       kernel[ix] = f(ix);   ....   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>typedef struct node{  char value;  struct node* next;} node;typedef struct charList{  node* first;  int size;} charList; charList createList(){  charList foo = {.first = NULL, .size = 0};  return foo;}int addEl(charList* list, char c){  if(list != NULL){    node* foo = (node*)malloc(sizeof(node));    if(foo == NULL) return -1;    foo->value = c; foo->next = NULL;    if(list->first == NULL){      list->first = foo;    }else{      node* it= list->first;      while(it->next != NULL)it = it->next;      it->next = foo;    }    list->size = list->size+1;    return 0;  }else return -1;}int removeEl(charList* list, int index){    if(list != NULL && list->size > index){      node* it = list->first;      for(int i = 0; i < index-1; i++) it = it->next;      node* el = it->next;      it->next = el->next;      free(el);      list->size--;      return 0;    }else return -1;}char getEl(charList* list, int index){    if(list != NULL && list->size > index){        node* it = list->first;        for(int i = 0; i < index; i++) it = it->next;        return it->value;    }else return '\0';}static void cleanHelp(node* el){  if(el != NULL){    if(el->next != NULL) cleanHelp(el->next);    free(el);  }}void clean(charList* list){  cleanHelp(list->first);  list->size = 0;} `

## C#

Example of array of 10 int types:

` int[] numbers = new int[10];`

Example of array of 3 string types:

` string[] words = { "these", "are", "arrays" };`

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

`  int[] more_numbers = new int[3]{ 21, 14 ,63 };`

For Multi-Dimensional arrays you declare them the same except for a comma in the type declaration.

The following creates a 3x2 int matrix

`  int[,] number_matrix = new int[3,2];`

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.

`  string[,] string_matrix = { {"I","swam"}, {"in","the"}, {"freezing","water"} };`

or

` string[,] funny_matrix = new string[2,2]{ {"clowns", "are"} , {"not", "funny"} };`
`int[] array = new int[10]; array[0] = 1;array[1] = 3; Console.WriteLine(array[0]);`

Dynamic

`using System;using System.Collections.Generic; List<int> list = new List<int>(); list.Add(1);list.Add(3); list[0] = 2; Console.WriteLine(list[0]);`

## C++

Works with: C++11

C++ supports several types of array, depending on whether or not the size is known at compile time, and whether the array must be fixed-size or can grow.

`std::array<T, N>` is a fixed-size array of `T` objects. The size (`N`) must be known at compile time. It wraps a C array, and provides additional functionality and safety. Depending on how it is used, it may be dynamically allocated on the stack as needed, placed in read-only program memory at load time, or possibly may only exist during compilation and get optimized away, among other possibilities.

`std::vector<T>` is a resizable array of `T` objects. The memory for the array will be allocated from the heap (unless a custom allocator is used).

`#include <array>#include <vector> // These headers are only needed for the demonstration#include <algorithm>#include <iostream>#include <iterator>#include <string> // This is a template function that works for any array-like objecttemplate <typename Array>void demonstrate(Array& array){  // Array element access  array[2] = "Three";  // Fast, but unsafe - if the index is out of bounds you                       // get undefined behaviour  array.at(1) = "Two"; // *Slightly* less fast, but safe - if the index is out                       // of bounds, an exception is thrown   // Arrays can be used with standard algorithms  std::reverse(begin(array), end(array));  std::for_each(begin(array), end(array),    [](typename Array::value_type const& element) // in C++14, you can just use auto    {      std::cout << element << ' ';    });   std::cout << '\n';} int main(){  // Compile-time sized fixed-size array  auto fixed_size_array = std::array<std::string, 3>{ "One", "Four", "Eight" };  // If you do not supply enough elements, the remainder are default-initialized   // Dynamic array  auto dynamic_array = std::vector<std::string>{ "One", "Four" };  dynamic_array.push_back("Eight"); // Dynamically grows to accept new element   // All types of arrays can be used more or less interchangeably  demonstrate(fixed_size_array);  demonstrate(dynamic_array);}`

## Ceylon

Works with: Ceylon version 1.3.0
`import ceylon.collection { 	ArrayList} shared void run() { 	// you can get an array from the Array.ofSize named constructor	value array = Array.ofSize(10, "hello");	value a = array[3];	print(a);	array[4] = "goodbye";	print(array); 	// for a dynamic list import ceylon.collection in your module.ceylon file	value list = ArrayList<String>();	list.push("hello");	list.push("hello again");	print(list);}`

## ChucK

` int array[0]; // instantiate int arrayarray << 1; // append itemarray << 2 << 3; // append items4 => array[3]; // assign element(4) to index(3)5 => array.size; // resizearray.clear(); // clear elements<<<array.size()>>>; // print in cosole array size[1,2,3,4,5,6,7] @=> array;array.popBack(); // Pop last element `

## Clean

Array denotations are overloaded in Clean, therefore we explicitly specify the types. There are lazy, strict, and unboxed array.

### Lazy array

Create a lazy array of strings using an array denotation.

`array :: {String}array = {"Hello", "World"}`

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

`array :: {Real}array = createArray 10 3.1415`

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

`array :: {Int}array = {x \\ x <- [1 .. 10]}`

### Strict array

Create a strict array of integers.

`array :: {!Int}array = {x \\ x <- [1 .. 10]}`

### Unboxed array

Create an unboxed array of characters, also known as String.

`array :: {#Char}array = {x \\ x <- ['a' .. 'z']}`

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

`   // Declare and initialize two-dimensional array   Local arr1 := { { "NITEM","N",10,0 }, { "CONTENT","C",60,0} }   // Create an empty array   Local arr2 := {}   // Declare three-dimensional array   Local arr3[2,100,3]   // Create an array   Local arr4 := Array(50)    // Array can be dynamically resized:   arr4 := ASize( arr4, 80 )`

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

`// Adding new item to array, its size is incremented   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   arr3[1,1,1] := 11.4`

Retrieve items of an array:

`   x := arr3[1,10,2]// 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:

`// Fill the 20 items of array with 0, starting from 5-th item:   AFill( arr4, 0, 5, 20 )//Copy 10 items from arr4 to arr3[2], starting from the first position:   ACopy( arr4, arr3[2], 1, 10 )//Duplicate the whole or nested array:   arr5 := AClone( arr1 )   arr6 := AClone( arr1[3] )`

## Clojure

`;clojure is a language built with immutable/persistent data structures. there is no concept of changing what a vector/list ;is, instead clojure creates a new array with an added value using (conj...);in the example below the my-list does not change.  user=> (def my-list (list 1 2 3 4 5)) user=> my-list(1 2 3 4 5) user=> (first my-list)1 user=> (nth my-list 3)4 user=> (conj my-list 100) ;adding to a list always adds to the head of the list(100 1 2 3 4 5) user=> my-list ;it is impossible to change the list pointed to by my-list(1 2 3 4 5) user=> (def my-new-list (conj my-list 100)) user=> my-new-list(100 1 2 3 4 5) user=> (cons 200 my-new-list) ;(cons makes a new list, (conj will make a new object of the same type as the one it is given(200 100 1 2 3 4 5) user=> (def my-vec [1 2 3 4 5 6]) user=> (conj my-vec 300) ;adding to a vector always adds to the end of the vector[1 2 3 4 5 6 300]`

## COBOL

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

`       IDENTIFICATION DIVISION.       PROGRAM-ID. arrays.        DATA DIVISION.       WORKING-STORAGE SECTION.       01  fixed-length-table.           03  fixed-table-elt      PIC X OCCURS 5 TIMES.        01  table-length             PIC 9(5) VALUE 1.       01  variable-length-table.           03  variable-table-elt   PIC X OCCURS 1 TO 5 TIMES               DEPENDING ON table-length.        01  initial-value-area.           03  initial-values.               05  FILLER           PIC X(10) VALUE "One".               05  FILLER           PIC X(10) VALUE "Two".               05  FILLER           PIC X(10) VALUE "Three".           03 initial-value-table REDEFINES initial-values.              05  initial-table-elt PIC X(10) OCCURS 3 TIMES.        01  indexed-table.           03  indexed-elt          PIC X OCCURS 5 TIMES               INDEXED BY table-index.        PROCEDURE DIVISION.           *> Assigning the contents of an entire table.           MOVE "12345" TO fixed-length-table            *>  Indexing an array (using an index)           MOVE 1 TO table-index           MOVE "1" TO indexed-elt (table-index)            *> Pushing a value into a variable-length table.           ADD 1 TO table-length           MOVE "1" TO variable-table-elt (2)            GOBACK           .`

## CoffeeScript

`array1 = []array1[0] = "Dillenidae"array1[1] = "animus"array1[2] = "Kona"alert "Elements of array1: " + array1 # Dillenidae,animus,Kona array2 = ["Cepphus", "excreta", "Gansu"]alert "Value of array2[1]: " + array2[1] # excreta`

## ColdFusion

Creating a one-dimensional Array:

`<cfset arr1 = ArrayNew(1)>`

Creating a two-dimensional Array in CFScript:

`<cfscript>  arr2 = ArrayNew(2);</cfscript>`

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

## Common Lisp

`(let ((array (make-array 10)))  (setf (aref array 0) 1          (aref array 1) 3)  (print array))`

Dynamic

`(let ((array (make-array 0 :adjustable t :fill-pointer 0)))  (vector-push-extend 1 array)  (vector-push-extend 3 array)  (setf (aref array 0) 2)  (print array))`

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

`(make-array 10)`

Creates a two-dimensional array with dimensions 10x20.

`(make-array '(10 20))`

make-array may be called with a number of optional arguments.

`; Makes an array of 20 objects initialized to nil(make-array 20 :initial-element nil) ; Makes an integer array of 4 elements containing 1 2 3 and 4 initially which can be resized(make-array 4 :element-type 'integer :initial-contents '(1 2 3 4) :adjustable t)`

## Component Pascal

An arrays in Component Pascal are started from zero index.

` MODULE TestArray;(* Implemented in BlackBox Component Builder *) 	IMPORT Out; 	(* Static array *) 	PROCEDURE DoOneDim*;		CONST M = 5;		VAR a: ARRAY M OF INTEGER;	BEGIN		a[0] := 100; (* set first element's value of array a to 100 *)		a[M-1] := -100; (* set M-th element's value of array a to -100 *)		Out.Int(a[0], 0); Out.Ln;		Out.Int(a[M-1], 0); Out.Ln;	END DoOneDim; 	PROCEDURE DoTwoDim*;		VAR b: ARRAY 5, 4 OF INTEGER;	BEGIN		b[1, 2] := 100; (* second row, third column element *)		b[4, 3] := -100; (* fifth row, fourth column element *)		Out.Int(b[1, 2], 0); Out.Ln;		Out.Int(b[4, 3], 0); Out.Ln;	END DoTwoDim; END TestArray.`

## Computer/zero Assembly

An array is simply a sequence of memory addresses. If we have an array beginning at address ary, we can access element ${\displaystyle n}$ (zero-indexed) using an instruction of the form LDA ary+n (or STA ary+n, ADD ary+n, SUB ary+n). Generating this instruction will often involve the use of self-modifying code: we start with an instruction like LDA ary, add ${\displaystyle n}$ to it, store it back, and execute it.

It is often convenient to be able to iterate through an array—which means knowing where the array ends. There are two easy ways to do this: fixed-length arrays and zero-terminated arrays. As an illustration, we shall find the sum of an array of the first ten positive integers using each technique.

### Fixed-length array

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

`load:   LDA  ary        ADD  sum        STA  sum         LDA  load        ADD  one        STA  load         SUB  end        BRZ  done         JMP  load done:   LDA  sum        STP one:         1end:    LDA  ary+10 sum:         0 ary:         1             2             3             4             5             6             7             8             9             10`

### Zero-terminated array

`load:   LDA  ary        BRZ  done         ADD  sum        STA  sum         LDA  load        ADD  one        STA  load         JMP  load done:   LDA  sum        STP one:         1 sum:         0 ary:         1             2             3             4             5             6             7             8             9             10             0`

## Crystal

` # create an array with one object in ita = ["foo"] # Empty array literals always need a type specification:[] of Int32 # => Array(Int32).new # The array's generic type argument T is inferred from the types of the elements inside the literal. When all elements of the array have the same type, T equals to that. Otherwise it will be a union of all element types.[1, 2, 3]         # => Array(Int32)[1, "hello", 'x'] # => Array(Int32 | String | Char) # An explicit type can be specified by immediately following the closing bracket with of and a type, each separated by whitespace. This overwrites the inferred type and can be used for example to create an array that holds only some types initially but can accept other types later. array_of_numbers = [1, 2, 3] of Float64 | Int32 # => Array(Float64 | Int32)array_of_numbers << 0.5                         # => [1, 2, 3, 0.5] array_of_int_or_string = [1, 2, 3] of Int32 | String # => Array(Int32 | String)array_of_int_or_string << "foo"                      # => [1, 2, 3, "foo"] # percent array literals%w(one two three) # => ["one", "two", "three"]%i(one two three) # => [:one, :two, :three] `

## D

`// All D arrays are capable of bounds checks. import std.stdio, core.stdc.stdlib;import std.container: Array; void main() {    // GC-managed heap allocated dynamic array:    auto array1 = new int[1];    array1[0] = 1;    array1 ~= 3; // append a second item    // array1[10] = 4; // run-time error    writeln("A) Element 0: ", array1[0]);    writeln("A) Element 1: ", array1[1]);     // Stack-allocated fixed-size array:    int[5] array2;    array2[0] = 1;    array2[1] = 3;    // array2[2] = 4; // compile-time error    writeln("B) Element 0: ", array2[0]);    writeln("B) Element 1: ", array2[1]);     // Stack-allocated dynamic fixed-sized array,    // length known only at run-time:    int n = 2;    int[] array3 = (cast(int*)alloca(n * int.sizeof))[0 .. n];    array3[0] = 1;    array3[1] = 3;    // array3[10] = 4; // run-time error    writeln("C) Element 0: ", array3[0]);    writeln("C) Element 1: ", array3[1]);     // Phobos-defined  heap allocated not GC-managed array:    Array!int array4;    array4.length = 2;    array4[0] = 1;    array4[1] = 3;    // array4[10] = 4; // run-time exception    writeln("D) Element 0: ", array4[0]);    writeln("D) Element 1: ", array4[1]);}`
Output:
```A) Element 0: 1
A) Element 1: 3
B) Element 0: 1
B) Element 1: 3
C) Element 0: 1
C) Element 1: 3
D) Element 0: 1
D) Element 1: 3```

One more kind of built-in array:

`import std.stdio, core.simd; void main() {    // Stack-allocated vector for SIMD registers:    ubyte16 vector5;    vector5.array[0] = 1;    vector5.array[1] = 3;    // vector5.array[17] = 4; // Compile-time error.    writeln("E) Element 0: ", vector5.array[0]);    writeln("E) Element 1: ", vector5.array[1]);}`
Output:
```E) Element 0: 1
E) Element 1: 3```

## Dao

`# use [] to create numeric arrays of int, float, double or complex types:a = [ 1, 2, 3 ]  # a vectorb = [ 1, 2; 3, 4 ] # a 2X2 matrix # use {} to create normal arrays of any types:c = { 1, 2, 'abc' } d = a[1]e = b[0,1] # first row, second columnf = c[1]`

## Dart

` main(){	// Dart uses Lists which dynamically resize by default	final growable = [ 1, 2, 3 ];         // Add to the list using the add method	growable.add(4); 	print('growable: \$growable'); 	// You can pass an int to the constructor to create a fixed sized List	final fixed = List(3); 	// We must assign each element individually using the Subscript operator	// using .add would through an error	fixed[0] = 'one';	fixed[1] = 'two';	fixed[2] = 'three'; 	print('fixed: \$fixed'); 	// If we want to create a fixed list all at once we can use the of constructor	// Setting growable to false is what makes it fixed	final fixed2 = List.of( [ 1.5, 2.5, 3.5 ], growable: false); 	print('fixed2: \$fixed2'); 	// A potential gotcha involving the subscript operator [] might surprise JavaScripters	// One cannot add new elements to a List using the subscript operator	// We can only assign to existing elements, even if the List is growable 	final gotcha = [ 1, 2 ];		// gotcha[2] = 3 would cause an error in Dart, but not in JavaScript	// We must first add the new element using .add	gotcha.add(3);	// Now we can modify the existing elements with the subscript	gotcha[2] = 4; 	print('gotcha: \$gotcha');  }  `
Output:
```growable: [1, 2, 3, 4]
fixed: [one, two, three]
fixed2: [1.5, 2.5, 3.5]
gotcha: [1, 2, 4]
```

## DBL

`;;       Arrays for DBL version 4 by Dario B.; .DEFINE NR,5         RECORD VNUM1,  5D8             ;array of numberVNUM2,  [5]D8           ;array of numberVNUM3,  [5,2]D8         ;two-dimensional array of number VALP1,  5A10            ;array of stringsVALP2,  [5]A10          ;array of stringsVALP3,  [5,2]A10        ;two-dimensional array of strings VALP4,  [NR]A10         ;array of strings     PROC;------------------------------------------------------------------         ;Valid uses of arrays         VNUM1(1)=12345678         VNUM2(1)=VNUM1(1)               ; = 12345678        VNUM2[2]=VNUM1(1)               ; = 12345678         VNUM2[3]=VNUM2[1](3:2)          ; = 34         VNUM3[1,1]=1        VNUM3[1,2]=2        VNUM3[2,1]=3          VALP1(1)="ABCDEFGHIJ"         VALP2(2)=VALP1(1)               ; = "ABCDEFGHIJ"        VALP2[2]=VALP1(1)               ; = "ABCDEFGHIJ"         VALP2[3](3:2)=VALP2[1](3:2)     ; = "  CD      "         VALP3[1,1]="ABCDEFGHIJ"        VALP3[1,2]=VALP3[1,1]           ;= "ABCDEFGHIJ"        VALP3[2,1](3:2)=VALP3[1,2](3:2) ;= "   CD      "         VALP4[1]="ABCDEFGHIJ"         ;Clear arrays        CLEAR VNUM1(1:5*8),VNUM3(1:5*2*8)        VNUM2(1:5*8)=        CLEAR VALP1(1:5*8),VALP2(1:5*10)        VALP3(1:5*2*10)=`

## 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  StaticArray: array[1..10] of Integer; // static arrays can start at any index  DynamicArray: array of Integer; // dynamic arrays always start at 0  StaticArrayText,  DynamicArrayText: string;  ixS, ixD: Integer;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  for ixS := Low(StaticArray) to High(StaticArray) do  begin    StaticArray[ixS] := StrToInt(      InputBox('Random number',               'Enter a random number for position',               IntToStr(ixS)));  end;  // Storing entered numbers of the static array in reverse order into the dynamic  ixD := High(DynamicArray);  for ixS := Low(StaticArray) to High(StaticArray) do  begin    DynamicArray[ixD] := StaticArray[ixS];    Dec(ixD);  end;  // Concatenating the static and dynamic array into a single string variable  StaticArrayText := '';  for ixS := Low(StaticArray) to High(StaticArray) do    StaticArrayText := StaticArrayText + IntToStr(StaticArray[ixS]);  DynamicArrayText := '';  for ixD := Low(DynamicArray) to High(DynamicArray) do    DynamicArrayText := DynamicArrayText + IntToStr(DynamicArray[ixD]);  end;  // Displaying both arrays (#13#10 = Carriage Return/Line Feed)  ShowMessage(StaticArrayText + #13#10 + DynamicArrayText);end;`

## Diego

`set_ns(rosettacode);set_base(0); // Create a new dynamic array with length zero, variant and/or mixed datatypesadd_array(myEmptyArray); // Create a new dynamic array with length zero, of integers with no mixed datatypesadd_array({int}, myIntegerArray); // Create a new fixed-length array with length 5add_array(myFiveArray)_len(5)_base(0);   // The value base '_base(0)' is usually defaulted to zero, depends upon thing.  // Create an array with 2 members (length is 2) add_ary(myStringArray)_value(Item1,Item2);   // '_array' can be shortened to '_ary' // Assign a value to member [2]with_ary(myChangeArray)_at(2)_v(5);    // '_value' can be shortened to '_v' // Add a member to an array with the push function (defaulted at end), length increased by one[myExpandedArray]_push()_v(9);    // 'with_ary(...)' can be shortened to '[...]'[myExpandedArray]_append()_v(9); // Add a member to an array with the push function (at a location), length increased by one[myExpandedArray]_pushat(3)_v(8); // Remove a member to an array with the pop function (defaulted at end), length reduced by one[myExpandedArray]_pop(); // Remove a member to an array with the pop function (at a location), length reduced by one[myExpandedArray]_popat(3); // Swap a member to an array with the swap function[myExpandedArray]_swapfrom(2)_swapto(6);[myExpandedArray]_swap(2, 6); // Rectiline a member in an array[MyCaterpillarArray]_rectilat(4)_rectilup(2);[MyCaterpillarArray]_rectilup(4, 2);[MyCaterpillarArray]_rectilat(5)_rectildown(3);[MyCaterpillarArray]_rectildown(5, 3); // Null a member to an array with the pluck function (defaulted at end)[myExpandedArray]_pluck(); // Null a member to an array with the pluck function (at a location)[myExpandedArray]_pluckat(3); // Get size of array[mySizableArray]_size();    // '_len()' can also be used[myMultidimensialArray]_size() // Retrieve an element of an array[myArray]_at(3);[myArray]_first();    // Retrieve first element in an array[myArray]_last();     // Retrieve last element in an array // More transformations of arrays (like append, union, intersection) are available // For multi-dimensional array use the 'matrix' object set_matrixorder(row-major);    // set major order as row- or column-major order depends on the thingset_handrule(right);           // set hand-rule, most things will use right hand-rule // Create a new dynamic two-dimensional array with length zero, variant and/or mixed datatypesadd_matrix(myMatrix)_dim(2); // Create a new dynamic three-dimensional array with length zero, of integers with no mixed datatypesadd_matrix({int}, my3DEmptyMatrix)_dim(3); // Convert an array to a matrix by adding a new dimension with length zero, variant and/or mixed datatypeswith_array(MyConvertedArray)_dim();    // Should now use '_matrix' object rather than '_array'with_array(MyConvertedArray)_dim(3);   // Add three dimensions to array, should now use '_matrix' object rather than '_array' // Create a new fixed-length traditional (2D) matrix with 5 rows and 4 columnsadd_matrix(myMatrix)_rows(5)_columns(4);add_matirx(myMatrix)_subs(5, 4);  // check or set major order first // Create a new fixed-length mutil-dimensional matrix with 5 rows, 4 columns, 6 subscripts, and 8 subscripts add_matrix(myMatrix)_rows(5)_columns(4)_subs(6)_subs(8);add_mat(myMatrix)_subs(5, 4, 6, 8);  // check or set major order first, '_matrix' can be shortened to 'mat' // Create a 4 x 4 identiy matrix:add_mat(myIdentityMatrix)_subs(4, 4)_identity;    // ...or... add_mat(myMorphedMatrix)_subs(4, 4)with_mat(myMorphedMatrix)_trans(morph)_identity();   // More transformations available // Assign a value to member [2,4]with_mat(myMatrix)_row(2)_col(4)_value(5);    // ...or...with_mat(myMatrix)_at(2, 4)_v(5);    // check or set major order first // Add a member(s) to a matrix using push functions is available// Remove a member(s) from a matrix with the pop functions is available// Swap a member(s) in a matrix with the swap functions is available // Rectiline a single member in a three-dimensional matrix[MyWobbleMatrix]_rectilat()_row(3)_col(3)_sub(3)_rectilto()_row(-1)_col(1)_sub(0);    // ...or...[MyWobbleMatrix]_rectilat(3, 3, 3)_rectilto(-1, 1, 0);    // check or set major order first, ...or...[MyWobbleMatrix]_rectilat(3, 3, 3)_rectilleft(1)_rectilup(1);    / check or set hand-rule, ...or... // Also 'crab', 'elevate', 'slide' and 'pump' movements are available// Also 'row', 'pitch', and 'yaw' movements are available// Also, quaternions calculations are available// Null a member in a matrix using pluck functions is available // Get size of a matrixmat(mySizableMatrix)_size();    // will return an array of the size()[myMultidimensialArray]_len();  // '_len()' can also be used // Retrieve an element of a matrix[myMatrix]_at(3, 2);[myArray]_first()_atsub(2);    // Retrieve first element of a row/column/subscript of a matrix[myArray]_last()_atsub(2);     // Retrieve last element of a row/column/subscript of a matrix[myArray]_origin();    // Retrieve first element in a matrix[myArray]_end();       // Retrieve last element in a matrix reset_ns[];`

## Dragon

`array = newarray(3) //optionally, replace "newarray(5)" with a brackets list of values like "[1, 2, 3]"array[0] = 42showln array[2] `

## DWScript

` // dynamic array, extensible, this a reference typevar d : array of Integer;d.Add(1);     // has various methods to add, delete, etc.d.Add(2, 3); // read and write elements by indexitem := d[5];d[6] := item+1; // static, fixed-size array, arbitrary lower-bound, this is a value typevar s : array [2..4] of Integer; // inline array constructor, works for both static and dynamic arrayss := [1, 2, 3]; `

## Dyalect

`//Dyalect supports dynamic arraysvar empty = []var xs = [1, 2, 3] //Add elements to an arrayempty.Add(0)empty.AddRange(xs) //Access array elementsvar x = xs[2]xs[2] = x * x`

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

`#create a new listlocal :l [] #add something to itpush-to l "Hi" #add something else to itpush-to l "Boo" #the list could also have been built up this way:local :l2 [ "Hi" "Boo" ] #this prints 2!print len l #this prints Hi!print get-from l 0 #this prints Boo!print pop-from l `

## E

E's collection library emphasizes providing both mutable and immutable collections. The relevant array-like types are `ConstList` and `FlexList`.

Literal lists are `ConstList`s.

`? def empty := []# value: [] ? def numbers := [1,2,3,4,5]# value: [1, 2, 3, 4, 5] ? numbers.with(6)# value: [1, 2, 3, 4, 5, 6] ? numbers + [4,3,2,1]# value: [1, 2, 3, 4, 5, 4, 3, 2, 1]`

Note that each of these operations returns a different list object rather than modifying the original. You can, for example, collect values:

`? var numbers := []# value: [] ? numbers := numbers.with(1)# value: [1] ? numbers with= 2            # shorthand for same# value: [1, 2]`

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

`? def flex := numbers.diverge()# value: [1, 2].diverge() ? flex.push(-3)? flex# value: [1, 2, -3].diverge() ? numbers# value: [1, 2] ? flex.snapshot()# value: [1, 2, -3]`

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

`([0] * 100).diverge(int)    # contains 100 zeroes, can only contain integers`

Note that this puts the same value in every element; if you want a collection of some distinct mutable objects, see N distinct objects#E.

In accordance with its guarantees of determinism, you can never have an uninitialized FlexList in E.

## EasyLang

`len f[] 3for i range len f[]  f[i] = i.f[] &= 3for i range len f[]  print f[i].`

## EGL

Arrays in EGL are 1-based, so the first element of an array is placed in element [1].

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]); `
Output:
```42
```

Dynamic array

```array int[0]; // Array declared without elements.
array.appendElement(11); // Add an element to the array and provide a value at the samen time.
array.appendElement(new int{}); // Add an element with the correct type, but without a value.
array[2] = 18; // Set the value of the added element.
SysLib.writeStdout(array[1]);
SysLib.writeStdout(array[2]);
```
Output:
```11
18
```

## Eiffel

` class	APPLICATION inherit	ARGUMENTS create	make feature {NONE} -- Initialization	make			-- Run application.		do			-- initialize the array, index starts at 1 (not zero) and prefill everything with the letter z			create my_static_array.make_filled ("z", 1, 50) 			my_static_array.put ("a", 1)			my_static_array.put ("b", 2)			my_static_array [3] := "c" 			-- access to array fields			print (my_static_array.at(1) + "%N")			print (my_static_array.at(2) + "%N")			print (my_static_array [3] + "%N") 			-- in Eiffel static arrays can be resized in three ways			my_static_array.force ("c", 51) -- forces 'c' in position 51 and resizes the array to that size (now 51 places)			my_static_array.automatic_grow -- adds 50% more indices (having now 76 places)			my_static_array.grow (100) -- resizes the array to 100 places		end 	my_static_array: ARRAY [STRING]end `

## Elena

ELENA 5.0:

Static array

`    var staticArray := new int[]{1, 2, 3};`

Generic array

`    var array := system'Array.allocate:3;    array[0] := 1;    array[1] := 2;    array[2] := 3;`

Stack allocated array

`    int stackAllocatedArray[3];    stackAllocatedArray[0] := 1;    stackAllocatedArray[1] := 2;    stackAllocatedArray[2] := 3;`

Dynamic array

`    var dynamicArray := new system'collections'ArrayList();    dynamicArray.append:1;    dynamicArray.append:2;    dynamicArray.append:4;     dynamicArray[2] := 3;`

Printing an element

`    system'console.writeLine(array[0]);    system'console.writeLine(stackAllocatedArray[1]);    system'console.writeLine(dynamicArray[2]);`

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

`ret = {:ok, "fun", 3.1415}`

Elements of tuples are indexed numerically, starting with zero.

`elem(ret, 1) == "fun"elem(ret, 0) == :okput_elem(ret, 2, "pi")               # => {:ok, "fun", "pi"}ret == {:ok, "fun", 3.1415}`

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

`Tuple.append(ret, 3.1415)            # => {:ok, "fun", "pie", 3.1415}`

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

`Tuple.insert_at(ret, 1, "new stuff") # => {:ok, "new stuff", "fun", "pie"}`

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:

`[ 1, 2, 3 ]`

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 = [1, :two, "three"]my_list ++ [4, :five]              # => [1, :two, "three", 4, :five] List.insert_at(my_list, 0, :cool)  # => [:cool, 1, :two, "three"]List.replace_at(my_list, 1, :cool) # => [1, :cool, "three"]List.delete(my_list, :two)         # => [1, "three"]my_list -- ["three", 1]            # => [:two]my_list                            # => [1, :two, "three"]`

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

`iex(1)> fruit = [:apple, :banana, :cherry][:apple, :banana, :cherry]iex(2)> hd(fruit):appleiex(3)> tl(fruit)[:banana, :cherry]iex(4)> hd(fruit) == :appletrueiex(5)> tl(fruit) == [:banana, :cherry]true`

## Erlang

`   %% Create a fixed-size array with entries 0-9 set to 'undefined'  A0 = array:new(10).  10 = array:size(A0).   %% Create an extendible array and set entry 17 to 'true',  %% causing the array to grow automatically  A1 = array:set(17, true, array:new()).  18 = array:size(A1).   %% Read back a stored value  true = array:get(17, A1).   %% Accessing an unset entry returns the default value  undefined = array:get(3, A1).   %% Accessing an entry beyond the last set entry also returns the  %% default value, if the array does not have fixed size  undefined = array:get(18, A1).   %% "sparse" functions ignore default-valued entries  A2 = array:set(4, false, A1).  [{4, false}, {17, true}] = array:sparse_to_orddict(A2).   %% An extendible array can be made fixed-size later  A3 = array:fix(A2).   %% A fixed-size array does not grow automatically and does not  %% allow accesses beyond the last set entry  {'EXIT',{badarg,_}} = (catch array:set(18, true, A3)).  {'EXIT',{badarg,_}} = (catch array:get(18, A3)). `

## ERRE

To declare array variables (with their associated type):

``` DIM A%[100]   ! integer array
DIM S\$[50]    ! string array
DIM R[50]     ! real array
DIM R#[70]    ! long real array
```

Index starts from 0: you can start from 1 by using a pragma directive

``` !\$BASE=1
```

Subscripts can be a constant like:

``` CONST MX=100
.......
DIM A%[MX]
```

ERRE arrays are static (known at compile-time) but you can declare dynamic arrays (subscripts depends from a user' input):

``` !\$DYNAMIC
DIM A%[0]   ! dummy declaration
.......
BEGIN
INPUT(NUM)
!\$DIM A%[NUM]
.......
```

You can also redimensioning arrays with ERASE clause:

```    !\$RCODE="ERASE A%"
INPUT(NUM2)
!\$DIM A%[NUM2]
```

Unfortunately there is no PRESERVE clause, so after an ERASE all array values are lost.

Values can be assigned to an array by a DATA..READ statements, by an INPUT or by normal assignment:

```   DATA(0,1,2,3,4,5,6,7,8,9,10)
FOR I%=0 TO 10 DO
END FOR
```

It's possible to assign an array to another (same type and dimensions) with

```   B%[]=A%[]
```

Arrays are global object in an ERRE module: in the next revision there will be a LOCAL DIM statement for "local arrays".

## Euphoria

` --Arrays task for Rosetta Code wiki--User:Lnettnay atom dummy--Arrays are sequences-- single dimensioned array of 10 elementssequence xarray = repeat(0,10)xarray[5] = 5dummy = xarray[5]? dummy --2 dimensional array--5 sequences of 10 elements eachsequence xyarray = repeat(repeat(0,10),5)xyarray[3][6] = 12dummy = xyarray[3][6]? dummy --dynamic array use (all sequences can be modified at any time)sequence dynarray = {}for x = 1 to 10 do          dynarray = append(dynarray, x * x)end for? dynarray   for x = 1 to 10 do        dynarray = prepend(dynarray, x)end for? dynarray `
Output:
```5
12
{1,4,9,16,25,36,49,64,81,100}
{10,9,8,7,6,5,4,3,2,1,1,4,9,16,25,36,49,64,81,100}
```

## Explore

The Scratch solution, which requires making an array named "array" first, works, unmodified:
https://i.ibb.co/Hp6dLXX/Arrays-in-Explore-using-the-Scratch-solution.png

This example uses a special block located in the Strings category, and outputs the results of the repeating of the string to a "say" block, and additionally starts when the flag is activated:
https://i.ibb.co/QN4ys6k/Arrays-in-Explore-using-a-special-block.png

## F#

Fixed-length arrays:

`> Array.create 6 'A';;val it : char [] = [|'A'; 'A'; 'A'; 'A'; 'A'; 'A'|]> Array.init 8 (fun i -> i * 10) ;;val it : int [] = [|0; 10; 20; 30; 40; 50; 60; 70|]> let arr = [|0; 1; 2; 3; 4; 5; 6 |] ;;val arr : int [] = [|0; 1; 2; 3; 4; 5; 6|]> arr.[4];;val it : int = 4> arr.[4] <- 65 ;;val it : unit = ()> arr;;val it : int [] = [|0; 1; 2; 3; 65; 5; 6|]`

Dynamic arrays:

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

`> let arr = new ResizeArray<int>();;val arr : ResizeArray<int>> arr.Add(42);;val it : unit = ()> arr.[0];;val it : int = 42> arr.[0] <- 13;;val it : unit = ()> arr.[0];;val it : int = 13> arr.[1];;> System.ArgumentOutOfRangeException: Index was out of range. Must be non-negative and less than the size of the collection.Parameter name: index ...> arr;;val it : ResizeArray<int> = seq [13]`

## Factor

(cleave applies all the quotations to the initial argument (the array)) This demonstrates array litterals and writing/reading to the array

Directly in the listener :

`{ 1 2 3 }{   [ "The initial array: " write . ]  [ [ 42 1 ] dip set-nth ]  [ "Modified array: " write . ]  [ "The element we modified: " write [ 1 ] dip nth . ]} cleave`
```   The initial array: { 1 2 3 }
Modified array: { 1 42 3 }
The element we modified: 42
```

Arrays of arbitrary length can be created with the <array> word :

```   ( scratchpad - auto ) 10 42 <array> .
{ 42 42 42 42 42 42 42 42 42 42 }
```

Arrays can contain different types :

```   { 1 "coucou" f [ ] }
```

Arrays of growable length are called Vectors.

`V{ 1 2 3 }{   [ "The initial vector: " write . ]  [ [ 42 ] dip push ]  [ "Modified vector: " write . ]} cleave`
```   The initial vector: V{ 1 2 3 }
Modified vector: V{ 1 2 3 42 }
```

Vectors can also be used with set-nth and nth.

```   ( scratchpad - auto ) V{ } [ [ 5 5 ] dip set-nth ] [ . ] bi
V{ 0 0 0 0 0 5 }
```

## FBSL

Various types of FBSL's BASIC arrays are listed below:

``` #APPTYPE CONSOLE DIM v[-1 TO 1] AS VARIANT ' static Variant v[-1] = -1 v[0] = "zero" v[1] = !1.0 FOR EACH DIM e IN v PRINT e, " "; NEXT PRINT DIM i[-1 TO 1] AS INTEGER ' static strong-type Integer/Quad/Single/Double/String i[-1] = -1 i[0] = "zero" i[1] = !1 FOR EACH e IN i PRINT e, " "; NEXT PRINT DIM d[] AS INTEGER ' dynamic growable strong-type Integer/Quad/Single/Double/String d[] = -1 d[] = "zero" d[] = !1 FOR EACH e IN d PRINT e, " "; NEXT PRINT DIM a[] AS VARIANT = {-1, "zero", !1} ' dynamic growable Variant w/ anonymous array initialization FOR EACH e IN a PRINT e, " "; NEXT PRINT FOR EACH e IN {-1, "zero", !1} ' anonymous Variant PRINT e, " "; NEXT PRINT PAUSE```
Output:
``` -1 zero 1.000000-1 0 1-1 0 1-1 zero 1.000000-1 zero 1.000000Press any key to continue... ```

FBSL's Dynamic C supports static and dynamic initialized arrays. Dynamic variable-length arrays are not currently supported.

## Forth

Forth has a variety of ways to allocate arrays of data as contiguous blocks of memory, though it has no built-in array handling words, favoring pointer arithmetic.

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

`create MyArray 1 , 2 , 3 , 4 , 5 ,  5 cells allothere constant MyArrayEnd 30 MyArray 7 cells + !MyArray 7 cells + @ .    \ 30 : .array  MyArrayEnd MyArray do I @ .  cell +loop ;`
` : array ( n -- )  create      dup ,                           \ remember size at offset 0     dup cells here swap 0 fill      \ fill cells with zero     cells allot                     \ allocate memory  does> ( i addr -- )      swap 1+ cells + ;               \ hide offset=0 to index [0..n-1]: [size] -1 ;  10 array MyArray  30 7 MyArray ! 7 MyArray @ .                        \ 30 : 5fillMyArray  5  0 do  I  I MyArray  !  loop ;: .MyArray     [size] MyArray @  0 do  I MyArray  @ .  loop ; .MyArray                             \ 0 0 0 0 0 0 30 0 0 0 5fillMyArray .MyArray                             \ 1 2 3 4 5 0 30 0 0 0  `
` : array  create  dup ,  dup cells here swap 0 fill  cells allot ;: [size] @ ;: [cell] 1+ cells  + ;               \ hide offset=0 to index [0..n-1] 10 array MyArray   30 MyArray 7 [cell] ! MyArray 7 [cell] @ .                 \ 30 : 5fillMyArray  5  0 do  I  MyArray I [cell]  !  loop ;: .MyArray      MyArray [size]  0 do  MyArray I [cell]  @ .  loop ; .MyArray                             \ 0 0 0 0 0 0 30 0 0 0 5fillMyArray .MyArray                             \ 1 2 3 4 5 0 30 0 0 0  `

## Fortran

Works with: Fortran version 90 and later

Basic array declaration:

`integer a (10)`
`integer :: a (10)`
`integer, dimension (10) :: a`

Arrays are one-based. These declarations are equivalent:

`integer, dimension (10) :: a`
`integer, dimension (1 : 10) :: a`

Other bases can be used:

`integer, dimension (0 : 9) :: a`

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

`real, dimension (10) :: a`
`type (my_type), dimension (10) :: a`

Multidimensional array declaration:

`integer, dimension (10, 10) :: a`
`integer, dimension (10, 10, 10) :: a`

Allocatable array declaration:

`integer, dimension (:), allocatable :: a`
`integer, dimension (:, :), allocatable :: a`

Array allocation:

`allocate (a (10))`
`allocate (a (10, 10))`

Array deallocation:

`deallocate (a)`

Array initialisation:

`integer, dimension (10) :: a = (/1, 2, 3, 4, 5, 6, 7, 8, 9, 10/)`
`integer :: iinteger, dimension (10) :: a = (/(i * i, i = 1, 10)/)`
`integer, dimension (10) :: a = 0`
`integer :: iinteger, dimension (10, 10) :: a = reshape ((/(i * i, i = 1, 100)/), (/10, 10/))`

Constant array declaration:

`integer :: iinteger, dimension (10), parameter :: a = (/(i * i, i = 1, 10)/)`

Element assignment:

`a (1) = 1`
`a (1, 1) = 1`

Array assignment (note that since Fortran 2003 array assignment also allocates or reallocates if necessary):

`a = (/1, 2, 3, 4, 5, 6, 7, 8, 9, 10/)`
`a = (/(i * i, i = 1, 10)/)`
`a = reshape ((/(i * i, i = 1, 100)/), (/10, 10/))`
`a = 0`

Array section assignment:

`a (:) = (/1, 2, 3, 4, 5, 6, 7, 8, 9, 10/)`
`a (1 : 5) = (/1, 2, 3, 4, 5/)`
`a (: 5) = (/1, 2, 3, 4, 5/)`
`a (6 :) = (/1, 2, 3, 4, 5/)`
`a (1 : 5) = (/(i * i, i = 1, 10)/)`
`a (1 : 5)= 0`
`a (1, :)= (/(i * i, i = 1, 10)/)`
`a (1 : 5, 1)= (/(i * i, i = 1, 5)/)`

Element retrieval:

`i = a (1)`

Array section retrieval:

`a = b (1 : 10)`

Size retrieval:

`i = size (a)`

Size along a single dimension retrieval:

`i = size (a, 1)`

Bounds retrieval:

`i_min = lbound (a)`
`i_max = ubound (a)`

Bounds of a multidimensional array retrieval:

`a = ubound (b)`

## FreeBASIC

This info only applies for the default setting fb. For the other modes [fblite, qb, deprecated] other keywords and restrictions apply. Consult the FreeBASIC manual for those modes.

Parts of the info was taken from the FreeBASIC manual.

Arrays limits Maximum Subscript Range [-2147483648, +2147483647] [*] Maximum Elements per Dimension +2147483647 [*] Minimum/Maximum Dimensions 1/9 Maximum Size (in bytes) +2147483647 [*]

[*] All runtime library array procedures take and produce Integer values for subscripts and indexes. The actual limits will vary (smaller) with the number of dimensions, element size, storage location and/or platform.

Every Data Type that is allowed in FreeBASIC can be used for an array. (Integer, Double, String, UDT etc.)

Static Specifies static storage arrays; they are allocated at program startup and deallocated upon exit. Shared makes module-level array's visible inside Subs and Functions. Dim fixed length. ReDim variable length. Preserve can only be used With ReDim. If the array is resized, data is not reset but is preserved. Erase statement to erase arrays, clear the elements.

Fixed length array are created in the stack Space, if this space is to small the compiler will issue a warning. "Array too large for stack, consider making it var-len or Shared" You can make the array var-len by using Redim or use Dim Shared instead of Dim.

By default the bounds check is off, you can add the checks by adding the command line option -exx.(will slow the program down)

The default lower bound is always 0

`' compile with: FBC -s console. ' compile with: FBC -s console -exx to have boundary checks. Dim As Integer a(5)  ' from s(0) to s(5)Dim As Integer num = 1Dim As String s(-num To num) ' s1(-1), s1(0) and s1(1) Static As UByte c(5) ' create a  array with 6 elements (0 to 5) 'dimension array and initializing it with DataDim d(1 To 2, 1 To 5) As Integer => {{1, 2, 3, 4, 5}, {1, 2, 3, 4, 5}}Print "  The first dimension has a lower bound of"; LBound(d);_                           " and a upper bound of"; UBound(d)Print " The second dimension has a lower bound of"; LBound(d,2);_                           " and a upper bound of"; UBound(d,2)Print : Print Dim Shared As UByte u(0 To 3) ' make a shared array of UByte with 4 elements Dim As UInteger pow() ' make a variable length array' you must Dim the array before you can use ReDimReDim pow(num) ' pow now has 1 elementpow(num) = 10  ' lets fill it with 10 and print itPrint " The value of pow(num) = "; pow(num) ReDim pow(10)  ' make pow a 10 element arrayPrintPrint " Pow now has"; UBound(pow) - LBound(pow) +1; " elements"' the value of pow(num) is gone nowPrint " The value of pow(num) = "; pow(num); ", should be 0" PrintFor i As Integer = LBound(pow) To UBound(pow)    pow(i) = i * i    Print pow(i),NextPrint:Print ReDim Preserve pow(3 To 7)' the first five elements will be preserved, not elements 3 to 7PrintPrint " The lower bound is now"; LBound(pow);_      " and the upper bound is"; UBound(pow)Print " Pow now has"; UBound(pow) - LBound(pow) +1; " elements"PrintFor i As Integer = LBound(pow) To UBound(pow)    Print pow(i),NextPrint : Print 'erase the variable length arrayErase powPrint " The lower bound is now"; LBound(pow);_     " and the upper bound is "; UBound(pow)Print " If the lower bound is 0 and the upper bound is -1 it means,"Print " that the array has no elements, it's completely removed"Print : Print 'erase the fixed length arrayPrint " Display the contents of the array d"For i As Integer = 1 To 2 : For j As Integer = 1 To 5    Print d(i,j);" ";Next : Next : Print : Print  Erase dPrint " We have erased array d"Print "  The first dimension has a lower bound of"; LBound(d);_                           " and a upper bound of"; UBound(d)Print " The second dimension has a lower bound of"; LBound(d,2);_                           " and a upper bound of"; UBound(d,2)PrintFor i As Integer = 1 To 2 : For j As Integer = 1 To 5    Print d(i,j);" ";Next : NextPrintPrint " The elements self are left untouched but there content is set to 0" ' empty keyboard buffer While InKey <> "" : WendPrint : Print "hit any key to end program"SleepEnd`
Output:
```  The first dimension has a lower bound of 1 and a upper bound of 2
The second dimension has a lower bound of 1 and a upper bound of 5

The value of pow(num) = 10

Pow now has 11 elements
The value of pow(num) = 0, should be 0

0             1             4             9             16
25            36            49            64            81
100

The lower bound is now 3 and the upper bound is 7
Pow now has 5 elements

0             1             4             9             16

The lower bound is now 0 and the upper bound is -1
If the lower bound is 0 and the upper bound is -1 it means,
that the array has no elements, it completely removed

Display the contents of the array d
1  2  3  4  5  1  2  3  4  5

We have erased array d
The first dimension has a lower bound of 1 and a upper bound of 2
The second dimension has a lower bound of 1 and a upper bound of 5

0  0  0  0  0  0  0  0  0  0
The elements self are left untouched but there content is set to 0```

## Frink

In Frink, all arrays are dynamically resizable. Arrays can be created as literals or using `new array`

` a = new array[email protected] = 10[email protected] = 20println[[email protected]] b = [1, 2, 3] `

## Futhark

 This example is incorrect. Please fix the code and remove this message.Details: The language's syntax has changed, so "fun" should be "let"

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

## 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[] mynumbers[0] = 1.5mynumbers[1] = 2.3 myfruits[0] = "apple"myfruits[1] = "banana" `

In Gambas, you DO need to dimension arrays. The first element of an array is numbered zero. The DIM statement is optional and can be omitted ONLY if defined as a Global variable.

`Public Sub Main()Dim sFixedArray As String[] = ["Rosetta", "code", "is", "a", "programming", "chrestomathy", "site"]Dim sFixedArray1 As New String[10]Dim iDynamicArray As New Integer[]Dim siCount As Short For siCount = 1 To 10  iDynamicArray.Add(siCount)Next sFixedArray1[5] = "Hello"sFixedArray1[6] = " world!" Print sFixedArray.Join(" ")Print iDynamicArray[5] Print sFixedArray1[5] & sFixedArray1[6] End`

Output:

```Rosetta code is a programming chrestomathy site
6
Hello world!
```

## GAP

`# Arrays are better called lists in GAP. Lists may have elements of mixed types, e\$v := [ 10, 7, "bob", true, [ "inner", 5 ] ];# [ 10, 7, "bob", true, [ "inner", 5 ] ] # List index runs from 1 to Size(v)v[1];# 10 v[0];# error v[5];# [ "inner", 5 ] v[6];# error # One can assign a value to an undefined elementv[6] := 100; # Even if it's not after the last: a list may have undefined elementsv[10] := 1000;v;# [ 10, 7, "bob", true, [ "inner", 5 ], 100,,,, 1000 ] # And one can check for defined valuesIsBound(v[10]);# true IsBound(v[9]);# false # Size of the listSize(v);# 10 # Appending a list to the end of anotherAppend(v, [ 8, 9]);v;# [ 10, 7, "bob", true, [ "inner", 5 ], 100,,,, 1000, 8, 9 ] # Adding an element at the endAdd(v, "added");v;# [ 10, 7, "bob", true, [ "inner", 5 ], 100,,,, 1000, 8, 9, "added" ]`

## Genie

`[indent=4]/*    Arrays, in Genie    valac --pkg=gee-0.8 arrays.gs   ./arrays */ uses    Gee init    /* allocate a fixed array */    var arr = new array of int[10]     /* initialized array of strings */    initialized:array of string = {"This", "is", "Genie"}     /* length is an array property */    stdout.printf("%d\n", arr.length)     /* read/write access via index */    arr[1] = 1    arr[9] = arr[1] + 8    stdout.printf("%d\n", arr[9])     print initialized[2]     /* Dynamic arrays are lists in Genie */    var dyn = new list of int    dyn.add(1)    dyn.add(8)    dyn.add(dyn[0]+dyn[1])    stdout.printf("dyn size: %d\n", dyn.size)    stdout.printf("dyn[2]  : %d\n", dyn[2])`
Output:
```prompt\$ valac --pkg=gee-0.8 arrays.gs && ./arrays
10
9
Genie
dyn size: 3
dyn[2]  : 9```

## GML

### 1-Dimensional Array Examples

#### Example of Fixed Length Array

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

`array[0] = ' 'array[1] = 'A'array[2] = 'B'array[3] = 'C'`

#### Example of Arbitrary Length Array

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

`for(i = 0; i < k; i += 1)    array[i] = i + 1`

### 2-Dimensional Array Examples

#### Example of Fixed Length Array

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

`array[1,1] = 1array[1,2] = 2array[1,3] = 3array[1,4] = 4array[2,1] = 2array[2,2] = 4array[2,3] = 6array[2,4] = 8array[3,1] = 3array[3,2] = 6array[3,3] = 9array[3,4] = 12`

#### Example of Arbitrary Length Array

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

`for(i = 1; i <= k; i += 1)    for(j = 1; j <= h; j += 1)        array[i,j] = i * j`

## Go

`package main import (    "fmt") func main() {    // creates an array of five ints.    // specified length must be a compile-time constant expression.    // this allows compiler to do efficient bounds checking.    var a [5]int     // since length is compile-time constant, len() is a compile time constant    // and does not have the overhead of a function call.    fmt.Println("len(a) =", len(a))     // elements are always initialized to 0    fmt.Println("a =", a)     // assign a value to an element.  indexing is 0 based.    a[0] = 3    fmt.Println("a =", a)     // retrieve element value with same syntax    fmt.Println("a[0] =", a[0])     // a slice references an underlying array    s := a[:4] // this does not allocate new array space.    fmt.Println("s =", s)     // slices have runtime established length and capacity, but len() and    // cap() are built in to the compiler and have overhead more like    // variable access than function call.    fmt.Println("len(s) =", len(s), " cap(s) =", cap(s))     // slices can be resliced, as long as there is space    // in the underlying array.    s = s[:5]    fmt.Println("s =", s)     // s still based on a    a[0] = 22    fmt.Println("a =", a)    fmt.Println("s =", s)     // append will automatically allocate a larger underlying array as needed.    s = append(s, 4, 5, 6)    fmt.Println("s =", s)    fmt.Println("len(s) =", len(s), " cap(s) =", cap(s))     // s no longer based on a    a[4] = -1    fmt.Println("a =", a)    fmt.Println("s =", s)     // make creates a slice and allocates a new underlying array    s = make([]int, 8)    fmt.Println("s =", s)    fmt.Println("len(s) =", len(s), " cap(s) =", cap(s))     // the cap()=10 array is no longer referenced    // and would be garbage collected eventually.}`
Output:
```len(a) = 5
a = [0 0 0 0 0]
a = [3 0 0 0 0]
a[0] = 3
s = [3 0 0 0]
len(s) = 4  cap(s) = 5
s = [3 0 0 0 0]
a = [22 0 0 0 0]
s = [22 0 0 0 0]
s = [22 0 0 0 0 4 5 6]
len(s) = 8  cap(s) = 10
a = [22 0 0 0 -1]
s = [22 0 0 0 0 4 5 6]
s = [0 0 0 0 0 0 0 0]
len(s) = 8  cap(s) = 8```

## Golfscript

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.

`[1 2 3]:a; # numeric only array, assigned to a and then dropped10,: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 a10 a+puts  # prepend 10 to a`

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

## 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 aa = [ 1, 25, 31, -3 ]           // listdef a = [0] * 100                    // list of 100 zeroesdef b = 1..9                         // range notationdef c = (1..10).collect { 2.0**it }  // each output element is 2**(corresponding invoking list element) // There are no true "multi-dimensional" arrays in Groovy (as in most C-derived languages).// Use lists of lists in natural ("row major") order as a stand in.def d = (0..1).collect { i -> (1..5).collect { j -> 2**(5*i+j) as double } }def e = [ [  1.0,  2.0,  3.0,  4.0 ],          [  5.0,  6.0,  7.0,  8.0 ],          [  9.0, 10.0, 11.0, 12.0 ],          [ 13.0, 14.0, 15.0, 16.0 ] ] println aaprintln bprintln cprintln()d.each { print "["; it.each { elt -> printf "%7.1f ", elt }; println "]" }println()e.each { print "["; it.each { elt -> printf "%7.1f ", elt }; println "]" }`
Output:
```[1, 25, 31, -3]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]

[    2.0     4.0     8.0    16.0    32.0 ]
[   64.0   128.0   256.0   512.0  1024.0 ]

[    1.0     2.0     3.0     4.0 ]
[    5.0     6.0     7.0     8.0 ]
[    9.0    10.0    11.0    12.0 ]
[   13.0    14.0    15.0    16.0 ]```

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

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

Test program:

`def i2 = identity(2)def i15 = identity(15)  i2.each { print "["; it.each { elt -> printf "%4.1f ", elt }; println "]" }println()i15.each { print "["; it.each { elt -> printf "%4.1f ", elt }; println "]" }`
Output:
```[ 1.0  0.0 ]
[ 0.0  1.0 ]

[ 1.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0 ]
[ 0.0  1.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0 ]
[ 0.0  0.0  1.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0 ]
[ 0.0  0.0  0.0  1.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0 ]
[ 0.0  0.0  0.0  0.0  1.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0 ]
[ 0.0  0.0  0.0  0.0  0.0  1.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0 ]
[ 0.0  0.0  0.0  0.0  0.0  0.0  1.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0 ]
[ 0.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0 ]
[ 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0  0.0  0.0  0.0  0.0  0.0  0.0 ]
[ 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0  0.0  0.0  0.0  0.0  0.0 ]
[ 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0  0.0  0.0  0.0  0.0 ]
[ 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0  0.0  0.0  0.0 ]
[ 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0  0.0  0.0 ]
[ 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0  0.0 ]
[ 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0 ]```

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

`def strings = ['Mary', 'had', 'a', 'little', 'lamb', ". It's", 'fleece', 'was', 'white', 'as', 'snow'] println strings strings[0] = 'Arthur'strings[4] = 'towel'strings[6] = 'stain'strings[8] = 'ripe'strings[10] = 'strawberries' println strings`
Output:
```["Mary", "had", "a", "little", "lamb", ". It's", "fleece", "was", "white", "as", "snow"]
["Arthur", "had", "a", "little", "towel", ". It's", "stain", "was", "ripe", "as", "strawberries"]
```

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

`println strings[-1]`
Output:
```strawberries
```

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

`println strings[0, 7, 2, 3, 8]println strings[0..4]println strings[0..3, -5]`
Output:
```["Arthur", "was", "a", "little", "ripe"]
```

## GUISS

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:

`Start,Programs,Lotus 123,Type:Bob[downarrow],Kat[downarrow],Sarah[downarrow]`

## GW-BASIC

"An array, once dimensioned, cannot be re-dimensioned within the program without first executing a CLEAR or ERASE statement." (GW-BASIC User's Guide)

`10 DATA 0, 1, 2, 3, 4, 5, 6, 7, 8, 920 DIM A(9)        ' Array with size 10 (9 is maximum subscript), all elements are set to 030 FOR I = 0 TO 940     READ A(I)   ' Initialize by reading data50 NEXT I60 PRINT A(4)      ' Get 4th element of array70 A(4) = 400      ' Set 4th element of array80 PRINT A(4) `

## Halon

`\$array = []; \$array[] = 1;\$array["key"] = 3; \$array[0] = 2; echo \$array[0];echo \$array["key"];`

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

`   // Declare and initialize two-dimensional array   local arr1 := { { "NITEM", "N", 10, 0 }, { "CONTENT", "C", 60, 0 } }   // Create an empty array   local arr2 := {}   // Declare three-dimensional array   local arr3[ 2, 100, 3 ]   // Create an array   local arr4 := Array( 50 )    // Array can be dynamically resized:   arr4 := ASize( arr4, 80 )`

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

`// Adding new item to array, its size is incremented   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   arr3[ 1, 1, 1 ] := 11.4`

Retrieve items of an array:

`   x := arr3[ 1, 10, 2 ]// 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:

`// Fill the 20 items of array with 0, starting from 5-th item:   AFill( arr4, 0, 5, 20 )// Copy 10 items from arr4 to arr3[ 2 ], starting from the first position:   ACopy( arr4, arr3[ 2 ], 1, 10 )// Duplicate the whole or nested array:   arr5 := AClone( arr1 )   arr6 := AClone( arr1[ 3 ] )`

`import Data.Array.IO main = do arr <- newArray (1,10) 37 :: IO (IOArray Int Int)          a <- readArray arr 1          writeArray arr 1 64          b <- readArray arr 1           print (a,b)`

## hexiscript

`let a    arr 2  # fixed sizelet a[0] 123    # index starting at 0let a[1] "test" # can hold different types println a[1]`

## HicEst

`REAL :: n = 3, Astat(n), Bdyn(1, 1) Astat(2) = 2.22222222WRITE(Messagebox, Name) Astat(2) ALLOCATE(Bdyn, 2*n, 3*n)Bdyn(n-1, n) = -123WRITE(Row=27) Bdyn(n-1, n) ALIAS(Astat, n-1,   last2ofAstat, 2)WRITE(ClipBoard) last2ofAstat      ! 2.22222222 0 `

## HolyC

`// Create an array of fixed sizeU8 array[10] = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10; // The first element of a HolyC array is indexed at 0. To set a value:array[0] = 123; // Access an elementPrint("%d\n", array[0]);`

## Icon and Unicon

### Icon

`record aThing(a, b, c)       # arbitrary object (record or class) for illustration procedure main()    A0 := []                 # empty list    A0 := list()             # empty list (default size 0)    A0 := list(0)            # empty list (literal size 0)     A1 := list(10)           # 10 elements, default initializer &null    A2 := list(10, 1)        # 10 elements, initialized to 1     # literal array construction - arbitrary dynamically typed members    A3 := [1, 2, 3, ["foo", "bar", "baz"], aThing(1, 2, 3), "the end"]     # left-end workers    # NOTE: get() is a synonym for pop() which allows nicely-worded use of put() and get() to implement queues    #    Q := [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]    x := pop(A0)        # x is 1    x := get(A0)        # x is 2    push(Q,0)    # Q is now [0,3, 4, 5, 6, 7, 8, 9, 10]     # right-end workers    x := pull(Q)        # x is 10    put(Q, 100)         # Q is now [0, 3, 4, 5, 6, 7, 8, 9, 100]     # push and put return the list they are building    # they also can have multiple arguments which work like repeated calls     Q2 := put([],1,2,3)    # Q2 is [1,2,3]    Q3 := push([],1,2,3)   # Q3 is [3,2,1]    Q4 := push(put(Q2),4),0] # Q4 is [0,1,2,3,4] and so is Q2     # array access follows with A as the sample array    A := [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]     # get element indexed from left    x := A[1]           # x is 10    x := A[2]           # x is 20    x := A[10]          # x is 100     # get element indexed from right    x := A[-1]          # x is 100    x := A[-2]          # x is 90    x := A[-10]         # x is 10     # copy array to show assignment to elements    B := copy(A)     # assign element indexed from left    B[1] := 11    B[2] := 21    B[10] := 101    # B is now [11, 21, 30, 50, 60, 60, 70, 80, 90, 101]     # assign element indexed from right - see below    B[-1] := 102    B[-2] := 92    B[-10] := 12    # B is now [12, 21, 30, 50, 60, 60, 70, 80, 92, 102]     # list slicing    # the unusual nature of the slice - returning 1 less element than might be expected    # in many languages - is best understood if you imagine indexes as pointing to BEFORE    # the item of interest. When a slice is made, the elements between the two points are    # collected. eg in the A[3 : 6] sample, it will get the elements between the [ ] marks    #    # sample list:              10  20 [30  40  50] 60  70  80  90  100    # positive indexes:        1   2   3   4   5   6   7   8   9   10  11    # non-positive indexes:  -10  -9  -8  -7  -6  -5  -4  -3  -2  -1   0    #    # I have deliberately drawn the indexes between the positions of the values.    # The nature of this indexing brings simplicity to string operations    #    # list slicing can also use non-positive indexes to access values from the right.    # The final index of 0 shown above shows how the end of the list can be nominated    # without having to know it's length    #    # NOTE: list slices are distinct lists, so assigning to the slice    # or a member of the slice does not change the values in A    #    # Another key fact to understand: once the non-positive indexes and length-offsets are    # resolved to a simple positive index, the index pair (if two are given) are swapped    # if necessary to yield the elements between the two.    #    S := A[3 : 6]       # S is [30, 40, 50]    S := A[6 : 3]       # S is [30, 40, 50]   not illegal or erroneous    S := A[-5 : -8]     # S is [30, 40, 50]    S := A[-8 : -5]     # S is [30, 40, 50]   also legal and meaningful     # list slicing with length request    S := A[3 +: 3]      # S is [30, 40, 50]    S := A[6 -: 3]      # S is [30, 40, 50]    S := A[-8 +: 3]     # S is [30, 40, 50]    S := A[-5 -: 3]     # S is [30, 40, 50]    S := A[-8 -: -3]    # S is [30, 40, 50]    S := A[-5 +: -3]    # S is [30, 40, 50]end`

### Unicon

This Icon solution works in Unicon.

`# Unicon provides a number of extensions# insert and delete work on lists allowing changes in the middle# possibly others `
 This example is in need of improvement: Need code examples for these extensions

## i

`main	//Fixed-length arrays.	f \$= array.integer[1]()	f[0] \$= 2	print(f[0]) 	//Dynamic arrays.	d \$= list.integer()	d[+] \$= 2	print(d[1])}`

## Io

`foo := list("foo", "bar", "baz")foo at(1) println // barfoo append("Foobarbaz")foo printlnfoo atPut(2, "barbaz") // baz becomes barbaz`
```Io> foo := list("foo", "bar", "baz")
==> list(foo, bar, baz)
Io> foo at(1) println // bar
bar
==> bar
Io> foo append("Foobarbaz")
==> list(foo, bar, baz, Foobarbaz)
Io> foo println
list(foo, bar, baz, Foobarbaz)
==> list(foo, bar, baz, Foobarbaz)
Io> foo atPut(2, "barbaz") // baz becomes barbaz
==> list(foo, bar, barbaz, Foobarbaz)
Io>
```

## J

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

`   1                          NB. a stand-alone scalar value is an array without any axis1   NB. invoking any array produces that array as the result   {. array=: 1 3, 6#0        NB. create, name, then get head item of the array: 1 3 0 0 0 0 0 01   0 { array                  NB. another way to get the head item1   aword=: 'there'            NB. a literal array   0 1 3 2 2 { aword          NB. multiple items can be drawn in a single actionthree   ]twoD=: 3 5 \$ 'abcdefghijklmnopqrstuvwxyz'abcdefghijklmno   1 { twoD                   NB. item 1 from twoD - a list of three itemsfghij   1 {"1 twoD                 NB. item 1 from each rank-1 item of twoD (i.e. column 1)bgl   (<2 2){ twoD               NB. bracket indexing is not used in Jm   'X' 1} aword               NB. amend item 1tXere   aword=: 'X' 1 4} aword     NB. in-place amend of items 1 and 4tXerX   'X' (0 0;1 1;2 2)} twoD    NB. amend specified itemsXbcdefXhijklXno`

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

## Java

`int[] array = new int[10]; //optionally, replace "new int[10]" with a braced list of ints like "{1, 2, 3}"array[0] = 42;System.out.println(array[3]);`

Dynamic arrays can be made using `List`s:

`List<Integer> list = new ArrayList<Integer>();   // optionally add an initial size as an argumentlist.add(5);   // appends to the end of the listlist.add(1, 6);   // inserts an element at index 1System.out.println(list.get(0));`

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

`// Create a new array with length 0var myArray = new Array(); // Create a new array with length 5var myArray1 = new Array(5); // Create an array with 2 members (length is 2) var myArray2 = new Array("Item1","Item2"); // Create an array with 2 members using an array literalvar myArray3 = ["Item1", "Item2"]; // Assign a value to member [2] (length is now 3)myArray3[2] = 5; var x = myArray[2] + myArray.length;   // 8 // You can also add a member to an array with the push function (length is now 4)myArray3.push('Test'); // Elisions are supported, but are buggy in some implementationsvar y = [0,1,,];  // length 3, or 4 in buggy implementations  `

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

There are, however, some interesting extensions, e.g. [][4] = null creates an array of length 5 as explained below.
`# Create a new array with length 0[] # Create a new array of 5 nulls[][4] = null   # setting the element at offset 4 expands the array # Create an array having the elements 1 and 2 in that order [1,2] # Create an array of integers from 0 to 10 inclusive[ range(0; 11) ] # If a is an array (of any length), update it so that a[2] is 5a[2] = 5; # Append arrays a and ba + b # Append an element, e, to an array aa + [e] ################################################### In the following, a is assumed to be [0,1,2,3,4] # It is not an error to use an out-of-range index:a[10]  # => null # Negative indices count backwards from after the last element:a[-1]  # => 4 # jq supports simple slice operations but# only in the forward direction:a[:1]  # => [0]a[1:]  # => [1,2,3,4]a[2:4] # => [2,3]a[4:2] # null`

## Jsish

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

`/* Arrays in Jsi */// Create a new array with length 0var myArray = new Array();;myArray; // In Jsi, typeof [] is "array".  In ECMAScript, typeof [] is "object";typeof []; // Create a new array with length 5var myArray1 = new Array(5);;myArray1; // Create an array with 2 members (length is 2) var myArray2 = new Array("Item1","Item2");;myArray2;;myArray2.length; // Create an array with 2 members using an array literalvar myArray3 = ["Item1", "Item2"];;myArray3; // Assign a value to member [2] (length is now 3)myArray3[2] = 5;;myArray3;;myArray3.length; var x = myArray3[2] + myArray3.length;   // 8;x; // You can also add a member to an array with the push function (length is now 4)myArray3.push('Test');;myArray3;;myArray3.length; // Empty array entries in a literal is a syntax error, elisions not allowed//var badSyntax = [1,2,,4];  /*=!EXPECTSTART!=myArray ==> []typeof [] ==> arraymyArray1 ==> [ undefined, undefined, undefined, undefined, undefined ]myArray2 ==> [ "Item1", "Item2" ]myArray2.length ==> 2myArray3 ==> [ "Item1", "Item2" ]myArray3 ==> [ "Item1", "Item2", 5 ]myArray3.length ==> 3x ==> 8myArray3 ==> [ "Item1", "Item2", 5, "Test" ]myArray3.length ==> 4=!EXPECTEND!=*/`
Output:
```prompt\$ jsish -u arrays.jsi
PASS] arrays.jsi```

## Julia

Julia has both heterogeneous arrays and typed arrays.

```julia> A = cell(3)   # create an heterogeneous array of length 3
3-element Array{Any,1}:
#undef
#undef
#undef

julia> A[1] = 4.5 ; A[3] =  "some string" ; show(A)
{4.5,#undef,"some string"}

julia> A[1]          # access a value. Arrays are 1-indexed
4.5

julia> push!(A, :symbol) ; show(A)    # append an element
{4.5,#undef,"some string",:symbol}

julia> A[10]         # error if the index is out of range
ERROR: BoundsError()```

For typed arrays, the type can be specified explicitely or infered from its elements.

```julia> B = Array(String, 3) ; B[1]="first" ; push!(B, "fourth") ; show(B)
["first",#undef,#undef,"fourth"]

julia> push!(B, 3)   # type error
ERROR: no method convert(Type{String}, Int64)
in push! at array.jl:488

julia> ['a':'c']     # type inference
3-element Array{Char,1}:
'a'
'b'
'c'```

## KonsolScript

`//creates an array of length 3Array:New array[3]:Number; function main() {  Var:Number length;  Array:GetLength(array, length)  //retrieve length of array  Konsol:Log(length)   array[0] = 5;                   //assign value  Konsol:Log(array[0])            //retrieve value and display}`

## Kotlin

`fun main(x: Array<String>) {    var a = arrayOf(1, 2, 3, 4)    println(a.asList())    a += 5    println(a.asList())    println(a.reversedArray().asList())}`
Output:
```[1, 2, 3, 4]
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]```

## LabVIEW

This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.

## Lambdatalk

` // Create a new array with length 0{def myArray1 {A.new}}-> [] // Create an array with 2 members (length is 2) {def myArray2 {A.new Item1 Item2}}-> [Item1,Item2] // Edit a value in an array{def myArray3 {A.new 1 2 3}}{A.set! 1 hello {myArray3}}-> [1,hello,3] // Add a value at the head of an array{def myArray4 {A.new 1 2 3}}-> myArray4 {A.addfirst! hello {myArray4}}-> [hello,1,2,3] // Add a value at the tail of an array{def myArray5 {A.new 1 2 3}}{A.addlast! hello {myArray5}}-> [1,2,3,hello] and so on... `

## lang5

`[]1 append['foo 'bar] append2 reshape0 remove 2 swap 2 compress collapse .`

## langur

Langur uses 1-based indexing.

`var .a1 = [1, 2, 3, "abc"]val .a2 = series 4..10val .a3 = .a1 ~ .a2 writeln "initial values ..."writeln ".a1: ", .a1writeln ".a2: ", .a2writeln ".a3: ", .a3writeln() .a1[4] = .a2[4]writeln "after setting .a1[4] = .a2[4] ..."writeln ".a1: ", .a1writeln ".a2: ", .a2writeln ".a3: ", .a3writeln() writeln ".a2[1]: ", .a2[1]writeln() writeln "using index alternate ..."writeln ".a2[5; 0]: ", .a2[5; 0]writeln ".a2[10; 0]: ", .a2[10; 0]writeln()`
Output:
```initial values ...
.a1: [1, 2, 3, "abc"]
.a2: [4, 5, 6, 7, 8, 9, 10]
.a3: [1, 2, 3, "abc", 4, 5, 6, 7, 8, 9, 10]

after setting .a1[4] = .a2[4] ...
.a1: [1, 2, 3, 7]
.a2: [4, 5, 6, 7, 8, 9, 10]
.a3: [1, 2, 3, "abc", 4, 5, 6, 7, 8, 9, 10]

.a2[1]: 4

using index alternate ...
.a2[5; 0]: 8
.a2[10; 0]: 0
```

## Lasso

Lasso Array [1] 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.

`// Create a new empty arraylocal(array1) = array // Create an array with 2 members (#myarray->size is 2) local(array1) = array('ItemA','ItemB') // Assign a value to member [2] #array1->get(2) = 5 // Retrieve a value from an array#array1->get(2) + #array1->size // 8 // Merge arrayslocal(    array1 = array('a','b','c'),    array2 = array('a','b','c'))#array1->merge(#array2) // a, b, c, a, b, c // Sort an array#array1->sort // a, a, b, b, c, c // Remove value by index#array1->remove(2) // a, b, b, c, c // Remove matching items#array1->removeall('b') // a, c, c // Insert item#array1->insert('z')  // a, c, c, z // Insert item at specific position#array1->insert('0',1)  // 0, a, c, c, z`

### Static Arrays

Lasso also supports Static Arrays[2]. 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.

`// Create a staticarray containing 5 itemslocal(mystaticArray) = staticarray('a','b','c','d','e') // Retreive an item#mystaticArray->get(3) // c // Set an item#mystaticArray->get(3) = 'changed' // a, b, changed, d, e // Create an empty static array with a length of 32local(mystaticArray) = staticarray_join(32,void)`

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

`;; Construct an array.foo := [1, 2, 3]. ;; Arrays can also be constructed explicitly.bar := Array clone.bar pushBack (1).bar pushBack (2).bar pushBack (3). ;; Accessing values.println: foo nth (2). ;; 3 ;; Mutating values.foo nth (1) = 99.println: foo. ;; [1, 99, 3] ;; Appending to either the front or the back of the array.foo pushBack ("back").foo pushFront ("front").println: foo. ;; ["front", 1, 99, 3, "back"] ;; Popping from the front or back.println: foo popBack. ;; "back"println: foo popBack. ;; 3println: foo popFront. ;; "front"println: foo. ;; [1, 99]`

## 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))#(array 10 0 undefined 10)> (: array size a0)10 ; Create an extendible array and set entry 17 to 'true',; causing the array to grow automatically> (set a1 (: array set 17 'true (: array new)))#(array  18  ...(: array size a1)18 ; Read back a stored value> (: array get 17 a1)true ; Accessing an unset entry returns the default value> (: array get 3 a1)undefined ; Accessing an entry beyond the last set entry also returns the; default value, if the array does not have fixed size> (: array get 18 a1)undefined ; "sparse" functions ignore default-valued entries> (set a2 (: array set 4 'false a1))#(array  18  ...> (: array sparse_to_orddict a2)(#(4 false) #(17 true)) ; An extendible array can be made fixed-size later> (set a3 (: array fix a2))#(array  18  ... ; A fixed-size array does not grow automatically and does not; allow accesses beyond the last set entry> (: array set 18 'true a3)exception error: badarg  in (array set 3) > (: array get 18 a3)exception error: badarg  in (array get 2)  `

## Liberty BASIC

Arrays of less than 10 terms need not be dimensioned.
Arrays may only be 1D or 2D.
An empty numeric array term returns '0'. Empty string array terms ="".
'redim'ming allows the array size to be extended, but all existing values are lost.
DATA is READ into variables. It cannot be READ directly into arrays.
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) Array(0) = -1Array(10) =  1 print Array( 0), Array( 10) REDIM Array( 100) print Array( 0), Array( 10) Array( 0) = -1print Array( 0), Array( 10)  `

## LIL

LIL, like Tcl, doesn't manage arrays as such. Indexed lists are used in LIL. The list command creates a list from the remaining arguments in the statement. The index LIST NUM command returns the NUM'th item in the list, starting from zero. Lists are copied on assignment. The array-ish functions and operators would be

• index LIST NUM, returning the NUM'th item
• count LIST, returning the number of items in the list
• indexof LIST VAL, returning the offset from zero position of where VAL is found in LIST, or an empty string
• filter VARNAME LIST EXPRESSION, returning a new list of filtered items matching EXPRESSION, with the value under test in VARNAME.
• list ..., creating a list from remaining word tokens in the statement.
• append LIST VAL (list VAL values are appended as single items to the given LIST)
• slice LIST FROM-NUM TO-NUM
• foreach VARNAME LIST CODE
• charat STRING NUM, indexing a string for characters
• codeat STRING NUM, indexing a string for the character byte code
• lmap LIST VARNAME..., maps the list items to the given variable names, in the order given.

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.

`# (not) Arrays, in LILset a [list abc def ghi]set b [list 4 5 6]print [index \$a 0]print [index \$b 1]print [count \$a]append b [list 7 8 9]print [count \$b]print \$b`
Output:
```prompt\$ lil arrays.lil
abc
5
3
4
4 5 6 {7 8 9}```

By and large, LIL is NOT an array processing language; LIL is a Little Interpreted Language built to deal with strings, commands, and substitutions.

If need arose for tight array processing, LIL is very easy to embed in C applications and extend with new functions that run at speed. If need arises. LIL is small enough, under 4K of source lines, total, that adding extra commands for LIL scripting using C code is quite approachable. If a developer is more comfortable in Pascal, fplil.pas is only 86K characters of source.

## Lingo

`a = [1,2] -- or: a = list(1,2)put a[2] -- or: put a.getAt(2)-- 2a.append(3)put a-- [1, 2, 3]a.deleteAt(2)put a-- [1, 3]a[1] = 5 -- or: a.setAt(1, 5)put a-- [5, 3]a.sort()put a-- [3, 5]`

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:

`ba = bytearray(2, 255) -- initialized with size 2 and filled with 0xffput ba-- <ByteArrayObject length = 2 ByteArray = 0xff, 0xff >ba[1] = 1ba[2] = 2ba[ba.length+1] = 3 -- dynamically increases sizeput ba-- <ByteArrayObject length = 3 ByteArray = 0x1, 0x2, 0x3 >ba[1] = 5put ba-- <ByteArrayObject length = 3 ByteArray = 0x5, 0x2, 0x3 >`

## Lisaac

`+ a : ARRAY(INTEGER);a := ARRAY(INTEGER).create 0 to 9;a.put 1 to 0;a.put 3 to 1;a.item(1).print;`

## Little

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

`String fruit[] = {"apple", "orange", "Pear"}`

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]);fruit[END+1] = "banana";`

## Logo

`array 5      ; default origin is 1, every item is empty(array 5 0)  ; custom originmake "a {1 2 3 4 5}  ; array literalsetitem 1 :a "ten       ; Logo is dynamic; arrays can contain different typesprint item 1 :a   ; ten`

## LOLCODE

`HAI 1.4BTW declaring arrayI HAS A array ITZ A BUKKITBTW store values in array array HAS A one ITZ 1array HAS A two ITZ 2array HAS A three ITZ 3array HAS A string ITZ "MEOW"OBTW there is no way to get an element of an array at a specified index in LOLCODEtherefore, you can't really iterate through an arrayTLDRBTW get the element of array VISIBLE array'Z oneVISIBLE array'Z twoVISIBLE array'Z threeVISIBLE array'Z stringKTHXBYE`

## LSE64

`10 myArray :array0 array 5 [] !      # store 0 at the sixth cell in the arrayarray 5 [] @     # contents of sixth cell in array`

## LSL

LSL does not have Arrays, but it does have lists which can function similar to a one dimensional ArrayList in Java or C#.

` default {    state_entry() {        list lst = ["1", "2", "3"];        llSay(0, "Create and Initialize a List\nList=["+llList2CSV(lst)+"]\n");         lst += ["A", "B", "C"];        llSay(0, "Append to List\nList=["+llList2CSV(lst)+"]\n");         lst = llListInsertList(lst, ["4", "5", "6"], 3);        llSay(0, "List Insertion\nList=["+llList2CSV(lst)+"]\n");         lst = llListReplaceList(lst, ["a", "b", "c"], 3, 5);        llSay(0, "Replace a portion of a list\nList=["+llList2CSV(lst)+"]\n");         lst = llListRandomize(lst, 1);        llSay(0, "Randomize a List\nList=["+llList2CSV(lst)+"]\n");         lst = llListSort(lst, 1, TRUE);        llSay(0, "Sort a List\nList=["+llList2CSV(lst)+"]\n");         lst = [1, 2.0, "string", (key)NULL_KEY, ZERO_VECTOR, ZERO_ROTATION];        string sCSV = llList2CSV(lst);        llSay(0, "Serialize a List of different datatypes to a string\n(integer, float, string, key, vector, rotation)\nCSV=\""+sCSV+"\"\n");         lst = llCSV2List(sCSV);        llSay(0, "Deserialize a string CSV List\n(note that all elements are now string datatype)\nList=["+llList2CSV(lst)+"]\n");    }}`
Output:
```Create and Initialize a List
List=[1, 2, 3]

Append to List
List=[1, 2, 3, A, B, C]

List Insertion
List=[1, 2, 3, 4, 5, 6, A, B, C]

Replace a portion of a list
List=[1, 2, 3, a, b, c, A, B, C]

Randomize a List
List=[2, 3, B, a, A, b, C, c, 1]

Sort a List
List=[1, 2, 3, a, A, b, B, c, C]

Serialize a List of different datatypes to a string
(integer, float, string, key, vector, rotation)
CSV="1, 2.000000, string, 00000000-0000-0000-0000-000000000000, <0.00000, 0.00000, 0.00000>, <0.00000, 0.00000, 0.00000, 1.00000>"

Deserialize a string CSV List
(note that all elements are now string datatype)
List=[1, 2.000000, string, 00000000-0000-0000-0000-000000000000, <0.00000, 0.00000, 0.00000>, <0.00000, 0.00000, 0.00000, 1.00000>]
```

## Lua

Lua does not differentiate between arrays, lists, sets, dictionaries, maps, etc. It supports only one container: Table. Using Lua's simple yet powerful syntax, any of these containers can be emulated. All tables are dynamic. If a static array is necessary, that behavior can be created.

`l = {}l[1] = 1      -- Index starts with 1, not 0.l[0] = 'zero' -- But you can use 0 if you wantl[10] = 2     -- Indexes need not be continuousl.a = 3       -- Treated as l['a']. Any object can be used as indexl[l] = l      -- Again, any object can be used as an index. Even other tablesfor i,v in next,l do print (i,v) end`

## M2000 Interpreter

Here present Arrays of type variant (can be any type, object, pointer to object), and arrays of structures (unsigned numbers plus double and single, and strings including pointers to BSTR). 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      Dim A(10)=1      Global B(10)=1      For This {            Local A(10)=5            Print A(4)=5      }      Print A(4)=1       \\ Auto Array      M=(1,2,3,4,5)      Link M to M()      Print M(2)=3      Return M, 0:=100, 5-4:=300       \\ Retrieve an Element of an Array      k=Each(M, 1, 2)      \\ print 100 300      While k { Print Array(k),}      Print       Print Array(M, 2)=3      Print Array("M", 2)=3      Print Array(B(), 1)=1      \\ arrays are containers for every value/object/pointer      B(0):="Hello",100,"Good Morning", 200      \\ using set to make B\$() global too      Set Link B() to B\$()      Print B\$(0), B(1), B\$(2), B(3)      Swap B(0), B(2)      Swap B(1), B(3)      Print B\$(0), B(1), B\$(2), B(3)      Print B()      \\ Reduce B() to 4 elements - and change dimensions      \\ we have to redim the global array, using set to send line to console      \\ all globals are part of level 0, at console input.      Set Dim B(4)      Module CheckGlobal {            Print B\$(0), B(1), B\$(2), B(3)      }      CheckGlobal      Print B()      Dim BB(4)      \\ Copy 4 items from B() to BB(), from B(0), to BB(0)      Stock B(0) keep 4, BB(0)      Link BB() to BB\$()      Print BB\$(0), BB(1), BB\$(2), BB(3)      \\ Arrays of structures in Buffers       Structure TwoByte {            {                  ab as integer            }            a as byte            b as byte      }      Print Len(TwoByte) = 2      \ Use clear to clear memory      \\ Mem is a pointer to a Buffer object      Buffer Clear Mem as TwoByte*20      Print Len(Mem)=40      Return Mem, 0!ab:=0xFFAA      Print Eval(Mem, 0!a)=0xAA,  Eval(Mem, 0!b)=0xFF      Return Mem, 0!b:=0xF2      Hex Eval(Mem,0!ab)   ' print 0xF2AA      \\ Redim with preserve      Buffer Mem as TwoByte*40      \\ copy 40 bytes  at index 20 (40 bytes from start)      Return Mem, 20:=Eval\$(Mem, 0, 20*2)      Hex Eval(Mem,20!ab)   ' print 0xF2AA      A(3)=Mem      Hex Eval(A(3),20!ab)   ' print 0xF2AA      \\ now Mem change pointer      Clear Mem      Print Len(Mem)      \\ old Mem is in A(3)      Hex Eval(A(3),20!ab)   ' print 0xF2AA      \\ we can change       Buffer Clear Mem as Integer * 200      Print Len(Mem)=400      Return Mem, 0:=Eval\$(A(3), 0, 80)      Hex Eval(Mem,20)   ' print 0xF2AA      \\ change type without use of clear      Buffer Mem as TwoByte * 200      Hex Eval(Mem,20!ab)   ' print 0xF2AA}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)=1Print a()  ' 1 1 1 1 1 1 1 1 1 1make(a())Print a()  ' 2 2 2 2 2 2 2 2 2 2make2(&a())Print a()  ' 3 3 3 3 3 3 3 3 3 3Sub make(A)      A++End SubSub make2(&a())      A=A()      A++End Sub `

## Maple

`#defining an array of a certain lengtha := Array (1..5);                                 a := [ 0 0 0 0 0 ]#can also define with a list of entriesa := Array ([1, 2, 3, 4, 5]);                                a := [ 1 2 3 4 5 ]a[1] := 9;a                                a[1] := 9                                [ 9 2 3 4 5 ]a[5];                                5#can only grow arrays using ()a(6) := 6;                                a := [ 9 2 3 4 5 6 ]a[7] := 7;Error, Array index out of range`

## Mathematica / Wolfram Language

`a = Array[Sin, 10]a[[1]]Delete[a, 2]`
Output:
```{Sin[1],Sin[2],Sin[3],Sin[4],Sin[5],Sin[6],Sin[7],Sin[8],Sin[9],Sin[10]}
Sin[1]
{Sin[1],Sin[3],Sin[4],Sin[5],Sin[6],Sin[7],Sin[8],Sin[9],Sin[10]}```

## MATLAB / Octave

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 = [1 2 35] %Declaring a vector (i.e. one-dimensional array) a =      1     2    35 >> a = [1 2 35;5 7 9] % Declaring a matrix (i.e. two-dimensional array) a =      1     2    35     5     7     9 >> a3 = reshape(1:2*3*4,[2,3,4]);   % declaring a three-dimensional array of size 2x3x4 a3 = ans(:,:,1) =    1   3   5   2   4   6 ans(:,:,2) =     7    9   11    8   10   12 ans(:,:,3) =    13   15   17   14   16   18 ans(:,:,4) =    19   21   23   20   22   24  >> a(2,3) %Retrieving value using row and column indicies      9 >> a(6) %Retrieving value using array subscript ans =      9 >> a = [a [10;42]] %Added a column vector to the array a =      1     2    35    10     5     7     9    42 >> a(:,1) = [] %Deleting array elements a =      2    35    10     7     9    42`

## Maxima

`/* Declare an array, subscripts run from 0 to max value */array(a, flonum, 20, 20, 3)\$ arrayinfo(a);/* [complete, 3, [20, 20, 3]] */ a[0, 0]: 1.0; listarray(a);/* [1.0, 0.0, 0.0, ..., 0.0] */ /* Show all declared arrays */arrays;/* [a] */  /* One may also use an array without declaring it, it's a hashed array */b[1]: 1000;b['x]: 3/4; /* hashed array may have any subscript */ arrayinfo(b);/* [hashed, 1, [1], [x]] */ listarray(b);/* [1000, 3/4] */`

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

`:- module array_example.:- interface.:- import_module io.:- pred main(io::di, io::uo) is det.:- implementation.:- import_module array, int.:- use_module exception. :- type example_error ---> impossible. main(!IO) :-    some [!A] ( % needed to introduce a state variable not present in the head        % Create an array(int) of length 10, with initial values of 0        array.init(10, 0, !:A),         % create an empty array (with no initial value)        % since the created array is never used, type inference can't tell what        % kind of array it is, and there's an unresolved polymorphism warning.        array.make_empty_array(_Empty),         % resize our first array, so that we can then set its 17th member        % new values are set to -1        array.resize(20, -1, !A),        !A ^ elem(17) := 5,         % Mercury data structures tend to have deterministic (exception thrown        % on error), semideterministic (logical failure on error), and unsafe        % (undefined behavior on error) access methods.        array.lookup(!.A, 5, _), % det        ( if array.semidet_lookup(!.A, 100, _) then  % semidet            exception.throw(impossible)        else            true        ),        array.unsafe_lookup(!.A, 5, _), % could cause a segfault on a smaller array         % output: array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, 5, -1, -1])        io.print_line(!.A, !IO),         plusminus(2, 0, !A),         % output: array([2, -2, 2, -2, 2, -2, 2, -2, 2, -2, 1, -3, 1, -3, 1, -3, 1, 3, 1, -3])        io.print_line(!.A, !IO)    ).     % Sample predicate operating on an array.    % Note the array_* modes instead of in/out.:- pred plusminus(int, int, array(int), array(int)).:- mode plusminus(in, in, array_di, array_uo) is det.plusminus(N, I, !A) :-    ( if array.semidet_lookup(!.A, I, X) then        !A ^ unsafe_elem(I) := X + N,        plusminus(-N, I+1, !A)    else        true    ).`

## MiniScript

Lists and arrays are synonymous in MiniScript.

Operations:

```+	list concatenation
*	replication (i.e. repeat the list some number of times)
/	division (get some fraction of a list)
==, !=	comparison (for equality)
[i]	get/set item i (first item is 0)
[i:j]	get sublist ("slice") from i up to j
```

Slicing:

```x = ["a", 42, 3.14, 7, "hike"]
x[0]	"a" (first item)
x[1]	42 (second item)
x[-1]	"hike" (last item)
x[-2]	7 (next-to-last item)
x[1:-1]	[42, 3.14, 7] (everything from the second up to the last item)
x[1:]	[42, 3.14, 7, "hike"] (everything from the second item to the end)
x[:-1]	["a", 42, 3.14, 7] (everything up to the last item)
```

Example:

`arr = ["a", 1, 3]print arr[0] arr.push "x"print arr.pop`

## MIPS Assembly

` 	.dataarray:	.word	1, 2, 3, 4, 5, 6, 7, 8, 9 # creates an array of 9 32 Bit words.  	.textmain:	la 	\$s0, array	li	\$s1, 25	sw	\$s1, 4(\$s0)	# writes \$s1 (25) in the second array element# the four counts thi bytes after the beginning of the address. 1 word = 4 bytes, so 4 acesses the second element  	lw	\$s2, 20(\$s0)	# \$s2 now contains 6	 	li	\$v0, 10		# end program	syscall `

## Modula-2

Same as described for Modula-3

## Modula-3

`VAR staticArray: ARRAY [1..10] OF INTEGER;`

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

Static arrays can also be given initial values:

`VAR staticArray := ARRAY [1..10] OF INTEGER {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};VAR staticArray2 := ARRAY [1..10] OF INTEGER {1, ..} (* Initialize all elements to 1. *)`

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

`TYPE TOpenIntArray = REF ARRAY OF INTEGER;VAR openArray: TOpenIntArray;`

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:

`openArray := NEW(TOpenIntArray, 10);`

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:

` VAR  staticArraySize := NUMBER(staticArray);  staticArrayElement := staticArray[4];   openArraySize := NUMBER(openArray^); (* Note the dereference. *)  openArrayElement := openArray[9];`
`staticArray[4] := 100;openArray[1] := 200;`

## Monte

`var myArray := ['a', 'b', 'c','d']`

To retrieve a value:

`traceln(myArray[0])`

To change a value:

`myArray := myArray.with(3, 'z')`

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

## Nanoquery

`// create a fixed-length array (length 10)arr = array(10) // assign a value to the first position in the array and then display itarr[0] = "hello, world!"println arr[0]  // create a variable-length listl = list() // place the numbers 1-10 in the listfor i in range(1,10)	append l iend // display the listprintln l`
Output:
```hello, world!
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]```

## Neko

`var myArray = \$array(1); \$print(myArray[0]);`
Output:

1

## Nemerle

`using System;using System.Console;using System.Collections; module ArrayOps{    Main() : void    {        def fives = array(10);        foreach (i in [1 .. 10]) fives[i - 1] = i * 5;        def ten = fives[1];        WriteLine(\$"Ten: \$ten");         def dynamic = ArrayList();        dynamic.Add(1);        dynamic.Add(3);        dynamic[1] = 2;        foreach (i in dynamic) Write(\$"\$i\t"); // Nemerle isn't great about displaying arrays, it's better with lists though    }}`

## NetRexx

Note: Dynamic arrays can be simulated via the Java Collections Framework or by using NetRexx indexed strings (AKA: associative arrays).

`/* NetRexx */options replace format comments java crossref symbols nobinary array = int[10]array[0] = 42 say array[0] array[3]say words = ['Ogof', 'Ffynnon', 'Ddu'] say words[0] words[1] words[2]say -- Dynamic arrays can be simulated via the Java Collections packagesplk = ArrayList()splk.add(words[0])splk.add(words[1])splk.add(words[2])splk.add('Draenen') say splk.get(0) splk.get(3)say splk.get(0) splk.get(1) splk.get(2)say -- or by using NetRexx "indexed strings" (associative arrays)cymru = ''cymru[0] = 0cymru[0] = cymru[0] + 1; cymru[cymru[0]] = splk.get(0) splk.get(1) splk.get(2)cymru[0] = cymru[0] + 1; cymru[cymru[0]] = splk.get(0) splk.get(3) loop x_ = 1 to cymru[0] by 1  say x_':' cymru[x_]  end x_`
Output:
```42 0

Ogof Ffynnon Ddu

Ogof Draenen
Ogof Ffynnon Ddu

1: Ogof Ffynnon Ddu
2: Ogof Draenen
```

## NewLISP

This creates an array of 5 elements, initialized to `nil`:

`(array 5)→ (nil nil nil nil nil)`

The example below creates a multi-dimensional array (a 3-element array of 4-element arrays), initialized using the values returned by the function sequence (a list containing whole numbers from 1 to 12) and stores the newly created array in a variable called myarray. The return value of the set function is the array.

`(set 'myarray (array 3 4 (sequence 1 12)))→ ((1 2 3 4) (5 6 7 8) (9 10 11 12))`

## Nim

`var # fixed size arrays  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  z: array['a'..'z', int] # indexed using characters x[0] = x[1] + 1echo x[0]echo z['d'] x[7..9] = y[3..5] # copy part of array var # variable size sequences  a = @[1,2,3,4,5,6,7,8,9,10]  b: seq[int] = @[1,2,3,4,5] a[0] = a[1] + 1echo a[0] a.add(b) # append another sequencea.add(200) # append another elementecho a.pop() # pop last item, removing and returning itecho a`

## NS-HUBASIC

`10 DIM A(1)20 A(1)=1030 PRINT A(1)`

## NSIS

Library: NSISArray

NSIS does not have native support for arrays. Array support is provided by the NSISArray plugin.

` !include NSISArray.nshFunction ArrayTest	Push \$0	; Declaring an array	NSISArray::New TestArray 1 2	NSISArray::Push TestArray "Hello"	; NSISArray arrays are dynamic by default.	NSISArray::Push TestArray "World"	NSISArray::Read TestArray 1	Pop \$0	DetailPrint \$0	Pop \$0FunctionEnd `

## Oberon-2

` MODULE Arrays;IMPORT   Out;   PROCEDURE Static;  VAR    x: ARRAY 5 OF LONGINT;  BEGIN    x[0] := 10;    x[1] := 11;    x[2] := 12;    x[3] := 13;    x[4] := x[0];     Out.String("Static at 4: ");Out.LongInt(x[4],0);Out.Ln;  END Static;   PROCEDURE Dynamic;  VAR    x: POINTER TO ARRAY OF LONGINT;  BEGIN    NEW(x,5);     x[0] := 10;    x[1] := 11;    x[2] := 12;    x[3] := 13;    x[4] := x[0];     Out.String("Dynamic at 4: ");Out.LongInt(x[4],0);Out.Ln;  END Dynamic; BEGIN  Static;  DynamicEND Arrays. `

## Objeck

` bundle Default {  class Arithmetic {    function : Main(args : System.String[]), Nil {      array := Int->New[2];      array[0] := 13;      array[1] := 7;      (array[0] + array[1])->PrintLine();    }  }} `

## Objective-C

`// NSArrays are ordered collections of NSObject subclasses only. // Create an array of NSString objects.NSArray *firstArray = [[NSArray alloc] initWithObjects:@"Hewey", @"Louie", @"Dewey", nil]; // NSArrays are immutable; it does have a mutable subclass, however - NSMutableArray.// Let's instantiate one with a mutable copy of our array.// We can do this by sending our first array a -mutableCopy message.NSMutableArray *secondArray = [firstArray mutableCopy]; // Replace Louie with Launchpad McQuack.[secondArray replaceObjectAtIndex:1 withObject:@"Launchpad"]; // Display the first object in the array.NSLog(@"%@", [secondArray objectAtIndex:0]); // In non-ARC or non-GC environments, retained objects must be released later.[firstArray release];[secondArray release]; // There is also a modern syntax which allows convenient creation of autoreleased immutable arrays.// No nil termination is then needed.NSArray *thirdArray = @[ @"Hewey", @"Louie", @"Dewey", @1, @2, @3 ]; `

## OCaml

in the toplevel:

`# Array.make 6 'A' ;;- : char array = [|'A'; 'A'; 'A'; 'A'; 'A'; 'A'|] # Array.init 8 (fun i -> i * 10) ;;- : int array = [|0; 10; 20; 30; 40; 50; 60; 70|] # let arr = [|0; 1; 2; 3; 4; 5; 6 |] ;;val arr : int array = [|0; 1; 2; 3; 4; 5; 6|] # arr.(4) ;;- : int = 4 # arr.(4) <- 65 ;;- : unit = () # arr ;;- : int array = [|0; 1; 2; 3; 65; 5; 6|]`

## Oforth

Array created with [ ... ] are immutable array. To create a mutable array, #new is used.

`[ "abd", "def", "ghi" ] at( 3 ) . Array new dup addAll( [1, 2, 3] ) dup put( 2, 8.1 ) . `
Output:
```ghi
[1, 8.1, 3]
```

## Ol

Ol provides arrays in the form of vectors.

Vectors are heterogeneous structures whose elements are indexed by integers. A vector typically occupies less space than a list of the same length, and the average time needed to access a randomly chosen element is typically less for the vector than for the list.

The length of a vector is the number of elements that it contains. This number is a non-negative integer that is fixed when the vector is created.

The valid indices of a vector are the exact non zero integers which absolute value is less or equal than the length of the vector. Negative indices of a vector means counting from the end of a vector.

The first element in a vector is indexed by one (not a zero!), and the last element is indexed by length of the vector. 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)#(1 2 3 4 5) ; making a vector in a functional way> (vector 1 2 3 4 5)#(1 2 3 4 5) ; another functional vector making way> (make-vector '(1 2 3 4 5))#(1 2 3 4 5) ; the same as above functional vector making way> (list->vector '(1 2 3 4 5))#(1 2 3 4 5) ; modern syntax of making a vector> [1 2 3 4 5]#(1 2 3 4 5) ; making a vector of symbols> '[a b c d e]#(a b c d e) ; making a vector of symbols but evaluate a third element> `[a b ,(* 7 13) d e]#(a b 91 d e) ; making an empty vectors> #()#() > []#() > '[]#() > `[]#() > (make-vector '())#() > (list->vector '())#() ; making a vector of a vectors (a matrix, for example)> [[1 2 3]   [4 5 6]   [7 8 9]]#(#(1 2 3) #(4 5 6) #(7 8 9)) ; getting length of a vector> (size [1 2 3 4 5])5 ; making n-length vector with undefined values (actually, #false)> (make-vector 5)#(#false #false #false #false #false) ; making n-length vector with default values> (make-vector 5 0)#(0 0 0 0 0) ; define a test vector for use in below> (define array [3 5 7 9 11]);; Defined array ; getting first element of a vector> (ref array 1)3 > (ref array (- (size array)))3 ; getting last element of a vector> (ref array (size array))11 > (ref array -1)11 ; vectors comparison> (equal? [1 2 3 4 5] [1 2 3 4 5])#true > (equal? [1 2 3 4 5] [7 2 3 4 5])#false ; vectors of vectors comparison> (equal?   [[1 2 3]    [4 5 6]    [7 8 9]]   [[1 2 3]    [4 5 6]    [7 8 9]])#true > (equal?   [[1 2 3]    [4 5 6]    [7 8 9]]   [[1 2 3]    [4 5 6]    [7 8 3]])#false `

## ooRexx

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

`   a = .array~new       -- create a zero element array   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   c~append(4)          -- adds to end.  c[4] == 4 now`

ooRexx provides a built-in array class that provides one- and more dimensional arrays with positive integer indexes. The above example shows the use of a one-dimensional array (vector).

For other related classes see http://rosettacode.org/wiki/Associative_array/Creation#ooRexx

Much more powerful than the array class are stems with tails as described in the following.

A stem is a symbol followed by a period, e.g., XXX. Compound variables consist of a stem followed by a tail, i.e., one or more symbols separated by one or more periods, e.g., XXX.U..V.W or just one or more periods, e.g., XXX.. An assignment of some value to a stem gives this value to all compound variables with that stem.

` XXX.='*'Say 'xxx.1='xxx.1   -- shows xxx.1=*u=17xxx.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.

Another improvement introduced by ooRexx is the possibility to use expressions instead of symbols for the tail: Instead of z=z+1; xxx.z='something' one can now write xxx.[z+1]='something' Notice the period in contrast to array references as shown above!

The effective "name" of a compound variable is the stem concatenated with the periods and the values of the tail's symbols or expressions. If u=17 and v='zz' Then XXX.u.v or xxx.[u,v] evaluates to the "effective name" XXX.17.zz The tail's symbols' values can be any character string with v='John Doe' XXX.u.v... will evaluate to XXX.17.John Doe... The old restriction that the length of such an effective name must not exceed 250 bytes no longer applies to ooRexx and Regina. XXX.u.v...='something'

`u=17v='John Doe'XXX.u.v...='some value'z='17.John Doe...'Say xxx.z  shows 'some value'`

When using a stem for storing structured data, as in

`person.first='Walter'person.last='Pachl'`

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.

## OxygenBasic

`  'CREATING A STATIC ARRAYfloat f[100] 'SETTING INDEX BASEindexbase 1 'default 'FILLING PART OF AN ARRAYf[20]={2,4,6,8,10,12} 'MAPPING AN ARRAY TO ANOTHERfloat *g@[email protected][20]print g[6] 'result 12 'DYNAMIC (RESIZEABLE) ARRAYSredim float f(100)f={2,4,6,8}               'assign some valuesredim float f(200)        'expand arrayprint f(2)                'original values are preserved by defaultredim float f(200) clear  'array elements are cleared print f(2)                'value set to 0.0redim float f(0)          'release allocated memory          ' `

## Oz

`declare  Arr = {Array.new 1   %% lowest index                   10  %% highest index                   37} %% all 10 fields initialized to 37in  {Show Arr.1}  Arr.1 := 64  {Show Arr.1}`

## PARI/GP

`v=[];v=concat(v,7);v[1]`

## Pascal

A modification of the Delphi example:

` Program ArrayDemo;uses  SysUtils;var  StaticArray: array[0..9] of Integer;  DynamicArray: array of Integer;  StaticArrayText,  DynamicArrayText: string;  lcv: Integer;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  for lcv := 0 to Pred(Length(StaticArray)) do  begin    write('Enter a integer random number for position ', Succ(lcv), ': ');    readln(StaticArray[lcv]);  end;  // Storing entered numbers of the static array in reverse order into the dynamic  for lcv := 0 to Pred(Length(StaticArray)) do    DynamicArray[Pred(Length(DynamicArray)) - lcv] := StaticArray[lcv];  // Concatenating the static and dynamic array into a single string variable  StaticArrayText := '';  DynamicArrayText := '';  for lcv := 0 to Pred(Length(StaticArray)) do  begin    StaticArrayText := StaticArrayText + IntToStr(StaticArray[lcv]) + ' ';    DynamicArrayText := DynamicArrayText + IntToStr(DynamicArray[lcv]) + ' ';  end;  // Displaying both arrays  writeln(StaticArrayText);  writeln(DynamicArrayText);end. `

## Perl

In-line

` my @empty; my @empty_too = ();  my @populated   = ('This', 'That', 'And', 'The', 'Other'); print \$populated[2];  # And  my \$aref = ['This', 'That', 'And', 'The', 'Other']; print \$aref->[2];  # And `

Dynamic

`my @arr; push @arr, 1;push @arr, 3; \$arr[0] = 2; print \$arr[0];`

Two-dimensional

` my @multi_dimensional = (     [0, 1, 2, 3],     [qw(a b c d e f g)],     [qw(! \$ % & *)], ); `

## Phix

Library: Phix/basics

In Phix, sequences are it - there are no other data structures to learn.

Arrays, multidimensional arrays, lists, stacks, queues, trees, etc. and even character strings can all be easily represented in Phix with sequences. They can grow or shrink without any need to worry about memory management issues.

```-- simple one-dimensional arrays:
sequence s1 = {0.5, 1, 4.7, 9}, -- length(s1) is now 4
s2 = repeat(0,6),     -- s2 is {0,0,0,0,0,0}
s3 = tagset(5)         -- s3 is {1,2,3,4,5}

?s1[3]      -- displays 4.7 (nb 1-based indexing)
s1[3] = 0   -- replace that 4.7
s1 &= {5,6} -- length(s1) is now 6 ({0.5,1,0,9,5,6})
s1 = s1[2..5]   -- length(s1) is now 4 ({1,0,9,5})
s1[2..3] = {2,3,4} -- length(s1) is now 5 ({1,2,3,4,5})
s1 = append(s1,6)   -- length(s1) is now 6 ({1,2,3,4,5,6})
s1 = prepend(s1,0)  -- length(s1) is now 7 ({0,1,2,3,4,5,6})

-- negative subscripts can also be used, counting from the other end, eg
s2[-2..-1] = {-2,-1}    -- s2 is now {0,0,0,0,-2,-1}

-- multi dimensional arrays:
sequence y = {{{1,1},{3,3},{5,5}},
{{0,0},{0,1},{9,1}},
{{1,7},{1,1},{2,2}}}
-- y[2][3][1] is 9

y = repeat(repeat(repeat(0,2),3),3)
-- same structure, but all 0s

-- Array of strings:
sequence s = {"Hello", "World", "Phix", "", "Last One"}
-- s[3] is "Phix"
-- s[3][2] is 'h'

-- A Structure:
sequence employee = {{"John","Smith"},
45000,
27,
185.5}

-- To simplify access to elements within a structure it is good programming style to define constants that name the various fields, eg:
constant SALARY = 2

-- Array of structures:
sequence employees = {
{{"Jane","Adams"}, 47000, 34, 135.5},  -- a[1]
{{"Bill","Jones"}, 57000, 48, 177.2},  -- a[2]
-- .... etc.
}
-- employees[2][SALARY] is 57000

-- A tree can be represented easily, for example after adding "b","c","a" to it you might have:
sequence tree = {{"b",3,2},
{"c",0,0},
{"a",0,0}}

-- ie assuming
constant ROOT=1, VALUE=1, LEFT=2, RIGHT=3 -- then
--  tree[ROOT][VALUE] is "b"
--  tree[ROOT][LEFT] is 3, and tree[3] is the "a"
--  tree[ROOT][RIGHT] is 2, and tree[2] is the "c"

-- The operations you might use to build such a tree (tests/loops/etc omitted) could be:
tree = {}
tree = append(tree,{"b",0,0})
tree = append(tree,{"c",0,0})
tree[1][RIGHT] = length(tree)
tree = append(tree,{"a",0,0})
tree[1][LEFT] = length(tree)

-- Finally, some tests (recall that we have already output a 4.7):
?s[3]
?tree
?tree[ROOT][VALUE]
employees = append(employees, employee)
?employees[3][SALARY]
?s1
?s2
```
Output:
```4.7
"Phix"
{{"b",3,2},{"c",0,0},{"a",0,0}}
"b"
45000
{0,1,2,3,4,5,6}
{0,0,0,0,-2,-1}
```

## Phixmonti

`include ..\Utilitys.pmt 0 tolist            /# create an empty array/list. '( )' is equivalent #/drop                /# remove top of the stack #/0 10 repeat         /# put an array/list of 10 elements (each element has value 0) to the stack #/flush               /# remove all elements. List is empty [] #/drop( 1 2 "Hello" pi )  /# put an initialize array/list to stack #/-7 1 set            /# modified first element to -7 #/0 get               /# get the last element. '-1 get' is equivalent #/drop( "next" "level" ) 2 put    /# insert a list in a list = [-7, ["next", "level"], 2, "Hello", 3.141592653589793]] #/ 3 2 slice           /# extract the subarray/sublist [ 2 "Hello" ] #/ pstack              /# show the content of the stack #/ `

## PHP

### Writing To An Array

#### Single Dimension

`\$NumberArray = array(0, 1, 2, 3, 4, 5, 6);\$LetterArray = array("a", "b", "c", "d", "e", "f");\$simpleForm = ['apple', 'orange'];`

#### Multi-Dimensional

`\$MultiArray = array(                array(0, 0, 0, 0, 0, 0),                array(1, 1, 1, 1, 1, 1),                array(2, 2, 2, 2, 2, 2),                array(3, 3, 3, 3, 3, 3)          );`

#### Array push

`\$arr = ['apple', 'orange'];array_push(\$arr, 'pear');print implode(',', \$arr); // Returns apple,orange,pear`

#### Single Dimension

Read the 5th value in the array:

`echo \$NumberArray[5]; // Returns 5echo \$LetterArray[5]; // Returns f`

#### Multi-Dimensional

Read the 2nd line, column 5

`echo \$MultiArray[1][5]; // 2`

### Print a whole array

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

`print_r(\$MultiArray);`

Which would give us:

`Array(    0 => array(            0 => 0            1 => 0            2 => 0            3 => 0            4 => 0            5 => 0         )    1 => array(            0 => 1            1 => 1            2 => 1            3 => 1            4 => 1            5 => 1         )    2 => array(            0 => 2            1 => 2            2 => 2            3 => 2            4 => 2            5 => 2         )    3 => array(            0 => 3            1 => 3            2 => 3            3 => 3            4 => 3            5 => 3         ))`

### Set custom keys for values

This example starts the indexing from 1 instead of 0

`\$StartIndexAtOne = array(1 => "A", "B", "C", "D");`

This example shows how you can apply any key you want

`\$CustomKeyArray = array("d" => "A", "c" => "B", "b" =>"C", "a" =>"D");`

To read the 3rd value of the second array:

`echo \$CustomKeyArray["b"]; // Returns C`

### Other Examples

Create a blank array:

`\$BlankArray = array();`

Set a value for the next key in the array:

`\$BlankArray[] = "Not Blank Anymore";`

Assign a value to a certain key:

`\$AssignArray["CertainKey"] = "Value";`

## Picat

Picat has support both arrays and lists. Arrays are general much faster than lists, especially for many elements and if there are much element accesses/updates.

Here are some examples how to use arrays.

`import util. go =>    % Create an array of length 10   Len = 10,   A = new_array(Len),   bind_vars(A,0), % Initialize all values to 0   println(a=A),   A[1] := 1, % Assign a value   println(a=A),   println(a1=A[1]), % print first element   % (re)assign a value   foreach(I in 1..Len) A[I] := I end,   println(A[3..7]), % print some interval of an array   nl,    % 2D arrays   A2 = new_array(4,4),   foreach(I in 1..4, J in 1..4)      A2[I,J] := (I-1)*4+J   end,   foreach(Row in A2) println(Row) end,    % These functions are defined in the util module.   % They returns lists so we have to convert them to arrays.   println('rows     '=to_array(A2.rows)),    println('columns  '=A2.columns.to_array),   println(diagonal1=A2.diagonal1.to_array),   println(diagonal2=A2.diagonal2.to_array),    nl,    % Pushing values to an array    A3 = {}, % an empty array   foreach(I in 1..4)     A3 := A3 ++ {10**I+I}   end,   println(a3=A3),   nl,    % Some misc functions   println([first=A3.first(), second=A3.second(),last=A3.last()]),    nl. `
Output:
```a = {0,0,0,0,0,0,0,0,0,0}
a = {1,0,0,0,0,0,0,0,0,0}
a1 = 1
{3,4,5,6,7}

{1,2,3,4}
{5,6,7,8}
{9,10,11,12}
{13,14,15,16}
rows      = {{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}}
columns   = {{1,5,9,13},{2,6,10,14},{3,7,11,15},{4,8,12,16}}
diagonal1 = {1,6,11,16}
diagonal2 = {4,7,10,13}

a3 = {11,102,1003,10004}

[first = 11,second = 102,last = 10004]```
Translation of: Prolog
`listvariant :-    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    nth(4,List,b),            % put an b at position 4    println(list=List),    append(List,[d],List2),   % append an d at the end , List2 has 5 elements    println(list2=List2),    Add = new_list(5),        % create a new list of length 5    append(List2,Add,List3),  % append 5 free variables to List2    println(len=List3.len),   % List3 now has 11 elements    println(list3=List3),    Value = List3[1],         % get the value at position 1    println(value=Value).     % will print out a `
Output:

("_4970" etc are undefined variables):

```list = [a,_4970,_4980,b,_49a0]
list2 = [a,_4970,_4980,b,_49a0,d]
len = 11
list3 = [a,_4970,_4980,b,_49a0,d,_4e50,_4e60,_4e70,_4e80,_4e90]
value = a```

## PicoLisp

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

`(setq A '((1 2 3) (a b c) ((d e) NIL 777)))  # Create a 3x3 structure(mapc println A)  # Show it`
Output:
```(1 2 3)
(a b c)
((d e) NIL 777)```

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

`(set (nth A 2 2) 'B)(mapc println A)`
Output:
```(1 2 3)
(a B c)
((d e) NIL 777)```

Insert '1' in front of the middle row:

`(push (cdr A) 1)(mapc println A)`
Output:
```(1 2 3)
(1 a B c)
((d e) NIL 777)```

Append '9' to the middle row:

`(queue (cdr A) 9)(mapc println A)`
Output:
```(1 2 3)
(1 a B c 9)
((d e) NIL 777)```

## Pike

`int main(){   // Initial array, few random elements.   array arr = ({3,"hi",84.2});    arr += ({"adding","to","the","array"}); // Lets add some elements.    write(arr[5] + "\n"); // And finally print element 5.}`

## PL/I

`/* Example of an array having fixed dimensions */declare A(10) float initial (1, 9, 4, 6, 7, 2, 5, 8, 3, 10); A(6) = -45; /* Example of an array having dynamic bounds. */get list (N); begin;   declare B(N) float initial (9, 4, 7, 3, 8, 11, 0, 5, 15, 6);   B(3) = -11;   put (B(2));end; /* Example of a dynamic array. */   declare C(N) float controlled;   get list (N);   allocate C;   C = 0;   c(7) = 12;   put (C(9));`

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

`To run:Start up.Write "Creating an array of 100 numbers..." on the console.Create a number array given 100.Write "Putting 1 into the array at index 0." on the console.Put 1 into the number array at 0.Write "Putting 33 into the array at index 50." on the console.Put 33 into the number array at 50.Write "Retrieving value from array at index 0... " on the console without advancing.Get a number from the number array at 0.Write "" then the number on the console.Write "Retrieving value from array at index 50... " on the console without advancing.Get another number from the number array at 50.Write "" then the other number on the console.Write "Retrieving value from array at index 99... " on the console without advancing.Get a third number from the number array at 99.Write "" then the third number on the console.Destroy the number array.Wait for the escape key.Shut down. \\\\\\\\\\\\\\\\\\ Array implementation \\\\\\\\\\\\\\\\\\\\ A number array has a first element pointer. A location is a number. To create a number array given a count:Put a number's magnitude times the count into a size.Assign the number array's first element pointer given the size. \ allocate memory for the array To destroy a number array:Unassign the number array's first element pointer. \ free the array's memory To get a number from a number array at a location:Put the location times the number's magnitude into an offset.Put the number array's first element pointer into a number pointer.Add the offset to the number pointer.Put the number pointer's target into the number. To put a number into a number array at a location:Put the location times the number's magnitude into an offset.Put the number array's first element pointer into a number pointer.Add the offset to the number pointer.Put the number into the number pointer's target.`
Output:
```Creating an array of 100 numbers...
Putting 1 into the array at index 0.
Putting 33 into the array at index 50.
Retrieving value from array at index 0... 1
Retrieving value from array at index 50... 33
Retrieving value from array at index 99... 0
```

## Pony

Arrays are homogenous.

`use "assert"      // due to the use of Fact - - - var numbers = Array[I32](16) // creating array of 32-bit ints with initial allocation for 16 elementsnumbers.push(10) // add value 10 to the end of array, extending the underlying memory if neededtry  let x = numbers(0) // fetch the first element of array. index starts at 0  Fact(x == 10)      // try block is needed, because both lines inside it can throw exceptionend var other: Array[U64] = [10, 20, 30] // array literallet s = other.size() // return the number of elements in arraytry  Fact(s == 3)  // size of array 'other' is 3  other(1) = 40 // 'other' now is [10, 40, 30]end`

## PostScript

` %Declaring array /x [0 1] def %Assigning value to an element, PostScript arrays are 0 based. x 0 3 put %Print array x pstack[3 1] %Get an element x 1 get `

## PowerShell

Empty array:

`\$a = @()`

Array initialized with only one member:

`\$a = ,2\$a = @(2)  # alternative`

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

`\$a = 1,2,3`

A value can be appended to an array using the `+=` operator:

`\$a += 5`

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

Values can be retrieved using a fairly standard indexing syntax:

`\$a[1]`

Similarly, those values can also be replaced:

`\$a[1] = 42`

The range operator `..` can be used to create contiguous ranges of integers as arrays:

`\$r = 1..100`

Indexing for retrieval allows for arrays as well, the following shows a fairly complex example combining two ranges and an arbitrary array in the indexer:

`\$r[0..9+25..27+80,85,90]`

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

`\$r[-1]  # last index`

## Prolog

Works with: SWI Prolog

Prolog Terms can be abused as array structure. Using functor/3 to create arrays and arg/3 to nondestructively retrieve and set elements.

` singleassignment:-                       functor(Array,array,100), % create a term with 100 free Variables as arguments                              % index of arguments start at 1    arg(1 ,Array,a),          % put an a at position 1     arg(12,Array,b),          % put an b at position 12    arg(1 ,Array,Value1),     % get the value at position 1    print(Value1),nl,         % will print Value1 and therefore a followed by a newline     arg(4 ,Array,Value2),     % get the value at position 4 which is a free Variable    print(Value2),nl.         % will print that it is a free Variable followed by a newline `

To destructively set an array element, which is the "normal" way to set an element in most other programming languages, setarg/3 can be used.

` destructive:-                       functor(Array,array,100), % create a term with 100 free Variables as arguments                              % index of arguments start at 1    setarg(1 ,Array,a),       % put an a at position 1     setarg(12,Array,b),       % put an b at position 12    setarg(1, Array,c),       % overwrite value at position 1 with c    arg(1 ,Array,Value1),     % get the value at position 1    print(Value1),nl.         % will print Value1 and therefore c followed by a newline  `

Lists can be used as arrays.

` listvariant:-    length(List,100),          % create a list of length 100    nth1(1 ,List,a),           % put an a at position 1 , nth1/3 uses indexing from 1, nth0/3 from 0    nth1(12,List,b),           % put an b at position 3    append(List,[d],List2),    % append an d at the end , List2 has 101 elements    length(Add,10),            % create a new list of length 10    append(List2,Add,List3),   % append 10 free variables to List2 , List3 now has 111 elements    nth1(1 ,List3,Value),      % get the value at position 1    print(Value),nl.           % will print out a `

## PureBasic

Dim is used to create new arrays and initiate each element will be zero. An array in PureBasic can be of any types, including structured, and user defined types. Once an array is defined it can be resized with ReDim. Arrays are dynamically allocated which means than a variable or an expression can be used to size them.

`  ;Set up an Array of 23 cells, e.g. 0-22Dim MyArray.i(22)  MyArray(0) = 7  MyArray(1) = 11   MyArray(7) = 23`

ReDim is used to 'resize' an already declared array while preserving its content. The new size can be both larger or smaller, but the number of dimension of the array can not be changed after initial creation.

`  ;Extend the Array above to 56 items without affecting the already stored dataReDim MyArray(55)  MyArray(22) = 7  MyArray(33) = 11   MyArray(44) = 23`
`  ;Find all 6 non-zero cells from the Array aboveFor i=0 To ArraySize(MyArray())  If MyArray(i)    PrintN(Str(i)+" differs from zero.")  EndIfNext`
`  ; Now, set up a multi dimensional Array Dim MultiArray.i(800, 600)  MultiArray(100, 200) = 640  MultiArray(130,  40) = 120`
`Dim MultiArray2.i(64, 128, 32)  PrintN( Str(ArraySize(MultiArray2(), 2)) ; Will tell that second dimension size is '128'`

## Python

Python lists are dynamically resizeable.

`array = [] array.append(1)array.append(3) array[0] = 2 print array[0]`

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

`myArray = [0] * size`

However this will not work as intended if one tries to generalize from the syntax:

`myArray = [[0]* width] * height # DOES NOT WORK AS INTENDED!!!`

This creates a list of "height" number of references to one list object ... which is a list of width instances of the number zero. Due to the differing semantics of immutables (strings, numbers) and mutables (dictionaries, lists), a change to any one of the "rows" will affect the values in all of them. Thus we need to ensure that we initialize each row with a newly generated list.

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

`myArray = [[0 for x in range(width)] for y in range(height)]`

That is equivalent to:

`myArray = list()for x in range(height):   myArray.append([0] * width)`

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 listarray.pop(0) # Pop first item in a list # Using a negative element counts from the end of the list.item = array[-1] # Retrieve last element in a list. `

Python produces an IndexError when accessing elements out of range:

` try:    # This will cause an exception, which will then be caught.    print array[len(array)]except IndexError as e:    # Print the exception.     print e `

## QB64

` 'Task'Show basic array syntax in your language. 'Basically, create an array, assign a value to sit, and retrieve an element   (if available, show both fixed-length arrays and dynamic arrays, pushing a value into it).Rem  DECLARATION PART Rem QB64/QuickBasic/Qbasic array examples'-----------MyArray%(10) = 11 ' it creates an array integer of 11 elements  from 0 to 11Dim MyArray2%(0 To 10) ' it is equal to the previous line of code, it is its explicit way '--------------Option Base 1 ' from here all arrays have as default as index of first item 1MyArray3%(10) = 14 'it creates array from 1 to 14 Dim Myarray4%(1 To 14) ' it is equal to the 2 previous lines of code '-----------------Dim Shared myArray\$(-12 To 12) ' it creates a string array with 25 elements and SHARED makes it global array '---------------------'\$dynamicDim MyArray1!(1 To 4) ' these two lines of code create a resizable array ReDim myArray2!(1 To 4) ' it does the same of the 2 previous lines of code '-------------------------' alternatively at the place of suffix ! or \$ or % or # or &' you can use the explicit way  "DIM namearray (start to end) AS TypeOfVariable"Dim MyIntegerArray(1 To 10) As IntegerDim MyStringArray(1 To 10) As StringDim MySingleArray(1 To 10) As SingleDim MyLongArray(1 To 10) As LongDim MyDoubleArray(1 To 10) As Double '---------------------------'it is possible defining an User Data Type and creating an array with that typeType MyType    Name As String * 8 ' a fixed lenght string variable    ID As Integer    Position As SingleEnd Type Dim Lists(1 To 10) As MyTypeReDim WhoIs(-19 To 10) As MyType  '------------------------------' Number of dimensions of an array: QuickBasic vs QB64' an array can have from 1 to until 60 dimensions in QuickBasic' an array can have from 1 to RAM dimension of your machine' you must think that in the dayly practice is rare to use more than 3 dimensionsDim Calendar%(1 To 31, 1 To 56, 1 To 12) ' array calendar with days, week, mounthsReDim Time(1 To 60, 1 To 60, 1 To 24) As Integer ' array Time with seconds, minutes and hours Rem  ONLY QB64 arrays'--------' QB64 introduces more TypeOfVariable all of them associated to a suffix' so you can declare also these kind of data' _BIT  or `, _BYTE or %%, _INTEGER64 or &&, _FLOAT or ##, OFFSET or %&, _MEM (no suffix)Dim MyByteArray%%(1 To 4)Dim MyByteArray2(1 To 4) As _Byte' are the same declaration of the array '----------------'QB64 lets you to use an alternative way to declare variables and array'using the following syntax:   DIM / REDIM  AS Type of data  Array1, Array2, Array3"ReDim As _MEM Mem1(1 To 5), Mem2(6 To 10)Dim As _Unsigned _Byte UByte(-3 To 25), Ubyte2(100 To 200)  Rem QB64 / QB PDS (7.1) arraysReDim MyPreservedArray(1 To 5) As Integer ' it creates a dynamic arrayReDim _Preserve MyPreservedArray(-3 To 100) As Integer ' it changes limit of dimension of array Rem ASSIGNING PART' at declaration point each array is initializated: 0 for digit arrays, "" for string arrays' in the UDT arrays each variable is initializated following its type  ' all types of array can be accessed using the index of item choice to change' in the UDT array each item of UDT is reached using the "." while the item of array needs the indexPrint MyPreservedArray(2)MyPreservedArray(2) = 12345Print MyPreservedArray(2) Print WhoIs(-10).NameWhoIs(-10).Name = "QB64"Print WhoIs(-10).NameWhoIs(10).Name = WhoIs(-10).NamePrint WhoIs(10).Name Rem RETRIEVE AN ELEMENT' basically the coder must use a loop for scanning the whole array for that value choosen '-----------------' static arrayMySingleArray(4) = 4MySingleArray(8) = 8For n = 1 To 10    If MySingleArray(n) > 0 Then Print MySingleArray(n)Next  'dynamic array WhoIs(-10).Name = "QB64"WhoIs(10).Name = "C#"WhoIs(1).Name = "Java"Print WhoIs(-10).Name, WhoIs(10).Name, WhoIs(1).NameReDim _Preserve WhoIs(-10 To 19) As MyTypePrintPrint WhoIs(-10).Name, WhoIs(10).Name, WhoIs(1).NamePrint WhoIs(-1).Name, WhoIs(19).Name, WhoIs(10).Name    `

## Quackery

A selection of the nest related words in Quackery, demonstrated as a dialogue in the Quackery shell.

```Welcome to Quackery.

Enter "leave" to leave the shell.

Building extensions.

/O> ( nests are dynamic arrays, zero indexed from the left, -1 indexed from the right )
...

Stack empty.

/O> []                ( create an empty nest )
... 23 join 24 join   ( append two numbers   )
... ' [ 33 34 ]       ( create a nest of two numbers )
... join              ( concatenate them )
... ' [ 45 46 ]       ( create a nest of two numbers )
... nested join       ( add that nest as an item of the nest )
...

Stack: [ 23 24 33 34 [ 45 46 ] ]

/O> ' [ 55 56 ]       ( create a nest of two numbers )
... swap 2 stuff      ( insert it into the previous nest as the 2nd item )
...

Stack: [ 23 24 [ 55 56 ] 33 34 [ 45 46 ] ]

/O> -3 pluck drop     ( remove the third item from the end and dispose of it )
...

Stack: [ 23 24 [ 55 56 ] 34 [ 45 46 ] ]

/O> dup 0 peek        ( copy the first item )
...

Stack: [ 23 24 [ 55 56 ] 34 [ 45 46 ] ] 23

/O> swap -1 poke      ( ... and overwrite the last item with it )
...

Stack: [ 23 24 [ 55 56 ] 34 23 ]

/O> behead join      ( remove the first item and append it to the end )
...

Stack: [ 24 [ 55 56 ] 34 23 23 ]

/O> -2 split nip     ( split it two items from the end and dispose of the left hand side )
...

Stack: [ 23 23 ]

/O> ' ** join        ( append the exponentiation word )
...

Stack: [ 23 23 ** ]

/O> do               ( ... and perform the nest as Quackery code. )
...

Stack: 20880467999847912034355032910567 ```

## R

Dynamic

`arr <- array(1) arr <- append(arr,3) arr[1] <- 2 print(arr[1])`

## Racket

`#lang racket ;; import dynamic arrays(require data/gvector) (define v (vector 1 2 3 4))   ; array(vector-ref v 0)              ; 1(vector-set! v 1 4)           ; 2 -> 4 (define gv (gvector 1 2 3 4)) ; dynamic array(gvector-ref gv 0)            ; 1(gvector-add! gv 5)           ; increase size `

## Raku

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

`my @arr; push @arr, 1;push @arr, 3; @arr[0] = 2; say @arr[0];`

### Some further exposition:

In Raku, arrays have a very specific definition: "A collection of Scalar containers that do the Positional Role." Scalar container means it is mutable and may contain any object; an Integer, a Rational number, a String, another Array, whatever... literally any other object that can be instantiated in Raku. The Positional Role means that it uses integer indexing for access. The index must be a positive integer, an expression that evaluates to a positive integer, or something that can be coerced to a positive integer. Arrays are always indexed from 0. The starting index can not be changed.

Arrays are unconstrained by default. They may hold any number of any type of object up to available memory. They do not need to be pre-allocated. Simply assigning (or even referring in some cases) to an index slot is enough to autovivify the container and allocate enough memory to hold the assigned object. Memory will automatically be allocated and will grow and shrink as necessary to hold the values assigned.

Values may be pushed onto the end of an array, popped off of the end, shifted off of the front or unshifted onto the front, and spliced into or out of the interior.

```   @array.push: 'value';
my \$value = @array.pop;
@array.unshift: 'value';
my \$value = @array.shift;
@array.splice(2,3, <some arbitrary string values>);
```

Arrays may be constrained to only accept a certain number of objects or only a certain type of object.

```   my Int @array; # can only hold Integer objects. Assigning any other type will cause an exception.
my @array[9];  # can only 10 objects (zero indexed). Trying to assign to an index greater than 9 with cause an exception.
```

Arrays are constructed with square brackets, an explicit constructor, or by coercing some other object either explicitly using a coercer or implicitly by simply assigning to an array variable. These are all arrays:

```   [1, 2, 3, 4]
['a', 'b', 'c', 'd']
Array.new<this is an array of words>
('as', 'is', 'this').Array
my @implicit = <yep, this too>
```

Array variables in Raku are variables whose names bear the @ sigil, and are expected to contain some sort of list-like object. Of course, other variables may also contain these objects, but @-sigiled variables always do, and are expected to act the part. Array storage slots are accessed through postcircumfix square bracket notation. Unlike Perl 5, @-sigiled variables are invariant on access, whether you are accessing one slot, many slots, or all of the slots. The first slot in @array is @array[0] not \$array[0]. @array and \$array are two different unconnected variables.

```   @array[1]      # a single value in the 2nd slot
@array[*-1]    # a single value in the last slot
@array[1..5]   # an array slice, 2nd through 6th slots
@array[1,3,7]  # slice, 2nd, 4th and 8th slot
@array[8,5,2]  # can be in any order
@array[*]      # all the slots
@array[]       # all the slots (zen slice)
@array[^10]    # first 10 slots (upto 10 or 0..9)
@array.tail(2) # last two
```

Multi-dimensioned arrays also use postcircumfix square brackets for access. If the array is not ragged, (every sub array is the same size) you may use semicolon subscripting.

```   @array[1][1]   # 2nd item in the second slot
@array[1;1]    # same thing, implies rectangular (non-ragged) arrays
```

There are several objects that have an Iterable Role and a PositionalBindFailover Role which makes them act similar to arrays and allows them to be used nearly interchangeably in read-only applications. (Raku is big on duck typing. "If it looks like a duck and quacks like a duck and waddles like a duck, it's a duck.") These constructs are ordered and use integer indexing and are often used in similar circumstances as arrays, however, they are immutable. Values in slots can not be changed. They can not be pushed to, popped from or spliced. They can easily converted to arrays by simply assigning them to an array variable.

List: A fixed Iterable collection of immutable values. Lists are constructed similarly to arrays:

```   (1, 2, 3, 4)
('a', 'b', 'c', 'd')
List.new(<this is a list of words>)
('as', 'is', 'this').List
my @not-a-list = (<oops, this isn't>)
my @implicit := (<but this is>) # note the values are bound := not assigned =
```

Range: Iterable list of consecutive numbers or strings with a lower and an upper boundary. (That boundary may be infinite.) Reified on demand.

```   2..20    # integers two through twenty
1..Inf   # natural numbers
'a'..'z' # lowercase latin letters
'⁰'..'⁹'  # superscript digits
```

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.

```  0,2,4 ... 64   # even numbers up to 64
1,2,4 ... 64   # geometric increase
1,1, *+* ... * # infinite Fibonacci sequence
1,1,{\$^n2 + \$^n1 + 1} ... * # infinite Leonardo numbers
```

Postcircumfix indexing works for any object that has a Positional (or PositionalBindFailover) role, it need not be in a @-sigiled variable, or indeed, in a variable at all.

```   [2,4,6,8,10][1]                             # 4 - anonymous array
<my dog has fleas>[*-2]                     # 'has' - anonymous list
sub a {(^Inf).grep: *.is-prime}; a()[99];   # 541 - (100th prime) subroutine returning a sequence
my \$lol = ((1,2), (3,4), (5,6)); \$lol[1];   # (3 4) - list of lists in a Scalar variable
```

## 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 ; -> leftthird a ; -> "up"last a  ; -> "down"a/2     ; -> right (Note: REBOL is 1-based.) `

Getting subsequences. REBOL allows relative motion through a block (list). The list variable returns the current position to the end of the list, you can even assign to it without destroying the list.

` a         ; -> [left right "up" "down"]next a    ; -> [right "up" "down"]skip a 2  ; -> ["up" "down"] a: next a ; -> [right "up" "down"]head a    ; -> [left right "up" "down"] copy a                 ; -> [left right "up" "down"]copy/part a 2          ; -> [left right]copy/part  skip a 2  2 ; -> ["up" "down"]  `

## Red

`arr1: []      ;create empty arrayarr2: ["apple" "orange" 1 2 3]    ;create an array with data>> insert arr1 "blue">> arr1== ["blue"]append append arr1 "black" "green">> arr1== ["blue" "black" "green"]>> arr1/2== "black">> second arr1== "black">> pick arr1 2== "black"`

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.

`>> vec1: make vector! [ 20 30 70]== make vector! [20 30 70]>> vec1/2== 30>> second vec1== 30>> append vec1 90== make vector! [20 30 70 90]>> append vec1 "string"*** Script Error: invalid argument: "string"*** Where: append*** Stack: >> append vec1 3.0*** Script Error: invalid argument: 3.0*** Where: append*** Stack:`

## ReScript

`let arr = [1, 2, 3] let _ = Js.Array2.push(arr, 4) arr[3] = 5 Js.log(Js.Int.toString(arr[3]))`
Output:
```\$ bsc arrs.res > arrays.bs.js
\$ node arrays.bs.js
5
```

## Retro

Retro has a vocabulary for creating and working with arrays.

` needs array' ( Create an array with four elements )^array'new{ 1 2 3 4 } constant a ( Add 10 to each element in an array and update the array with the results )a [ 10 + ] ^array'map ( Apply a quote to each element in an array; leaves the contents alone )a [ 10 + putn cr ] ^array'apply ( Display an array )a ^array'display ( Look for a value in an array )3 a ^array'in?6 a ^array'in? ( Look for a string in an array )"hello" a ^array'stringIn? ( Reverse the order of items in an array )a ^array'reverse ( Append two arrays and return a new one )^array'new{ 1 2 3 } constant a^array'new{ 4 5 6 } constant ba b ^array'append constant c ( Create an array from the values returned by a quote )[ 1 2 "hello" "world" ] ^array'fromQuote constant d ( Create a quote from the values in an array )d ^array'toQuote `

## REXX

Strictly speaking, REXX doesn't have arrays, but it does have something that looks, feels, and tastes like arrays;
they're called stemmed arrays.

### simple arrays

`/*REXX program  demonstrates a  simple  array usage.                    */a.='not found'                         /*value for all  a.xxx  (so far).*/                do j=1  to 100         /*start at 1, define 100 elements*/                a.j=-j*1000            /*define as negative J thousand. */                end   /*j*/            /*the above defines 100 elements.*/ say 'element 50 is:'   a.50say 'element 3000 is:' a.3000                                       /*stick a fork in it, we're done.*/`
Output:
```element 50 is: -50000
```

### simple arrays, mimic other languages

`/*REXX program  demonstrates  array usage  with mimicry.                */a. = 'not found'                       /*value for all a.xxx  (so far). */                  do j=1  to 100       /*start at 1, define 100 elements*/                  a.j = -j * 100       /*define element as  -J hundred. */                  end   /*j*/          /*the above defines 100 elements.*/ say 'element 50 is:'    a(50)say 'element 3000 is:'  a(3000)exit                                   /*stick a fork in it, we're done.*//*──────────────────────────────────A subroutine────────────────────────*/a:   _a_ = arg(1);          return  a._a_`
```element 50 is: -5000
```

### simple arrays, assigned default

`/*REXX program  demonstrates  array usage  with mimicry.                */a. = 00                                /*value for all a.xxx  (so far). */                  do j=1  to 100       /*start at 1, define 100 elements*/                  a.j = -j * 100       /*define element as  -J hundred. */                  end   /*j*/          /*the above defines 100 elements.*/ say 'element 50 is:'    a(50)say 'element 3000 is:'  a(3000)exit                                   /*stick a fork in it, we're done.*//*──────────────────────────────────A subroutine────────────────────────*/a:   _a_ = arg(1);          return  a._a_`
Output:
```element 50 is: -5000
element 3000 is: 00
```

### arrays with non-unity index start

`/*REXX program  demonstrates  array usage  (with elements out-of-range).*/array. = 'out of range'                /*define  ALL  elements to this. */               do j=-3000  to 3000      /*start at -3k,  going up to +3k.*/              array.j=j**2             /*define element as its square.  */              end   /*j*/              /* [↑]   defines 6,001 elements. */g=-7say g      "squared is:"   array.gsay 7000   "squared is:"   array.7000                                       /*stick a fork in it, we're done.*/`
Output:
```-7 squared is: 49
7000 squared is: out of range
```

### arrays, disjoint

`/*REXX program  demonstrates  disjointed array usage.                   */yr. = 'year not supported'             /*value for all yr.xxx  (so far).*/                 do k=600  to 1100      /*a bunch of years prior to 1800.*/                yr.k=k "AD"            /*Kth element as the year itself.*/                end   /*k*/            /* [↑]      defines 501 elements.*/             do j=1800  to 2100         /*start at 1800, define a bunch. */            yr.j=j 'AD'                /*Jth element as the year itself.*/            end   /*j*/                /* [↑]      defines 301 elements.*/ year=1946say 'DOB' year "is:" yr.year year=1744say 'DOB' year "is:" yr.year                                       /*stick a fork in it, we're done.*/`
Output:
```DOB 1946 is: 1946 AD
DOB 1744 is: year not supported
```

### sparse arrays and special indices

`/*REXX program  demonstrates  array usage:   sparse and disjointed.     */  yyy = -55                            /*REXX must use this mechanism···*/a.yyy = 1e9                            /*··· when assigning neg indices.*/ a.1 = 1000a.2 = 2000.0001a.7 = 7000a.2012 = 'out here in left field.'a.cat = 'civet, but not a true cat ─── belonging to the family Viverridae'a.civet = "A.K.A.: toddycats"/*┌────────────────────────────────────────────────────────────────────┐  │ Array elements need not be continuous (nor even defined).   They   │  │ can hold any manner of numbers,  or strings (which can include any │  │ characters,  including    null    or    '00'x   characters).       │  │                                                                    │  │ Array elements need not be numeric, as the above code demonstrates.│  │ Indeed, the element "name" can be ANYTHING,  even non-displayable  │  │ characters.    To illustrate  [↓]:                                 │  └────────────────────────────────────────────────────────────────────┘*/stuff=')g.u.t.s(  or  ½ of an intestine!'a.stuff=44/*┌────────────────────────────────────────────────────────────────────┐  │ where the element name has special characters:  blanks,  and the   │  │ glyph of  one-half (½),  as well as the symbol used in REXX to     │  │ identify stemmed arrays (the period).                              │  └────────────────────────────────────────────────────────────────────┘*/                                       /*stick a fork in it, we're done.*/`

## Ring

Dynamic

`# create an array with one string in ita = ['foo'] # add itemsa + 1         # ["foo", 1] # set the value at a specific index in the arraya[1] = 2       # [2, 1] # retrieve an elementsee a[1]`

## RLaB

` // 1-D (row- or column-vectors)// Static:// row-vectorx = [1:3];  x = zeros(1,3); x[1]=1; x[2]=2; x[3]=3;// column-vectorx = [1:3]';  // orx = [1;2;3]; // orx = zeros(3,1); x[1]=1; x[2]=2; x[3]=3;// Dynamic:x = [];           // create an empty arrayx = [x; 1, 2];    // add a row to 'x' containing [1, 2], orx = [x, [1; 2]];  // add a column to 'x' containing [1; 2] // 2-D array// Static:x = zeros(3,5);        // create an zero-filed matrix of size 3x5x[1;1] = 1;            // set the x(1,1) element to 1x[2;]  = [1,2,3,4,5];  // set the second row x(2,) to a row vectorx[3;4:5] = [2,3];      // set x(3,4) to 2 and x(3,5) to 3// Dynamicx = [1:5];               // create an row-vector x(1,1)=1, x(1,2)=2, ... x(1,5)=5x = [x; 2, 3, 4, 6, 7];  // add to 'x' a row. // Accessing an element of arrays:// to retrieve/print element of matrix 'x' just put this in a single line in the scripti=1;j=2;x[i;j]   `

## Robotic

Robotic does not natively support arrays of any kind. However, using Counter Interpolation, we can create a simple (faux) array.

` set "index" to 0. "Assign random values to array": "loop"set "array&index&" to random 0 to 99inc "index" by 1if "index" < 100 then "loop" * "Value of index 50 is ('array('50')')."end `

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

` set "xx" to 0set "yy" to 0. "Assign random values to array": "loopX"set "array&xx&,&yy&" to random 0 to 99inc "xx" by 1if "xx" < 32 then "loopX"set "xx" to 0inc "yy" by 1if "yy" < 32 then "loopX" * "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.

## RPG

Works with: ILE RPG
`       //-Static array      //--def of 10 el array of integers, initialised to zeros     D array...      D                 s             10i 0 dim(10)     D                                     inz      //--def an el     D el_1...      D                 s             10i 0 inz       /free        //-assign first el       //--first element of RPG array is indexed with 1       array(1) = 111;        //-get first el of array       el_1 = array(1);        //--display it       dsply ('First el of array='+%char(el_1));       //--displays: First el of array=111        //---or shorter, without "el_1"       dsply ('First el of array='+%char(array(1)));       //--displays: First el of array=111       /end-free `

## Ruby

Dynamic

`# create an array with one object in ita = ['foo'] # the Array#new method allows several additional ways to create arrays # push objects into the arraya << 1         # ["foo", 1]a.push(3,4,5)  # ["foo", 1, 3, 4, 5] # set the value at a specific index in the arraya[0] = 2       # [2, 1, 3, 4, 5] # a couple of ways to set a slice of the arraya[0,3] = 'bar'    # ["bar", 4, 5]a[1..-1] = 'baz'  # ["bar", "baz"]a[0] = nil        # [nil, "baz"]a[0,1] = nil      # ["baz"] # retrieve an elementputs a[0]`

## Run BASIC

`print "Enter array 1 greater than 0"; : input a1print "Enter array 2 greater than 0"; : input a2 dim chrArray\$(max(a1,1),max(a2,1))dim numArray(max(a1,1),max(a2,1)) chrArray\$(1,1) = "Hello"numArray(1,1) = 987.2print chrArray\$(1,1);" ";numArray(1,1)`

## Rust

The Rust book has a tutorial on arrays.

By default, arrays are immutable unless defined otherwise.

`let a = [1, 2, 3]; // immutable arraylet mut m = [1, 2, 3]; // mutable arraylet zeroes = [0; 200]; // creates an array of 200 zeroes`

To get the length and iterate,

`let a = [1, 2, 3];a.len();for e in a.iter() {    e;}`

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

`let names = ["Graydon", "Brian", "Niko"];names[1]; // second element`

Dynamic arrays in Rust are called vectors.

`let v = vec![1, 2, 3];`

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

`let mut v = vec![1, 2, 3];v.push(4);v.len(); // 4`

## Sather

`-- a is an array of INTsa :ARRAY{INT};-- create an array of five "void" elementsa := #ARRAY{INT}(5);-- static creation of an array with three elementsb :ARRAY{FLT} := |1.2, 1.3, 1.4|;-- accessing an array elementc ::= b[0]; -- syntactic sugar for b.aget(0)-- set an array elementb[1] := c; -- syntactic sugar for b.aset(1, c)-- append another arrayb := b.append(|5.5|);`

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

`// Create a new integer array with capacity 10val a = new Array[Int](10) // Create a new array containing specified itemsval b = Array("foo", "bar", "baz") // Assign a value to element zeroa(0) = 42 // Retrieve item at element 2val c = b(2)`

Dynamic arrays can be made using `ArrayBuffer`s:

`val a = new collection.mutable.ArrayBuffer[Int] a += 5   // Append value 5 to the end of the lista(0) = 6 // Assign value 6 to element 0`

## Scheme

Lists are more often used in Scheme than vectors.

`(let ((array #(1 2 3 4 5))     ; vector literal      (array2 (make-vector 5))  ; default is unspecified      (array3 (make-vector 5 0))) ; default 0 (vector-set! array 0 3) (vector-ref array 0))    ; 3`

## Seed7

By default array indices have the type integer and start from 1. Other index types and start values are also possible. E.g.: The famous arrays with indices starting from 0 are possible. Every type, which can be mapped to integer, can be used as index type.

`\$ include "seed7_05.s7i"; const type: charArray is array [char] string;  # Define an array type for arrays with char index.const type: twoDim is array array char;        # Define an array type for a two dimensional array. const proc: main is func  local    var array integer: array1   is 10 times 0;           # Array with 10 elements of 0.    var array boolean: array2   is [0 .. 4] times TRUE;  # Array with 5 elements of TRUE.    var array integer: array3   is [] (1, 2, 3, 4);      # Array with the elements 1, 2, 3, 4.    var array string: array4    is [] ("foo", "bar");    # Array with string elements.    var array char: array5      is [0] ('a', 'b', 'c');  # Array with indices starting from 0.    const array integer: array6 is [] (2, 3, 5, 7, 11);  # Array constant.    var charArray: array7       is ['1'] ("one", "two"); # Array with char index starting from '1'.    var twoDim: array8          is [] ([] ('a', 'b'),    # Define two dimensional array.                                       [] ('A', 'B'));  begin    writeln(length(array1));    # Get array length (= number of array elements).    writeln(length(array2));    # Writes 5, because array2 has 5 array elements.    writeln(array4[2]);         # Get array element ("bar"). By default array indices start from 1.    writeln(array5[1]);         # Writes b, because the indices of array5 start from 0.    writeln(array7['2']);       # Writes two, because the indices of array7 start from '1'.    writeln(array8[2][2]);      # Writes B, because both indices start from 1.    writeln(minIdx(array7));    # Get minumum index of array ('1').    array3[1] := 5;             # Replace element. Now array3 has the elements 5, 2, 3, 4.    writeln(remove(array3, 3)); # Remove 3rd element. Now array3 has the elements 5, 2, 4.    array1 := array6;           # Assign a whole array.    array1 &:= [] (13, 17);     # Append an array.    array1 &:= 19;              # Append an element.    array1 := array3[2 ..];     # Assign a slice beginning with the second element.    array1 := array3[.. 5];     # Assign a slice up to the fifth element.    array1 := array3[3 .. 4];   # Assign a slice from the third to the fourth element.    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.  end func;`

## Self

The vector protorype represents a fixed size array with polymorphic contents. Vector indexing is zero based. Fixed size means that once created it is expensive (although not strictly impossible) to resize it. If resizable sequenced collections are wanted, the 'sequence' prototype can be used.

Creating simple vectors:

`vector copySize: 100`
`vector copySize: 100 FillingWith: anObject`

A polymorphic vector:

`(1 & 'Hello' & 2.0 & someObject) asVector`

Using a vector:

`|v|"creates an vector that holds up to 20 elements"v: vector copySize: 20."access the first element"v first printLine."access the 10th element"(v at: 9) printLine."put 100 as second value"vat: 1 Put: 100.`

Enumeration:

`v do: [:each | each printLine].v copy mapBy: [:each | each squared].v copy filterBy: [:each | each > 10].`

Using a squence:

`|s|"creates a new sequence"s: sequence copyRemoveAll."add an element"s addLast: 'Hello'."access the first element"s first printLine."remove the first element"s removeFirst."Check size"s size printLine.`

## SenseTalk

`// Initial creation of an arrayset a to (1, 2, 3) // pushing a value to the array// Both approaches are validinsert 4 after apush 5 into a put a -- (1, 2, 3, 4, 5) // Treating the array as a stack, using `push` and `pop`pop a into v1 put a -- (1, 2, 3, 4)put v1-- 5 // Treating the array as a queue, using `push` and `pull`push 6 into apull a into v2 put a -- (2, 3, 4, 6)put v2 -- 1 // Referencing the items in the arrayput the second item of a -- 3 // Changing the values in the arrayset the third item of a to "abc"put a -- (2, 3, "abc", 6)`

## Sidef

`# create an empty arrayvar arr = []; # push objects into the arrayarr << "a";           #: ['a']arr.append(1,2,3);    #: ['a', 1, 2, 3] # change an element inside the arrayarr[2] = "b";         #: ['a', 1, 'b', 3] # set the value at a specific index in the array (with autovivification)arr[5] = "end";       #: ['a', 1, 'b', 3, nil, 'end'] # resize the arrayarr.resize_to(-1);    #: [] # slice assignmentarr[0..2] = @|('a'..'c');       #: ['a', 'b', 'c'] # indices as arraysvar indices = [0, -1];arr[indices] = ("foo", "baz");  #: ['foo', 'b', 'baz'] # retrieve multiple elementsvar *elems = arr[0, -1]say elems                #=> ['foo', 'baz'] # retrieve an elementsay arr[-1];             #=> 'baz'`

## Simula

`BEGIN   PROCEDURE STATIC;  BEGIN    INTEGER ARRAY X(0:4);     X(0) := 10;    X(1) := 11;    X(2) := 12;    X(3) := 13;    X(4) := X(0);     OUTTEXT("STATIC AT 4: ");    OUTINT(X(4), 0);    OUTIMAGE  END STATIC;   PROCEDURE DYNAMIC(N); INTEGER N;  BEGIN    INTEGER ARRAY X(0:N-1);     X(0) := 10;    X(1) := 11;    X(2) := 12;    X(3) := 13;    X(4) := X(0);     OUTTEXT("DYNAMIC AT 4: ");    OUTINT(X(4),0);    OUTIMAGE  END DYNAMIC;   STATIC;  DYNAMIC(5)END ARRAYS. `
Output:
```STATIC AT 4: 10
DYNAMIC AT 4: 10
```

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

`BEGIN    CLASS ITEM;;    CLASS ITEMARRAY(N); INTEGER N;   BEGIN      REF(ITEM) ARRAY DATA(1:N);      OUTTEXT("NEW ITEMARRAY WITH "); OUTINT(N, 0); OUTTEXT(" ELEMENTS");      OUTIMAGE;   END;    CLASS ARRAYLIST;   BEGIN       PROCEDURE EXPAND(N); INTEGER N;      BEGIN         INTEGER I;         REF(ITEMARRAY) TEMP;         OUTTEXT("EXPAND TO CAPACITY "); OUTINT(N, 0); OUTIMAGE;         TEMP :- NEW ITEMARRAY(N);         FOR I := 1 STEP 1 UNTIL SIZE DO            TEMP.DATA(I) :- ITEMS.DATA(I);         ITEMS :- TEMP;      END;       PROCEDURE ADD(T); REF(ITEM) T;      BEGIN         IF SIZE + 1 > CAPACITY THEN         BEGIN            CAPACITY := 2 * CAPACITY;            EXPAND(CAPACITY);         END;         SIZE := SIZE + 1;         ITEMS.DATA(SIZE) :- T;         OUTTEXT("SIZE IS "); OUTINT(SIZE, 0); OUTIMAGE;      END;       PROCEDURE REMOVE(I); INTEGER I;      BEGIN        INTEGER J;        IF I < 1 OR I > SIZE THEN ERROR("REMOVE: INDEX OUT OF BOUNDS");        FOR J := I STEP 1 UNTIL SIZE - 1 DO          ITEMS.DATA(J) :- ITEMS.DATA(J + 1);        ITEMS.DATA(SIZE) :- NONE;        SIZE := SIZE - 1;      END;       REF(ITEM) PROCEDURE GET(I); INTEGER I;      BEGIN         IF I < 1 OR I > SIZE THEN ERROR("GET: INDEX OUT OF BOUNDS");         GET :- ITEMS.DATA(I);      END;       INTEGER CAPACITY;      INTEGER SIZE;      REF(ITEMARRAY) ITEMS;       CAPACITY := 20;      SIZE := 0;      EXPAND(CAPACITY);    END;     ITEM CLASS TEXTITEM(TXT); TEXT TXT;;    ARRAYLIST CLASS TEXTARRAYLIST;   BEGIN      PROCEDURE ADD(T); TEXT T;         THIS TEXTARRAYLIST QUA ARRAYLIST.ADD(NEW TEXTITEM(T));      TEXT PROCEDURE GET(I); INTEGER I;         GET :- THIS TEXTARRAYLIST QUA ARRAYLIST.GET(I) QUA TEXTITEM.TXT;   END;     ITEM CLASS REALITEM(X); REAL X;;    ARRAYLIST CLASS REALARRAYLIST;   BEGIN      PROCEDURE ADD(X); REAL X;         THIS REALARRAYLIST QUA ARRAYLIST.ADD(NEW REALITEM(X));      REAL PROCEDURE GET(I); INTEGER I;         GET := THIS REALARRAYLIST QUA ARRAYLIST.GET(I) QUA REALITEM.X;   END;     REF(TEXTARRAYLIST) LINES;   REF(REALARRAYLIST) REALS;   INTEGER I;    LINES :- NEW TEXTARRAYLIST;   LINES.ADD("WE");   LINES.ADD("HAVE");   LINES.ADD("SEEN");   LINES.ADD("THAT");   LINES.ADD("ARRAYS");   LINES.ADD("ARE");   LINES.ADD("A");   LINES.ADD("VERY");   LINES.ADD("CONVENIENT");   LINES.ADD("WAY");   LINES.ADD("OF");   LINES.ADD("STORING");   LINES.ADD("SIMPLE");   LINES.ADD("VALUES");   LINES.ADD("AND");   LINES.ADD("REFERENCES");   LINES.ADD("TO");   LINES.ADD("MORE");   LINES.ADD("COMPLEX");   LINES.ADD("CLASS");   LINES.ADD("OBJECTS");   LINES.ADD("IN");   LINES.ADD("AN");   LINES.ADD("ORDERED");   LINES.ADD("LIST");   LINES.ADD(".");    FOR I := 1 STEP 1 UNTIL LINES.SIZE DO   BEGIN     OUTINT(I, 0); OUTTEXT(": ");     OUTTEXT(LINES.GET(I)); OUTIMAGE;   END;     REALS :- NEW REALARRAYLIST;   FOR I := 1 STEP 1 UNTIL 10 DO     REALS.ADD(I * I);    FOR I := 1 STEP 1 UNTIL REALS.SIZE DO   BEGIN     OUTINT(I, 4); OUTTEXT(": ");     OUTFIX(REALS.GET(I),2,10); OUTIMAGE;   END;    FOR I := REALS.SIZE STEP - 2 UNTIL 1 DO     REALS.REMOVE(I);    FOR I := 1 STEP 1 UNTIL REALS.SIZE DO   BEGIN     OUTINT(I, 4); OUTTEXT(": ");     OUTFIX(REALS.GET(I),2,10); OUTIMAGE;   END; END; `
Output:
```EXPAND TO CAPACITY 20
NEW ITEMARRAY WITH 20 ELEMENTS
SIZE IS 1
SIZE IS 2
SIZE IS 3
SIZE IS 4
SIZE IS 5
SIZE IS 6
SIZE IS 7
SIZE IS 8
SIZE IS 9
SIZE IS 10
SIZE IS 11
SIZE IS 12
SIZE IS 13
SIZE IS 14
SIZE IS 15
SIZE IS 16
SIZE IS 17
SIZE IS 18
SIZE IS 19
SIZE IS 20
EXPAND TO CAPACITY 40
NEW ITEMARRAY WITH 40 ELEMENTS
SIZE IS 21
SIZE IS 22
SIZE IS 23
SIZE IS 24
SIZE IS 25
SIZE IS 26
1: WE
2: HAVE
3: SEEN
4: THAT
5: ARRAYS
6: ARE
7: A
8: VERY
9: CONVENIENT
10: WAY
11: OF
12: STORING
13: SIMPLE
14: VALUES
15: AND
16: REFERENCES
17: TO
18: MORE
19: COMPLEX
20: CLASS
21: OBJECTS
22: IN
23: AN
24: ORDERED
25: LIST
26: .
EXPAND TO CAPACITY 20
NEW ITEMARRAY WITH 20 ELEMENTS
SIZE IS 1
SIZE IS 2
SIZE IS 3
SIZE IS 4
SIZE IS 5
SIZE IS 6
SIZE IS 7
SIZE IS 8
SIZE IS 9
SIZE IS 10
1:       1.00
2:       4.00
3:       9.00
4:      16.00
5:      25.00
6:      36.00
7:      49.00
8:      64.00
9:      81.00
10:     100.00
1:       1.00
2:       9.00
3:      25.00
4:      49.00
5:      81.00
```

## Slate

`slate[1]> #x := ##(1 2 3). {1. 2. 3}slate[2]> x{1. 2. 3}slate[3]> #y := {1 + 2. 3 + 4. 5}.{3. 7. 5}slate[4]> y at: 2 put: 99.99slate[5]> y{3. 7. 99}slate[6]> x first1slate[7]> x at: 0.1`

## Smalltalk

The Array class represents fixed size vectors with polymorphic contents. Array indexing is ONE-based. Fixed size means, that once created it is expensive (although not strictly impossible), to resize it (not strictly impossible because we could allocate a new array and #become that the old one). Most Smalltalks also provide element type restricted arrays, which are tuned (usually space-wise) for particular elements. For example: ByteArray, IntegerArray, LongIntegerArray, FloatArray or DoubleArray. Instances of them are also used to pass bulk data in and out of FFI calls (for example, for OpenGL). Also Strings can be seen as arrays of characters. All collection classes share a rich common protocol, which includes enumeration, stream converting, concatenation, copying, replacing, searching etc.

Finally, there is OrderedCollection, which behaves similar to Array, but allows for the number of elements to be changed (i.e. elements can be added and removed later). Usually, adding/removing at either end is cheap, so they can be used to implement stacks and queues.

Literal Arrays (Array constants):

`#(1 2 3 'four' 5.0 true false nil (10 20) \$a)`

a polymorphic array containing integers, a string, a float, booleans, a nil, another array with integers and a character constant.

Programatic use:

`|array|"creates an array that holds up to 20 elements"array := Array new: 20 ."access the first element: array base is 1"(array at: 1) displayNl."put 100 as second value; you can put any object,  in particular SmallInteger"array at: 2 put: 100."initialize an array from a 'constant' given array"array := Array withAll: #('an' 'apple' 'a' 'day' 'keeps' 'the' 'doctor' 'away')."Replacing apple with orange"array at: 2 put: 'orange'.`
`"assigning values to an array""suppose array is bound to an array of 20 values"array at: 5 put: 'substitute fifth element'. [ array at: 21 put: 'error' ]   on: SystemExceptions.IndexOutOfRange   do: [ :sig | 'Out of range!' displayNl ].`
`"retrieving a value from an array" #(\$a \$b \$c) at: 2`

Enumeration:

`array do:[:each | each printOn: aStream ]array collect:[:each | each squared|array select:[:each | each > 10]`
Works with: Pharo
Works with: Smalltalk/X
Works with: Squeak

Constructing an Array from evaluated expressions:

`{ Time now . 10 . Date today . 'foo' }`

this construct evaluates each expression and creates a 4-element array containing a time, int, date and string object.

OrderedCollection:

`oc := OrderedCollection withAll: #(4 5 6).oc add:1. oc add:2. oc add:3.foo := oc removeFirst.oc addFirst:10.oc removeLast.oc at:2 put: 'someString'.oc add:123 beforeIndex:10.oc asArray printCR.oc2 := oc copyFrom:5 to:10oc indexOf: 'someString'oc findFirst:[:el  | el isString]"hundreds of other methods skipped here.." `

## SNOBOL4

SNOBOL4 supports multi-dimensional arrays and array initialization.

`      ar = ARRAY("3,2")      ;* 3 rows, 2 columnsfill  i = LT(i, 3) i + 1     :F(display)      ar<i,1> = i      ar<i,2> = i "-count"   :(fill) display                      ;* fail on end of array      j = j + 1      OUTPUT = "Row " ar<j,1> ": " ar<j,2>+                            :S(display)END`
Output:
```Row 1: 1-count
Row 2: 2-count
Row 3: 3-count
```

## SPL

`a[1] = 2.5a[2] = 3a[3] = "Result is "#.output(a[3],a[1]+a[2])`
Output:
```Result is 5.5
```

## SSEM

At the machine level, an array is a block of sequential storage addresses. Modern computer architectures support arrays through indexed addressing, where the contents of a particular register can be used to provide an offset from some specified address. A program to find the sum of a four-element array beginning at address array might look, in pseudocode, like this:

```        load          register 0,  #0         ; running total
load          register 1,  #0         ; index
loop:   add           register 0,  array+register 1
compare       register 1,  #4
branchIfLess  loop```

If we do not know in advance how many elements the array will have, we can mark the end with a special value (say, zero) and test for that. Again in pseudocode:

```        load          register 0,  #0         ; running total
load          register 1,  #0         ; index
loop:   load          register 2,  array+register 1
compare       register 2,  #0
branchIfEqual done
goTo          loop
done:            ; program continues with sum in register 0```

On a machine like the SSEM, which has only one addressing mode and only one general-purpose register (the accumulator or c), we can achieve the same things using instruction arithmetic—also known as self-modifying code. Since an instruction that refers to address ${\displaystyle n+1}$ can be obtained by adding one to an instruction that refers to address ${\displaystyle n}$, the pseudocode to find the sum of a four-element array (and store it at address sum, which we assume initially holds zero) becomes:

```loop:   load          accumulator, sum
store         accumulator, sum
branchIfEqual done
store         accumulator, instr
goTo          loop
done:            ; program continues```

We are now in a position to translate this algorithm into SSEM instructions and run it. As always, the SSEM version is a bit fiddlier than the pseudocode because the SSEM has no load or add instructions; but it follows the pseudocode as closely as the instruction set allows, so it should be comparatively readable. As a test, we shall sum an array of the first four positive integers—a very significant operation for the Pythagoreans of old—and halt with the accumulator holding the result.

`10101000000000100000000000000000   0. -21 to c11101000000000010000000000000000   1. Sub. 2300101000000001100000000000000000   2. c to 2000101000000000100000000000000000   3. -20 to c10101000000001100000000000000000   4. c to 2110000000000000100000000000000000   5. -1 to c01001000000000010000000000000000   6. Sub. 1800101000000001100000000000000000   7. c to 2000101000000000100000000000000000   8. -20 to c10000000000001100000000000000000   9. c to 101101000000000010000000000000000  10. Sub. 2200000000000000110000000000000000  11. Test01001000000001000000000000000000  12. Add 18 to CI11001000000000000000000000000000  13. 19 to CI10101000000000100000000000000000  14. -21 to c00101000000001100000000000000000  15. c to 2000101000000000100000000000000000  16. -20 to c00000000000001110000000000000000  17. Stop10000000000000000000000000000000  18. 111111111111111111111111111111111  19. -100000000000000000000000000000000  20. 000000000000000000000000000000000  21. 011011000000000010000000000000000  22. Sub. 2710000000000000000000000000000000  23. 101000000000000000000000000000000  24. 211000000000000000000000000000000  25. 300100000000000000000000000000000  26. 4`

The program could easily be modified to work with arrays of unknown length, if required, along the lines of the second pseudocode example above.

## Standard ML

` (* create first array and assign elements *)-val first = Array.tabulate (10,fn x=>x+10) ;val first = fromList[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]: int array (* assign to array 'second' *)-val second=first ;val second = fromList[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]: int array (* retrieve 5th element *)-Array.sub(second,4);val it = 14: int `

## Stata

In Stata, there are mainly two ways to work with arrays: the matrix command can create and manipulate arrays, either elementwise or using matrix functions. And there is Mata, a matrix programming language similar to MATLAB, R or SAS/IML.

There are ways to exchange data between Stata datasets, Stata matrices, and Mata matrices:

• the Mata functions st_data and st_view are used to read data from the current Stata dataset to a Mata matrix (st_data copies data, while st_view creates a view, that can be used to modify the dataset in place).
• The Mata function st_store is used to write a Mata matrix into the current dataset.
• the Mata function st_matrix is used to read or write from/to a Stata matrix to a Mata matrix.
• the mkmat and svmat commands are used to store data from a dataset to a Stata matric and vice versa.

Both Stata matrices and Mata matrices have either one or two dimensions. For both, functions are provided for the usual linear algebra functions (Cholesky and SVD decompositions, for instance). Stata matrices must contain real numbers (or missing values), while Mata matrices may contain complex numbers, or strings (but either a matrix contains only numeric values, either it contains only string values).

### Matrix command

`matrix a = 2,9,4\7,5,3\6,1,8display det(a)matrix svd u d v = amatrix b = u*diag(d)*v'matrix list b* store the u and v matrices in the current datasetsvmat usvmat v`

### Mata

`mataa = 2,9,4\7,5,3\6,1,8det(a)svd(a, u=., s=., v=.)// Notice that to reconstruct the matrix, v is not transposed here,// while it is with -matrix svd- in Stata.u*diag(s)*v`

## Suneido

`array = Object('zero', 'one', 'two')array.Add('three')array.Add('five', at: 5)array[4] = 'four'Print(array[3]) --> 'three'`

## Swift

`// Arrays are typed in Swift, however, using the Any object we can add any type. Swift does not support fixed length arraysvar anyArray = [Any]()anyArray.append("foo") // Adding to an ArrayanyArray.append(1) // ["foo", 1]anyArray.removeAtIndex(1) // Remove objectanyArray[0] = "bar" // ["bar"]`

## Tailspin

` // arrays are created as literals, by simply listing elements, or by a generator expression, or a combination.def a: [1, 2, 3..7:2, 11];\$a -> !OUT::write'' -> !OUT::write // Natural indexes start at 1\$a(1) -> !OUT::write'' -> !OUT::write // You can select a range\$a(3..last) -> !OUT::write'' -> !OUT::write // Or a permutation/selection\$a([4,1,5]) -> !OUT::write'' -> !OUT::write // Values in Tailspin are generally immutable, but there is a mutable slot in a function/templates.// A mutable array can be appended5 -> \(@: [1,2]; \$ -> ..|@: \$; [email protected] ! \) -> !OUT::write `
Output:
```[1, 2, 3, 5, 7, 11]
1
[3, 5, 7, 11]
[5, 1, 7]
[1, 2, 5]
```

## Tcl

Tcl's lists are really dynamic array values behind the scenes. (Note that Tcl uses the term “array” to refer to an associative collection of variables.)

`set ary {} lappend ary 1lappend ary 3 lset ary 0 2 puts [lindex \$ary 0]`

Note also that serialization is automatic on treating as a string:

`puts \$ary; # Print the whole array`

## Tern

Arrays and lists are synonymous in Tern.

`let list = [1, 22, 3, 24, 35, 6]; for(i in list) {   println(i);} `
Output:
```1
22
3
24
35
6```

## TI-83 BASIC

In TI-83 BASIC there are two sequenced data types: Lists and Matrices.
List
One dimensional arrays are lists, they can be set as a whole with the syntax:

`{1,2,3,4,5}→L1`

using only numerical values separated by commas and enclosed by curly braces.
Lists can be accessed as a whole using L1-L6 or a custom list name using the L command in the "OPS" section of the "LIST" menu (2nd STAT (Right Arrow) B). You can also retrieve a single value from a list using the name of the list and the position of the value, which starts at 1 on the left.

`{1,2,3,4,5}→L1Disp L1(3)0→L1(4)`

This would return 3 and set the fourth list element to 0.
You can dynamically define or delete lists by:

`20→dim(L1)DelVar L15→dim(∟MYLIST)DelVar ∟MYLIST`

Matrix
Two dimensional arrays are matrices. Similar, set them and retrieve numbers using the syntax:

`[[11,21,31,41][12,22,32,42][13,23,33,43]]→[A]Disp [A](1,3)0→[A](4,2)`

This would return 13 and set the element (4,2) to 0.
You can dynamically define or delete matrices by:

`{5,5}→dim([A])DelVar [A]`

## TorqueScript

Arrays in TorqueScript:

` \$array[0] = "hi";\$array[1] = "hello"; for(%i=0;%i<2;%i++)	echo(\$array[%i]);`

=> hi

=> hello

` \$array["Greet",0] = "hi";\$array["Greet",1] = "hello"; for(%i=0;%i<2;%i++)	echo(\$array["Greet",%i]);`

=> hi

=> hello

## Transd

Arrays in Transd are implemented in the form of dynamic containers: Vectors. Vector is a type parameterized container (also known as "generic"), that is a Vector object can only hold values of a single type.

Vectors can be created as empty containers, or they can be initialized with some values at the time of creation.

`module1 : {  v1: Vector<Int>(),  v2: Vector<String>(),  v3: Vector<Int>([1,2,3,4]),  v4: Vector<String>(["one","two","three"]),  // the type of vector values can automaticaly deduced  v5: [1.0, 2.5, 8.6], // Vector<Double>  v6: ["one","two","three"] // Vector<String>}`

Individual elements in a vector can be read, appended, and deleted.

`(with v [1,2,3]  (textout (get v 1)) // <= 2  (erase v 1)  (textout v) // <= [1, 3]  (append v 7)  (textout v) // <= [1, 3, 7])`

All standard container operations can be applied to vectors:

`(with v [3,1,5,2,4]  (textout (reverse v)) // <= [4, 2, 5, 1, 3]  (textout (sort v)) // <= [1, 2, 3, 4, 5]  (textout (shuffle v)) // <= [5, 3, 4, 1, 2])`

## TXR

TXR has two kinds of aggregate objects for sequences: lists and arrays. There is some syntactic sugar to manipulate them in the same way.

#### Literals

In the pattern matching language, there are no list literals. A list like `("a" "b" "c")` is actually being evaluated, as can be seen in a directive such as `@(bind (a b) (c "d"))` where `(c "d")` is a list consisting of the value of variable `c` and the string `"d"`. This is subject to destructuring and the two values are assigned to the variables `a` and `b`

In TXR Lisp, there are literal lists introduced by a quote `'(1 2 3 4)`. Vectors look like this: `#(1 2 3 4)`.

#### Construction

Lists can be implicitly produced using pattern matching. Lists and vectors can be constructed using the functions of TXR Lisp. `(vector 3)` creates a vector of length three, whose elements are initialized to `nil`. `(list 1 2 3)` constructs the list `(1 2 3)`.

#### Array Indexing Notation

The [] notation performs positional indexing on lists and arrays, which are both zero-based (element zero is the first element). Negative indices work from the tail of the list, whereby -1 denotes the last element of a sequence which has at least one element. Out of bounds access to arrays throws exceptions, but out of bounds access to lists produces nil. Out-of-bounds assignments are not permitted for either data type.

```(defvar li (list 1 2 3))      ;; (1 2 3)
(defvar ve (vec 1 2 3)) ;; make vector #(1 2 3)
;; (defvar ve (vector 3)) ;; make #(nil nil nil)

[ve 0]    ;; yields 1
[li 0]    ;; yields 1
[ve -1]   ;; yields 3
[li 5]    ;; yields nil
[li -50]  ;; yields nil
[ve 50]   ;; error

(set [ve 2] 4) ;; changes vector to #(1 2 4).
(set [ve 3] 0) ;; error
(set [ve 3] 0) ;; error```

#### Array Range Notation

Array range notation (slices) are supported, for both arrays and lists. An array range is a pair object denoted `a .. b`, which is a syntactic sugar for `(cons a b)`. Therefore, a range constitutes a single argument in the bracket notation (allowing for straightforward future extension to multi-dimensional arrays indexing and slicing).

```[ve 0..t]              ;; yield all of vector: t means "one position past last element"
[ve nil..nil]          ;; another way
[ve 1 3]               ;; yields #(2 3)
(set [ve 0..2] '(a b))  ;; changes vector to #(a b 3)
(set [ve 0..2] #(1 2))  ;; changes vector to #(1 2 3)
(set [li 0..1] nil)     ;; changes list to #(2 3), deleting 1.
(set [li t..t] '(4 5))  ;; changes list to #(2 3 4 5), appending (4 5)
(set [ve 1..2] '(0 0))  ;; changes vector to #(1 0 0 3), replacing 2 with 0 0```

#### In The Pattern Language

In the TXR pattern language, there is an array indexing and slicing notation supported in output variables. The following assumes that variable `a` holds a list.

```@(output)
here is a[0] left-adjusted in a 10 character field:

@{a[0] 10}.

here are a[1] through a[3] joined with a colon,
right-adjusted in a 20 character field:

@{a[1..4] ":" -20}
@(end)```

A complete program which turns comma-separated into tab-separated, where the first and last field from each line are exchanged:

`@(collect)@line@(bind f @(split-str line ","))@(output)@{f[-1]}@\[email protected]{f[1..-1] "\t"}@\[email protected]{f[0]}@(end)@(end)`

#### Other Kinds of Objects

The `[]` notation also works with strings, including ranges and assignment to ranges.

Hash tables can be indexed also, and the notation is meaningful for functions: `[fun args ...]` means the same thing as `(call fun args ...)`, providing a Lisp-1 flavor within a Lisp-2 dialect.

## uBasic/4tH

uBasic/4tH has only one single, global array of 256 integers. Since it's fixed, it can't be declared.

`Let @(0) = 5 : Print @(0)`

## Unicon

Unicon's arrays are provided by the list type, which is a hybrid list/array type. Lists of integers or reals, if not polluted by other types nor changed in size, may use a C-compatible internal representation (long and double).

`L := list(100); L[12] := 7; a := array(100, 0.0); a[3] +:= a[1]+a[2]`

## UNIX Shell

Bash supports one-dimensional arrays, which are zero-indexed. Zero-indexing means that if the array has five items in it, the first item is at index 0, and the last item is at index 4.

Two-dimensional arrays can be accomplished using shell functions applied to arrays of array names. Basically, hiding the indirection within the shell function invocation.

To create an array:

`alist=( item1 item2 item3 )  # creates a 3 item array called "alist"declare -a list2        # declare an empty list called "list2"declare -a list3[0]     # empty list called "list3"; the subscript is ignored # create a 4 item list, with a specific orderlist5=([3]=apple [2]=cherry [1]=banana [0]=strawberry)`

To obtain the number of items in an array:

`count=\${#alist[*]}echo "The number of items in alist is \${#alist[*]}"`

To iterate up over the items in the array:

`x=0while [[ \$x < \${#alist[*]} ]]; do  echo "Item \$x = \${alist[\$x]}"  : \$((x++))done`

To iterate down over theitems in an array:

`x=\${#alist[*]}       # start with the number of items in the arraywhile [[ \$x > 0 ]]; do     # while there are items left  : \$((x--))               # decrement first, because indexing is zero-based  echo "Item \$x = \${alist[\$x]}"   # show the current itemdone`

To append to an array, use the current number of items in the array as the next index:

`alist[\${#alist[*]}]=new_item`

To make appending easier, use a little shell function, let's call it "push", and design it to allow appending multiple values, while also preserving quoted values:

`# shell function to append values to an array# push LIST VALUES ...push() {  local var=\${1:?'Missing variable name!'}  shift  eval "\\$\$var=( \"\\${\$var[@]}\" \"[email protected]\" )"} push alist "one thing to add"push alist many words to add`

To delete a single array item, the first item:

`unset alist[0]`

To delete and return the last item in an array (e.g., "pop" function):

`# pop ARRAY -- pop the last item on ARRAY and output it pop() {  local var=\${1:?'Missing array name'}  local x ;   eval "x=\\${#\$var[*]}"  if [[ \$x > 0 ]]; then    local val ; eval "val=\"\\${\$var[\$((--x))]}\""    unset \$var[\$x]  else    echo 1>&2 "No items in \$var" ; exit 1  fi  echo "\$val"} alist=(a b c)pop alistapop alistbpop alistcpop alistNo items in alist`

To delete all the items in an array:

`unset alist[*]`

To delete the array itself (and all items in it, of course):

`unset alist`

## உயிர்/Uyir

`         இருபரிமாணணி வகை எண் அணி {3, 3};        இருபரிமாணணி2 வகை எண் அணி {3} அணி {3};        என்_எண்கள் வகை எண் {#5.2} அணி {5} = {3.14, 2.83, 5.32, 10.66, 14};        சொற்கள் வகை சரம் {25} அணி {100};        உயரங்கள் = அணி {10, 45, 87, 29, 53};        பெயர்கள் = அணி {"இராஜன்", "சுதன்", "தானி"};        தேதிகள் = அணி {{5, "மாசி", 2010}, {16, "புரட்டாசி", 1982}, {22, "ஆவணி", 1470}};        செவ்வகணி = அணி { அணி {10, 22, 43}, அணி {31, 58, 192}, அணி {46, 73, 65} };        முக்கோண்ணி = அணி { அணி {1}, அணி {2, 3}, அணி {4, 5, 6}, அணி {7, 8, 9, 1, 2} }; `

## Vala

Non-dynamic arrays:

` int[] array = new int[10]; array[0] = 1;array[1] = 3; stdout.printf("%d\n", array[0]); `
Library: Gee

Dynamic Arrays with Gee:

` var array = new ArrayList<int> (); array.add(1);array.add(3); array[0] = 2; stdout.printf("%d\n", array[0]); `

## VBA

The Option Base statement is used at the module level to declare the default lower bound for array subscripts.

`Option Base {0|1} `
`Sub matrix()    'create an array,    Dim a(3) As Integer    Dim i As Integer    'assign a value to it,    For i = 1 To 3        a(i) = i * i    Next i    'and retrieve an element    For i = 1 To 3        Debug.Print a(i)    Next i    'dynamic    Dim d() As Integer    ReDim d(3)    For i = 1 To 3        d(i) = i * i    Next i    'and retrieve an element    For i = 1 To 3        Debug.Print d(i)    Next i    'push a value to it - expand the array and preserve existing values    ReDim Preserve d(4)    d(4) = 16:    For i = 1 To 4        Debug.Print d(i)    Next iEnd Sub`
Output:
` 1  4  9  1  4  9  1  4  9  16 `

## VBScript

`'Arrays - VBScript - 08/02/2021    'create a static array    Dim a(3)   ' 4 items : a(0), a(1), a(2), a(3)    'assign a value to elements    For i = 1 To 3        a(i) = i * i    Next    'and retrieve elements	buf=""    For i = 1 To 3        buf = buf & a(i) & " "    Next    WScript.Echo buf     'create a dynamic array     Dim d()    ReDim d(3)   ' 4 items : d(0), d(1), d(2), d(3)    For i = 1 To 3        d(i) = i * i    Next	buf=""    For i = 1 To 3        buf = buf & d(i) & " "    Next	WScript.Echo buf 	d(0) = 0    'expand the array and preserve existing values    ReDim Preserve d(4)   ' 5 items : d(0), d(1), d(2), d(3), d(4)    d(4) = 16	buf=""    For i = LBound(d) To UBound(d)        buf = buf & d(i) & " "    Next	WScript.Echo buf 	'create and initialize an array dynamicaly    b = Array(1, 4, 9)	'and retrieve all elements	WScript.Echo Join(b,",") 	'Multi-Dimensional arrays	'The following creates a 5x4 matrix 	Dim mat(4,3) `
Output:
```1 4 9
1 4 9
0 1 4 9 16
1,4,9
```

## VHDL

` entity Array_Test isend entity Array_Test; architecture Example of Array_test is    -- Array type have to be defined first   type Integer_Array is array (Integer range <>) of Integer;    -- Array index range can be ascending...   signal A : Integer_Array (1 to 20);    -- or descending   signal B : Integer_Array (20 downto 1);    -- VHDL array index ranges may begin at any value, not just 0 or 1   signal C : Integer_Array (-37 to 20);    -- VHDL arrays may be indexed by enumerated types, which are   -- discrete non-numeric types   type Days is (Mon, Tue, Wed, Thu, Fri, Sat, Sun);   type Activities is (Work, Fish);   type Daily_Activities is array (Days) of Activities;   signal This_Week : Daily_Activities := (Mon to Fri => Work, Others => Fish);    type Finger is range 1 to 4; -- exclude thumb   type Fingers_Extended is array (Finger) of Boolean;   signal Extended : Fingers_Extended;    -- Array types may be unconstrained.   -- Objects of the type must be constrained   type Arr is array (Integer range <>) of Integer;   signal Uninitialized : Arr (1 to 10);   signal Initialized_1 : Arr (1 to 20) := (others => 1);   constant Initialized_2 : Arr := (1 to 30 => 2);   constant Const : Arr := (1 to 10 => 1, 11 to 20 => 2, 21 | 22 => 3);   signal Centered : Arr (-50 to 50) := (0 => 1, others => 0);    signal Result : Integer; begin    A <= (others => 0);           -- Assign whole array   B <= (1 => 1, 2 => 1,         3 => 2, others => 0);   -- Assign whole array, different values   A (1) <= -1;                  -- Assign individual element   A (2 to 4) <= B (3 downto 1); -- Assign a slice   A (3 to 5) <= (2, 4, -1);     -- Assign an aggregate   A (3 to 5) <= A (4 to 6);     -- It is OK to overlap slices when assigned    -- VHDL arrays does not have 'first' and 'last' elements,   -- but have 'Left' and 'Right' instead   Extended (Extended'Left)  <= False; -- Set leftmost element of array   Extended (Extended'Right) <= False; -- Set rightmost element of array    Result <= A (A'Low) + B (B'High); end architecture Example; `

## Vim Script

Lists can be used for dynamic arrays. Indexing starts at 0.

`" Creating a dynamic array with some initial valueslet array = [3, 4] " Retrieving an elementlet four = array[1] " Modifying an elementlet array[0] = 2 " Appending a new elementcall add(array, 5) " Prepending a new elementcall insert(array, 1) " Inserting a new element before another elementcall insert(array, 3, 2) echo array`
Output:
`[1, 2, 3, 4, 5]`

## Visual Basic .NET

`'Example of array of 10 int types: Dim numbers As Integer() = New Integer(9) {}'Example of array of 4 string types: Dim words As String() = {"hello", "world", "from", "mars"}'You can also declare the size of the array and initialize the values at the same time: Dim more_numbers As Integer() = New Integer(2) {21, 14, 63} 'For Multi-Dimensional arrays you declare them the same except for a comma in the type declaration. 'The following creates a 3x2 int matrix Dim number_matrix As Integer(,) = New Integer(2, 1) {}  '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. Dim string_matrix As String(,) = {{"I", "swam"}, {"in", "the"}, {"freezing", "water"}}'orDim funny_matrix As String(,) = New String(1, 1) {{"clowns", "are"}, {"not", "funny"}} Dim array As Integer() = New Integer(9) {}array(0) = 1array(1) = 3Console.WriteLine(array(0))  'DynamicImports SystemImports System.Collections.GenericDim list As New List(Of Integer)()list.Add(1)list.Add(3)list(0) = 2Console.WriteLine(list(0))`

## Vlang

`// Arrays, in V// Tectonics: v run arrays.vmodule main // A little bit about V variables.  V does not allow uninitialized data.// If an identifier exists, there is a valid value.  "Empty" arrays have// values in all positions, and V provides defaults for base types if not// explicitly specified. E.g. 0 for numbers, `0` for rune, "" for strings. // V uses := for definition and initialization, and = for assignment // starts here, V programs start by invoking the "main" function.pub fn main() {    // Array definition in source literal form (immutable)   array := [1,2,3,4]   // print first element, 0 relative indexing   println("array: \$array")   println("array[0]: \${array[0]}")   // immutable arrays cannot be modified after initialization   // array[1] = 5, would fail to compile with a message it needs mut    // Dynamic arrays have some property fields   println("array.len: \$array.len")   println("array.cap: \$array.cap")    // array specs are [n]type{properties}   // Dynamic array definition, initial default values, "" for string   mut array2 := []string{}   // Append an element, using lessless   array2 << "First"   println("array2[0]: \${array2[0]}")   println("array2.len: \$array2.len")   println("array2.cap: \$array2.cap")    // Fixed array definition, capacity is fixed (! suffix), mutable entries   mut array3 := ["First", "Second", "Third"]!   println("array3: \$array3")   array3[array3.len-1] = "Last"   println("array3: \$array3")   println("array3.len: \$array3.len")    // Advanced, array intiailization using non default value   mut array4 := [4]int{init: 42}   array4[2] = 21   println("array4: \$array4")    // Arrays can be sliced, creating a copy   mut array5 := array4[0..3]   println("array5: \$array5")   array5[2] = 10   println("array4: \$array4")   println("array5: \$array5")}`
Output:
```prompt\$ v run arrays.v
array: [1, 2, 3, 4]
array[0]: 1
array.len: 4
array.cap: 4
array2[0]: First
array2.len: 1
array2.cap: 2
array3: ['First', 'Second', 'Third']
array3: ['First', 'Second', 'Last']
array3.len: 3
array4: [42, 42, 21, 42]
array5: [42, 42, 21]
array4: [42, 42, 21, 42]
array5: [42, 42, 10]```

## Wee Basic

`dim array\$(2)let array\$(1)="Hello!"let array\$(2)="Goodbye!"print 1 array\$(1)`

## Wren

`var arr = []arr.add(1)arr.add(2)arr.count // 2arr.clear() arr.add(0)arr.add(arr[0])arr.add(1)arr.add(arr[-1])  // [0, 0, 1, 1] arr[-1] = 0arr.insert(-1, 0) // [0, 0, 1, 0, 0]arr.removeAt(2)   // [0, 0, 0, 0]`

## X86 Assembly

` section .text	global _start 	_print:		mov ebx, 1		mov eax, 4		int 0x80		ret 	_start:		;print out our byte array. ergo, String.		mov edx, sLen		mov ecx, sArray		call _print		mov edx, f_len		mov ecx, f_msg		call _print		mov edx, 6			;our array members length.		xor ecx, ecx		mov ecx, 4		;turnicate through the array and print all it's members.		;At an offset of *4, each array member is referenced		;at 1,2,3 and so on. 		_out_loops:			push ecx			mov ecx, [fArray+esi*4]			call _print			inc esi			pop ecx		loop _out_loops		mov edx, u_len		mov ecx, u_msg		call _print		;Let's populate 'uArray' with something from sArray.		;mov edi, uArray		mov ecx, 4		xor esi, esi		_read_loops:				push dword [fArray+esi*4]			pop dword [uArray+esi*4]			inc esi		loop _read_loops		mov ecx, 4		xor esi, esi		_out_loops2:			push ecx			mov ecx, [uArray+esi*4]			call _print			inc esi			pop ecx		loop _out_loops2		push 0x1		mov eax, 1		push eax		int 0x80 section .datasArray	db 'a','r','r','a','y','s',' ','a','r','e',' ','f','u','n',0xasLen		equ \$-sArray crap1		db "crap1",0xacrap2		db "crap2",0xacrap3		db "crap3",0xacrap4		db "crap4",0xa fArray	dd crap1,crap2	dd crap3,crap4 f_msg		db "fArray contents",0xa,"----------------------",0xaf_len		equ \$-f_msgu_msg		db "uArray now holds fArray contents.. dumping..",0xa,"----------------------",0xau_len		equ \$-u_msg section .bssuArray	resd 1        resd 1	resd 1	resd 1 `

Arrays in assembly are a reference to anything, from groups of data such as f/uArray to strings like _msg's or sArray. Mutlidimentional arrays don't exist in assembly. To make a reference to one from assembly, we use a format as such. "row * r_len + column * member_size".

## XBS

Arrays in XBS are very similar to JavaScript.

`set Array = ["Hello","World"];log(Array[0]);Array.push("Test");log(?Array);log(Array[?Array-1]);`

## XLISP

Like some other languages, XLISP refers to one-dimensional arrays as vectors. Examples of vector and array syntax, from a REPL (interactive session):

`[1] (define a (make-vector 10)) ; vector of 10 elements initialized to the empty list A[2] (define b (make-vector 10 5)) ; vector of 10 elements initialized to 5 B[3] (define c #(1 2 3 4 5 6 7 8 9 10)) ; vector literal C[4] (vector-ref c 3) ; retrieve a value -- NB. indexed from 0 4[5] (vector-set! a 5 1) ; set a_5 to 1 1[6] (define d (make-array 5 6 7)) ; 3-dimensional array of size 5 by 6 by 7 D[7] (array-set! d 1 2 3 10) ; set d_1,2,3 to 10 -- NB. still indexed from 0 10[8] (array-ref d 1 2 3) ; and get the value of d_1,2,3 10`

## XPL0

`include c:\cxpl\codes;char A(10);             \creates a static array of 10 bytes, pointed to by "A"char B;                 \declares a variable for a pointer to a dynamic array[A(3):= 14;B:= Reserve(10);        \reserve 10 bytes and point to their starting addressB(7):= 28;IntOut(0, A(3)+B(7));   \displays 42]`

## Yabasic

`dim a(10)		// create a numeric array with 11 elements, from 0 to 10				// Indexed at your preference (0 to 9 or 1 to 10)print arraysize(a(), 1)	// this function return the element's higher number of an array a(7) = 12.3		// access to an element of the array				redim a(20)		// alias of 'dim'. Grouth size of array // Yabasic not allow direct downsize an array, but ... dim a\$(20)		// create a textual array with 21 elements print arraysize(a\$(), 1) void = token("1,2,3,4,5,6,7,8,9,10", a\$(), ",")	// populate it. Begun with element 1 (not 0). print arraysize(a\$(), 1)	// hey! the size is down print a\$(5)		// show the content of an element of the array void = token("", a\$())	// "erase" the array content AND redim it to 0 size print arraysize(a\$(), 1) redim a\$(10)	// resize the array print arraysize(a\$(), 1) print a\$(5)		// show the content of an element of the array. Now is empty`

## Z80 Assembly

An array is nothing more than a contiguous section of memory. Whether an array is mutable or not is solely determined by whether its memory location is in ROM or RAM.

`Array:        ;an array located in RAM. Its values can be updated freely.     byte 0,0,0,0,0     byte 0,0,0,0,0     byte 0,0,0,0,0     byte 0,0,0,0,0`

Side note: Some systems, such as the Game Boy or other ROM cartridge-based computers, cannot use the above declaration to initialize an array in RAM at assemble time; only in ROM. While the label "Array" can be given to an arbitrary RAM location on any system, you won't be able to define a data block in RAM the same way you would on an assembly program meant to run on the Amstrad CPC or ZX Spectrum for example. The examples below will still work on any system, you just won't be able to "see" the array before running the program, if that makes sense. Clearing the system ram will suffice to initialize the array to zero.

Although it is heavily implied that the above array is 4x5, the CPU makes no distinction whatsoever between linear data and square arrays or matrices. The programmer has intended the array to be 4x5 (and it is the best practice to write the array as such) but the CPU doesn't enforce array sizes in any way. One way to do this in software is with metadata that is placed in front of the actual array, which has a fixed length. This metadata can specify the dimensions of the array as well as the data type (8 bits per element, 16 bits per element, etc.)

This code will assign a value of decimal 20 to the 1st (zero-indexed) row and 2nd (zero-indexed) column. The resulting array will look like this:

`Array:            byte 0,0,0,0,0     byte 0,0,20,0,0     byte 0,0,0,0,0     byte 0,0,0,0,0`

`;for this example the array's size, the data we want to write, and where we want to write the data, are all known in advance. ld hl,Array ;hl points to the 0th element of row 0.ld c,5      ;one-indexed row lengthld b,0      ;set bc = row lengthadd hl,bc   ;now hl points to the 0th element of row 1.inc hl      ;now hl points to the 1st element of row 1.inc hl      ;now hl points to the 2nd element of row 1. This is where we planned on storing our new value.ld a,20     ;get the value 20 which we want to store hereld (hl),a   ;store 20 into the desired slot. (Retrieving a value is the same process except we skip the step above and            ;     execute "ld a,(hl)" at this point instead.)`

The main takeaway from all this is that arrays are handled the same as any other type of memory, and have no "special" syntax, apart from the boilerplate pointer arithmetic of `*array = *array + (desired_row_number*row_length*bytes_per_element) + (desired_column_number*bytes_per_element)`. This is the case for most assembly languages, even though the methods of offsetting a pointer may vary.

### Array Alignment

One very important topic for arrays in Z80 Assembly is alignment. If you need fast access to the data in an array, you can more than triple your lookup speed by aligning the table ahead of time. If an array of 8-bit data is placed so that its base address ends in 00, you really only need to load half the pointer to the table into the "high register" (B, D, H, IXH, or IYH) and the desired index into the corresponding "low register." Using an `org` or `align` directive is the easiest way to accomplish this task. Aligned tables are very important in Z80 Assembly, more so than in other assembly languages, since Z80's index registers are, for a lack of a better term, underwhelming at best. Not only are they slow, you are limited to using constant offsets only (unless you use self-modifying code) and are also signed offsets meaning that you can't index an array longer than 128 bytes without doing additional pointer arithmetic. Having indexing limitations is not unusual for most CPUs but the Z80 is probably one of the worst at it. Thankfully, table alignment can solve nearly all those problems (assuming you have enough padding to spare.)

In the example below, we wish to load the 13th (zero-indexed) element from the array MyTable.

`LD H,>MyTable  ;works out to be LD h,4 thanks to our alignment below.                ;>LABEL means "the high byte of the address represented by LABELLD L,13        ;this was a lot faster than doing LD HL,&0400 and adding the desired index later.LD a,(HL)      ;loads 12 into the accumulator.RET             org &0400MyTable:       ;thanks to the ORG statement above, this label's address is guaranteed to be &0400byte 1,2,3,4,5byte 2,4,6,8,10byte 3,6,9,12,15byte 4,8,12,16,20byte 5,10,15,20,25`

But what if you're working with 16-bit data? If you've got bytes to burn, you can separate your data into two "byteplanes" - a pair of tables, one of which contains the low bytes and the other containing the high bytes, both sharing a common index. Using alignment you can guarantee that they are a multiple of &0100 bytes apart, which simplifies the lookup process greatly. You can get away with loading just the high byte of the pointer to the "low table" and incrementing that half of the pointer to get to the high byte, while leaving the index (which is stored in the low half of your pointer register) intact.

That might have been a bit confusing, so let's visualize the concept. Here's a practical example of storing a sine wave pattern. Instead of storing 16-bit data together like you normally would:

`org &0400  word &8000,&8327,&864e,&8973,&8c98,&8fba,&92da,&95f7  word &9911,&9c27,&9f38,&a244,&a54c,&a84d,&ab48,&ae3c  word &b12a,&b40f,&b6ed,&b9c2,&bc8e,&bf50,&c209,&c4b7  word &c75b,&c9f4,&cc81,&cf02,&d177,&d3e0,&d63b,&d889`

You can instead store it like this:

`org &0400  byte <&8000,<&8327,<&864e,<&8973,<&8c98,<&8fba,<&92da,<&95f7  byte <&9911,<&9c27,<&9f38,<&a244,<&a54c,<&a84d,<&ab48,<&ae3c  byte <&b12a,<&b40f,<&b6ed,<&b9c2,<&bc8e,<&bf50,<&c209,<&c4b7  byte <&c75b,<&c9f4,<&cc81,<&cf02,<&d177,<&d3e0,<&d63b,<&d889org &0500  byte >&8000,>&8327,>&864e,>&8973,>&8c98,>&8fba,>&92da,>&95f7  byte >&9911,>&9c27,>&9f38,>&a244,>&a54c,>&a84d,>&ab48,>&ae3c  byte >&b12a,>&b40f,>&b6ed,>&b9c2,>&bc8e,>&bf50,>&c209,>&c4b7  byte >&c75b,>&c9f4,>&cc81,>&cf02,>&d177,>&d3e0,>&d63b,>&d889`

If your assembler is cool like mine is, this will be valid despite looking like I'm trying to declare what is obviously 16-bit data as 8-bit data. Many Z80 assemblers have some sort of "low byte" and "high byte" operator, it might not be the same symbol but most have it. If yours doesn't, I'd recommend using one that does, because it's really necessary for optimizations like these. In addition it makes the code more readable as it communicates to the reader how the data is intended to be interpreted.

So let's say we want to read the last entry in "the table".

`LD h,&04  ;load high byte of address &0400LD L,&1F  ;desired indexld a,(hl)ld c,ainc h     ;LD h,&05. We can keep L the same since the index is the same.           ;Effectively we did all the necessary pointer arithmetic for indexing the second table, just with this one instruction!ld a,(hl) ;now we have the low byte in C and the high byte in A.`

That would have taken a lot more instructions had this been a single table of words with more than 128 entries. You'd have to do some bit shifting to offset the pointer to the table by the desired index, and it would have just taken a lot more time. If you're trying to get something done quickly (such as a raster interrupt) you want to spend as little time doing lookups as possible.

## zkl

Core zkl does not support arrays or vectors of one type. It does support heterogeneous lists, which are usually a super set at the cost of space.

`var array=List();  // array of size 0array=(0).pump(10,List().write,5).copy(); // [writable] array of size 10 filled with 5array[3]=4;array[3] //-->4array+9; //append a 9 to the end, same as array.append(9)`

## zonnon

` var  a: array 10 of integer;  da: array * of cardinal; `

## ZX Spectrum Basic

`10 DIM a(5)20 LET a(2)=12830 PRINT a(2)`