Array length: Difference between revisions
Added OmniMark solution |
|||
(270 intermediate revisions by more than 100 users not shown) | |||
Line 1: | Line 1: | ||
{{task}} |
|||
[[Category:Simple]] |
[[Category:Simple]] |
||
{{task}} |
|||
;Task: |
;Task: |
||
Line 9: | Line 9: | ||
{{Template:Strings}} |
|||
;Related task: |
|||
* [[String length]] |
|||
<br><br> |
<br><br> |
||
=={{header|11l}}== |
|||
<syntaxhighlight lang="11l">print([‘apple’, ‘orange’].len)</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2 |
|||
</pre> |
|||
=={{header|360 Assembly}}== |
|||
Array length is computed at compilation time with the formula : (AEND-A)/L'A |
|||
<syntaxhighlight lang="360asm">* Array length 22/02/2017 |
|||
ARRAYLEN START |
|||
USING ARRAYLEN,12 |
|||
LR 12,15 end of prolog |
|||
LA 1,(AEND-A)/L'A hbound(a) |
|||
XDECO 1,PG+13 edit |
|||
XPRNT PG,L'PG print |
|||
BR 14 exit |
|||
A DC CL6'apple',CL6'orange' array |
|||
AEND DC 0C |
|||
PG DC CL25'Array length=' buffer |
|||
END ARRAYLEN</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Array length= 2 |
|||
</pre> |
|||
=={{header|6502 Assembly}}== |
|||
{{trans|360 Assembly}} |
|||
Array length is computed at compilation time with the formula: (Array_End-Array). Even though the labels Array and Array_End are both 16-bit values, if their difference fits into 8 bits the assembler will allow you to load it into a register. |
|||
<syntaxhighlight lang="6502asm">start: |
|||
LDA #(Array_End-Array) ;evaluates to 13 |
|||
RTS |
|||
Array: |
|||
byte "apple",0 |
|||
byte "orange",0 |
|||
Array_End:</syntaxhighlight> |
|||
=={{header|68000 Assembly}}== |
|||
Array length is computed at compilation time with the formula: (Array_End-Array). The "bit width" of this value is the bit width of the result, not the bit width of the inputs. In other words, even though code labels are 32-bit memory addresses, if their difference is 8 or 16-bit you can use a <code>.B</code> or <code>.W</code> instruction or directive on them without a compile-time error. |
|||
The biggest limitation to the (Array_End-Array) method is that it always measures in total bytes. So if your array elements are of a different type you'll have to adjust accordingly. For an array strings, you should instead construct an array of pointers to strings and divide the result of the difference by 4 to get the total number of "strings" in the array. |
|||
<syntaxhighlight lang="68000devpac">start: |
|||
MOVE.B #(MyArray_End-MyArray)/4 ;evaluates to 2 |
|||
RTS |
|||
Apple: |
|||
DC.B "apple",0 |
|||
even |
|||
Orange: |
|||
DC.B "orange",0 |
|||
even |
|||
MyArray: |
|||
DC.L Apple |
|||
DC.L Orange |
|||
MyArray_End:</syntaxhighlight> |
|||
=={{header|8th}}== |
=={{header|8th}}== |
||
< |
<syntaxhighlight lang="forth"> |
||
["apples", "oranges"] a:len . cr |
["apples", "oranges"] a:len . cr |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
2 |
2 |
||
</pre> |
</pre> |
||
=={{header|AArch64 Assembly}}== |
|||
{{works with|as|Raspberry Pi 3B version Buster 64 bits}} |
|||
<syntaxhighlight lang="aarch64 assembly"> |
|||
/* ARM assembly AARCH64 Raspberry PI 3B */ |
|||
/* program lenAreaString64.s */ |
|||
/*******************************************/ |
|||
/* Constantes file */ |
|||
/*******************************************/ |
|||
/* for this file see task include a file in language AArch64 assembly*/ |
|||
.include "../includeConstantesARM64.inc" |
|||
/*******************************************/ |
|||
/* Initialized data */ |
|||
/*******************************************/ |
|||
.data |
|||
szMessLenArea: .asciz "The length of area is : @ \n" |
|||
szCarriageReturn: .asciz "\n" |
|||
/* areas strings */ |
|||
szString1: .asciz "Apples" |
|||
szString2: .asciz "Oranges" |
|||
/* pointer items area */ |
|||
tablesPoi: |
|||
ptApples: .quad szString1 |
|||
ptOranges: .quad szString2 |
|||
ptVoid: .quad 0 |
|||
/*******************************************/ |
|||
/* UnInitialized data */ |
|||
/*******************************************/ |
|||
.bss |
|||
sZoneConv: .skip 30 |
|||
/*******************************************/ |
|||
/* code section */ |
|||
/*******************************************/ |
|||
.text |
|||
.global main |
|||
main: // entry of program |
|||
ldr x1,qAdrtablesPoi // begin pointer table |
|||
mov x0,0 // counter |
|||
1: // begin loop |
|||
ldr x2,[x1,x0,lsl 3] // read string pointer address item x0 (8 bytes by pointer) |
|||
cmp x2,0 // is null ? |
|||
cinc x0,x0,ne // no increment counter |
|||
bne 1b // and loop |
|||
ldr x1,qAdrsZoneConv // conversion decimal |
|||
bl conversion10S |
|||
ldr x0,qAdrszMessLenArea |
|||
ldr x1,qAdrsZoneConv |
|||
bl strInsertAtCharInc // insert result at @ character |
|||
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 call |
|||
qAdrtablesPoi: .quad tablesPoi |
|||
qAdrszMessLenArea: .quad szMessLenArea |
|||
qAdrsZoneConv: .quad sZoneConv |
|||
qAdrszCarriageReturn: .quad szCarriageReturn |
|||
/********************************************************/ |
|||
/* File Include fonctions */ |
|||
/********************************************************/ |
|||
/* for this file see task include a file in language AArch64 assembly */ |
|||
.include "../includeARM64.inc" |
|||
</syntaxhighlight> |
|||
=={{header|ABAP}}== |
|||
The concept of arrays does not exist in ABAP, instead internal tables are used. Since ABAP Version 7.40 they can be accessed with the common index notation. Note that the index starts at 1 and out of bound access raises an exception. The built-in function "lines" returns the number of records. |
|||
<syntaxhighlight lang="abap"> |
|||
report z_array_length. |
|||
data(internal_table) = value stringtab( ( `apple` ) ( `orange` ) ). |
|||
write: internal_table[ 1 ] , internal_table[ 2 ] , lines( internal_table ). |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
apple orange 2 |
|||
</pre> |
|||
=={{header|Ada}}== |
=={{header|Ada}}== |
||
<syntaxhighlight lang="ada"> |
|||
<lang Ada>with Ada.Text_IO; |
|||
with Ada.Text_IO; use Ada.Text_IO; |
|||
with System; |
|||
procedure Array_Length is |
procedure Array_Length is |
||
Fruits : constant array (Positive range <>) of access constant String |
|||
:= (new String'("orange"), |
|||
type Strings is array (Natural range <>) of AC; |
|||
new String'("apple")); |
|||
Arr: Strings := (new String'("orange"), new String'("apple")); |
|||
Memory_Size : constant Integer := Fruits'Size / System.Storage_Unit; |
|||
begin |
begin |
||
Put_Line ("Number of elements : " & Fruits'Length'Image); |
|||
for Str of Arr loop |
|||
Put_Line ("Array memory Size : " & Memory_Size'Image & " bytes" ); |
|||
Ada.Text_IO.Put(Integer'Image(Str.all'Length)); |
|||
Put_Line (" " & Integer'Image (Memory_Size * System.Storage_Unit / System.Word_Size) & " words" ); |
|||
end loop; |
|||
end Array_Length;</syntaxhighlight> |
|||
Ada.Text_IO.Put_Line(" Array Size:" & Integer'Image(Arr'Length)); |
|||
end Array_Length;</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
|||
<pre> 6 5 Array Size: 2</pre> |
|||
Number of elements : 2 |
|||
Array memory Size : 32 bytes |
|||
4 words |
|||
</pre> |
|||
=={{header|ALGOL 68}}== |
=={{header|ALGOL 68}}== |
||
< |
<syntaxhighlight lang="algol68"># UPB returns the upper bound of an array, LWB the lower bound # |
||
[]STRING fruits = ( "apple", "orange" ); |
[]STRING fruits = ( "apple", "orange" ); |
||
print( ( ( UPB fruits - LWB fruits ) + 1, newline ) ) # prints 2 #</ |
print( ( ( UPB fruits - LWB fruits ) + 1, newline ) ) # prints 2 #</syntaxhighlight> |
||
=={{header|AntLang}}== |
=={{header|AntLang}}== |
||
< |
<syntaxhighlight lang="antlang">array: seq["apple"; "orange"] |
||
length[array] |
length[array] |
||
/Works as a one liner: length[seq["apple"; "orange"]]</ |
/Works as a one liner: length[seq["apple"; "orange"]]</syntaxhighlight> |
||
=={{header|Apex}}== |
|||
<syntaxhighlight lang="apex">System.debug(new String[] { 'apple', 'banana' }.size()); // Prints 2</syntaxhighlight> |
|||
=={{header|APL}}== |
=={{header|APL}}== |
||
<lang |
<syntaxhighlight lang="apl">⍴'apple' 'orange'</syntaxhighlight> |
||
Output: |
Output: |
||
<pre>2</pre> |
<pre>2</pre> |
||
=={{header|Apex}}== |
|||
<lang apex>System.debug(new String[] { 'apple', 'banana' }.size()); // Prints 2</lang> |
|||
=={{header|AppleScript}}== |
=={{header|AppleScript}}== |
||
<syntaxhighlight lang="applescript"> |
|||
<lang AppleScript> |
|||
set theList to {"apple", "orange"} |
set theList to {"apple", "orange"} |
||
count theList |
count theList |
||
Line 68: | Line 218: | ||
-- or |
-- or |
||
number of items in theList |
number of items in theList |
||
</syntaxhighlight> |
|||
</lang> |
|||
''Strictly speaking, 'items in' can be omitted from the last example, since 'number of' does essentially the same as 'length of'. The additional stage of extracting theList's 'items' is inefficient.'' |
|||
{{out}} |
{{out}} |
||
<pre>2</pre> |
<pre>2</pre> |
||
Line 78: | Line 229: | ||
<pre>fold (λx n -> 1 + n) 0</pre> |
<pre>fold (λx n -> 1 + n) 0</pre> |
||
< |
<syntaxhighlight lang="applescript">on run |
||
set xs to ["alpha", "beta", "gamma", "delta", "epsilon", ¬ |
set xs to ["alpha", "beta", "gamma", "delta", "epsilon", ¬ |
||
Line 119: | Line 270: | ||
end repeat |
end repeat |
||
end fold |
end fold |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{Out}} |
{{Out}} |
||
<pre>{12, 12, "mu", "mu"}</pre> |
<pre>{12, 12, "mu", "mu"}</pre> |
||
=={{header|ARM Assembly}}== |
|||
{{works with|as|Raspberry Pi}} |
|||
<syntaxhighlight lang="arm assembly"> |
|||
/* ARM assembly Raspberry PI */ |
|||
/* program lenAreaString.s */ |
|||
/* Constantes */ |
|||
.equ STDOUT, 1 @ Linux output console |
|||
.equ EXIT, 1 @ Linux syscall |
|||
.equ WRITE, 4 @ Linux syscall |
|||
/* Initialized data */ |
|||
.data |
|||
szMessLenArea: .ascii "The length of area is : " |
|||
sZoneconv: .fill 12,1,' ' |
|||
szCarriageReturn: .asciz "\n" |
|||
/* areas strings */ |
|||
szString1: .asciz "Apples" |
|||
szString2: .asciz "Oranges" |
|||
/* pointer items area */ |
|||
tablesPoi: |
|||
ptApples: .int szString1 |
|||
ptOranges: .int szString2 |
|||
ptVoid: .int 0 |
|||
/* UnInitialized data */ |
|||
.bss |
|||
/* code section */ |
|||
.text |
|||
.global main |
|||
main: /* entry of program */ |
|||
push {fp,lr} /* saves 2 registers */ |
|||
ldr r1,iAdrtablesPoi @ begin pointer table |
|||
mov r0,#0 @ counter |
|||
1: @ begin loop |
|||
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 |
|||
ldr r1,iAdrsZoneconv @ conversion decimal |
|||
bl conversion10S |
|||
ldr r0,iAdrszMessLenArea |
|||
bl affichageMess |
|||
2: |
|||
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 call |
|||
iAdrtablesPoi: .int tablesPoi |
|||
iAdrszMessLenArea: .int szMessLenArea |
|||
iAdrsZoneconv: .int sZoneconv |
|||
iAdrszCarriageReturn: .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 |
|||
</syntaxhighlight> |
|||
=={{header|Arturo}}== |
|||
<syntaxhighlight lang="rebol">fruit: ["apple" "orange"] |
|||
print ["array length =" size fruit]</syntaxhighlight> |
|||
{{out}} |
|||
<pre>array length = 2</pre> |
|||
=={{header|ATS}}== |
|||
<syntaxhighlight lang="ats"> |
|||
#include |
|||
"share/atspre_staload.hats" |
|||
#include |
|||
"share/atspre_staload_libats_ML.hats" |
|||
val A0 = |
|||
array0_tuple<string> |
|||
( "apple", "orange" ) |
|||
val () = |
|||
println!("length(A0) = ", length(A0)) |
|||
implement main0((*void*)) = ((*void*)) |
|||
</syntaxhighlight> |
|||
=={{header|AutoHotkey}}== |
=={{header|AutoHotkey}}== |
||
< |
<syntaxhighlight lang="autohotkey">MsgBox % ["apple","orange"].MaxIndex()</syntaxhighlight> |
||
{{Out}}<pre>2</pre> |
{{Out}}<pre>2</pre> |
||
=={{header|AutoIt}}== |
=={{header|AutoIt}}== |
||
< |
<syntaxhighlight lang="autoit">Opt('MustDeclareVars',1) ; 1 = Variables must be pre-declared. |
||
Local $aArray[2] = ["Apple", "Orange"] |
Local $aArray[2] = ["Apple", "Orange"] |
||
Line 139: | Line 456: | ||
ConsoleWrite("aArray[" & $i & "] = '" & $aArray[$i] & "'" & @CRLF) |
ConsoleWrite("aArray[" & $i & "] = '" & $aArray[$i] & "'" & @CRLF) |
||
Next |
Next |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{Out}} |
{{Out}} |
||
<pre>Elements in array: 2 |
<pre>Elements in array: 2 |
||
aArray[0] = 'Apple' |
aArray[0] = 'Apple' |
||
aArray[1] = 'Orange'</pre> |
aArray[1] = 'Orange'</pre> |
||
=={{header|Avail}}== |
|||
Using Avail's tuples and the `|_|` method: |
|||
<syntaxhighlight lang="avail">|<"Apple", "Orange">|</syntaxhighlight> |
|||
=={{header|AWK}}== |
=={{header|AWK}}== |
||
Line 152: | Line 475: | ||
Another method to count the elements of the array is by using a variant of for(). |
Another method to count the elements of the array is by using a variant of for(). |
||
< |
<syntaxhighlight lang="awk"># usage: awk -f arraylen.awk |
||
# |
# |
||
function countElements(array) { |
function countElements(array) { |
||
Line 166: | Line 489: | ||
print "String length:", array[1], length(array[1]) |
print "String length:", array[1], length(array[1]) |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 173: | Line 496: | ||
String length: apple 5 |
String length: apple 5 |
||
</pre> |
</pre> |
||
=={{header|BaCon}}== |
|||
BaCon knows three types of arrays, the UBOUND function can query all. |
|||
<syntaxhighlight lang="bacon">' Static arrays |
|||
DECLARE fruit$[] = { "apple", "orange" } |
|||
PRINT UBOUND(fruit$) |
|||
' Dynamic arrays |
|||
DECLARE vegetable$ ARRAY 2 |
|||
vegetable$[0] = "cabbage" |
|||
vegetable$[1] = "spinach" |
|||
PRINT UBOUND(vegetable$) |
|||
' Associative arrays |
|||
DECLARE meat$ ASSOC STRING |
|||
meat$("first") = "chicken" |
|||
meat$("second") = "pork" |
|||
PRINT UBOUND(meat$)</syntaxhighlight> |
|||
=={{header|Bash}}== |
|||
<syntaxhighlight lang="bash"> |
|||
fruit=("apple" "orange" "lemon") |
|||
echo "${#fruit[@]}"</syntaxhighlight> |
|||
=={{header|BASIC}}== |
=={{header|BASIC}}== |
||
< |
<syntaxhighlight lang="basic">DIM X$(1 TO 2) |
||
X$(1) = "apple" |
X$(1) = "apple" |
||
X$(2) = "orange" |
X$(2) = "orange" |
||
PRINT UBOUND(X$) - LBOUND(X$) + 1</ |
PRINT UBOUND(X$) - LBOUND(X$) + 1</syntaxhighlight> |
||
==={{header|Applesoft BASIC}}=== |
|||
<syntaxhighlight lang="basic">10 DIM A$(2) |
|||
20 A$(1) = "ORANGE" |
|||
30 A$(2) = "APPLE" |
|||
40 N$ = "A$": GOSUB 70: PRINT L$ |
|||
60 PRINT |
|||
61 DIM A%(19,63,0),A3(4,5) |
|||
62 N$ = "A%": GOSUB 70: PRINT L$ |
|||
63 N$ = "A3": GOSUB 70: PRINT L$ |
|||
64 N$ = "COMMODORE" |
|||
65 GOSUB 70: PRINT L$: END |
|||
70 L$ = "":N0 = 0:N1 = 0 |
|||
71 N0$ = LEFT$ (N$,1) |
|||
72 N1$ = MID$ (N$,2,2) |
|||
73 N1 = RIGHT$ (N$,1) = "$" |
|||
74 N0 = RIGHT$ (N$,1) = "%" |
|||
75 IF N0 THEN N1 = 1 |
|||
76 I = LEN (N1$) - N1 |
|||
77 N1$ = MID$ (N1$,1,I) |
|||
78 A = ASC (N1$ + CHR$ (0)) |
|||
79 N1 = 128 * N1 + A |
|||
80 N0 = 128 * N0 + ASC (N0$) |
|||
90 DEF FN P(A) = PEEK (A) + PEEK (A + 1) * 256 |
|||
100 I = FN P(109):A = FN P(107) |
|||
110 FOR A = A TO I STEP 0 |
|||
128 IF PEEK (A) < > N0 OR PEEK (A + 1) < > N1 THEN A = A + FN P(A + 2): NEXT A: PRINT "ARRAY "N$" NOT FOUND": STOP |
|||
130 N0 = A + 4 |
|||
140 N1 = N0 + FN P(N0) * 2 |
|||
150 N0 = N0 + 2 |
|||
160 FOR I = N1 TO N0 STEP - 2 |
|||
170 L$ = L$ + STR$ ( FN P(I)) |
|||
180 L$ = L$ + " ": NEXT I |
|||
190 RETURN</syntaxhighlight> |
|||
==={{header|BASIC256}}=== |
|||
<syntaxhighlight lang="basic256"> |
|||
fruta$ = {"apple", "orange", "pear"} |
|||
print length(fruta$) |
|||
print fruta$[?] |
|||
print fruta$[1] |
|||
end |
|||
</syntaxhighlight> |
|||
<pre> |
|||
3 |
|||
3 |
|||
orange |
|||
</pre> |
|||
==={{header|Chipmunk Basic}}=== |
|||
{{works with|Chipmunk Basic|3.6.4}} |
|||
Unless modified with OPTION BASE 1 or MAT ORIGIN 1, the lower limit of an array is 1. |
|||
<syntaxhighlight lang="qbasic">10 dim fruta$(2) |
|||
20 read fruta$(0),fruta$(1),fruta$(2) |
|||
30 data "apple","orange","lemon" |
|||
40 print "The length of the array 'fruit$' is ";ubound(fruta$)+1 |
|||
50 end</syntaxhighlight> |
|||
==={{header|Commodore BASIC}}=== |
|||
Commodore BASIC has no way within the language to query an array for its length, but you can dive into the implementation to get that information. On a C-64 in particular, this works: |
|||
{{works with|Commodore BASIC|2.0 on C-64}} |
|||
<syntaxhighlight lang="basic">10 DIM A$(1):REM 1=LAST -> ROOM FOR 2 |
|||
20 A$(0) = "ORANGE" |
|||
30 A$(1) = "APPLE" |
|||
40 AT=0:N$="":T=0:L=0:REM DECLARE ALL VARS BEFORE PEEKING |
|||
50 AT=PEEK(47)+256*PEEK(48):REM START OF ARRAYS IN MEMORY |
|||
60 N$=CHR$(PEEK(AT)AND127)+CHR$(PEEK(AT+1)AND127):REM NAME |
|||
70 T=(PEEK(AT) AND 128)*2+(PEEK(AT+1)AND128):REM TYPE |
|||
80 IF T=384 THEN N$=N$+"%": REM INTEGER |
|||
90 IF T=128 THEN N$=N$+"$": REM STRING |
|||
100 L=PEEK(AT+6): REM FIRST INDEX SIZE |
|||
110 PRINT N$" HAS"L"ELEMENTS."</syntaxhighlight> |
|||
{{Out}} |
|||
<pre>A$ HAS 2 ELEMENTS.</pre> |
|||
==={{header|IS-BASIC}}=== |
|||
<syntaxhighlight lang="is-basic">100 STRING X$(1 TO 2) |
|||
110 LET X$(1)="apple":LET X$(2)="orange" |
|||
120 PRINT "The length of the array 'X$' is";SIZE(X$)</syntaxhighlight> |
|||
==={{header|True BASIC}}=== |
|||
<syntaxhighlight lang="qbasic">DIM fruta$(2) |
|||
READ fruta$(1), fruta$(2) |
|||
DATA "apple", "orange" |
|||
LET tamano = UBound(fruta$) - LBound(fruta$) + 1 |
|||
PRINT "La longitud del array fruta$ es" ; tamano |
|||
END</syntaxhighlight> |
|||
{{out}} |
|||
<pre> La longitud del array fruta$ es 2 </pre> |
|||
True BASIC's arrays are not fixed in length and, although True BASIC is a compiled-language, the number of elements can be changed during runtime using such functions as the MAT REDIM (matrix re-dimension) function. Although the starting index of 1 is in implicit, it can be changed by setting the lower and upper bounds (eg. fruit(0 to 3)) when declaring the array. Also, the example below uses the MAT READ function to read in the data elements into the array without having to explicitly list each variable-array index. The example also uses the SIZE function vs the bounds method to determine the length of the array. Finally, in this example the SIZE function was not assigned to a separate variable and instead is used within the PRINT function itself. |
|||
<syntaxhighlight lang="qbasic">DIM fruit$(2) |
|||
MAT READ fruit$ |
|||
DATA "apple", "orange" |
|||
PRINT "The length of the array 'fruit$' is "; SIZE(fruit$) |
|||
END</syntaxhighlight> |
|||
{{out}} |
|||
<pre> The length of the array 'fruit$' is 2 </pre> |
|||
==={{header|XBasic}}=== |
|||
{{works with|Windows XBasic}} |
|||
<syntaxhighlight lang="qbasic">PROGRAM "Array length" |
|||
VERSION "0.0000" |
|||
DECLARE FUNCTION Entry () |
|||
FUNCTION Entry () |
|||
DIM F$[2] |
|||
F$[0] = "apple" |
|||
F$[1] = "orange" |
|||
F$[2] = "pear" |
|||
PRINT "The length of the fruit array is "; UBOUND(F$[]) |
|||
PRINT F$[1] |
|||
END FUNCTION |
|||
END PROGRAM</syntaxhighlight> |
|||
{{out}} |
|||
<pre>The length of the fruit array is 2 |
|||
orange</pre> |
|||
=={{header|Batch File}}== |
|||
While batch files don't support arrays in the traditional sense, sets of variables forming somewhat of a pseudo-array are extremely useful. They are usually in the form of <code>%name{number}%</code>. The below code gives an example of how to create an array from a list stored in a variable, and how to acquire the amount of entries in the array. |
|||
<syntaxhighlight lang="dos"> |
|||
@echo off |
|||
:_main |
|||
setlocal enabledelayedexpansion |
|||
:: This block of code is putting a list delimitered by spaces into an pseudo-array |
|||
:: In practice, this could be its own function _createArray however for the demonstration, it is built in |
|||
set colour_list=red yellow blue orange green |
|||
set array_entry=0 |
|||
for %%i in (%colour_list%) do ( |
|||
set /a array_entry+=1 |
|||
set colours[!array_entry!]=%%i |
|||
) |
|||
call:_arrayLength colours |
|||
echo _arrayLength returned %errorlevel% |
|||
pause>nul |
|||
exit /b |
|||
:: _arrayLength returns the length of the array parsed to it in the errorcode |
|||
:_arrayLength |
|||
setlocal enabledelayedexpansion |
|||
:loop |
|||
set /a arrayentry=%arraylength%+1 |
|||
if "!%1[%arrayentry%]!"=="" exit /b %arraylength% |
|||
set /a arraylength+=1 |
|||
goto loop |
|||
</syntaxhighlight> |
|||
{{in}} |
|||
<pre> |
|||
red yellow blue orange green |
|||
</pre> |
|||
{{out}} |
|||
<pre> |
|||
_arrayLength returned 5 |
|||
</pre> |
|||
=={{header|BBC BASIC}}== |
|||
{{works with|BBC BASIC for Windows}} |
|||
<syntaxhighlight lang="bbcbasic"> DIM array$(1) |
|||
array$() = "apple", "orange" |
|||
PRINT "Number of elements in array = "; DIM(array$(), 1) + 1 |
|||
PRINT "Number of bytes in all elements combined = "; SUMLEN(array$()) |
|||
END</syntaxhighlight> |
|||
{{Out}} |
|||
<pre>Number of elements in array = 2 |
|||
Number of bytes in all elements combined = 11</pre> |
|||
=={{header|Beef}}== |
|||
<syntaxhighlight lang="csharp">using System; |
|||
namespace ArrayLength |
|||
{ |
|||
class Program |
|||
{ |
|||
public static void Main() |
|||
{ |
|||
var array = new String[]("apple", "orange"); |
|||
Console.WriteLine(array.Count); |
|||
delete(array); |
|||
} |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|Brat}}== |
=={{header|Brat}}== |
||
< |
<syntaxhighlight lang="brat"> |
||
p ["apple", "orange"].length |
p ["apple", "orange"].length |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header| |
=={{header|Binary Lambda Calculus}}== |
||
BLC has no arrays, so here's a function to compute the length of a given list (as a church numeral) instead, corresponding to https://github.com/tromp/AIT/blob/master/lists/length.lam : |
|||
<pre>010001101000000101100000000000011100101010111111110111111101111011010000010</pre> |
|||
=={{header|BQN}}== |
|||
<code>≠</code> gives the length of an array in BQN. |
|||
<syntaxhighlight lang="bqn">≠ 1‿"a"‿+</syntaxhighlight> |
|||
<syntaxhighlight lang="bqn">3</syntaxhighlight> |
|||
[https://mlochbaum.github.io/BQN/try.html#code=4omgIDHigL8iYSLigL8r Try It!] |
|||
=={{header|C}}== |
|||
===A commonly used solution=== |
|||
C features two kinds of arrays: static (compile-time, fixed size) and dynamic (allocated at runtime). |
C features two kinds of arrays: static (compile-time, fixed size) and dynamic (allocated at runtime). |
||
Line 193: | Line 755: | ||
For static arrays: |
For static arrays: |
||
<syntaxhighlight lang="c"> |
|||
<lang c> |
|||
#include <stdio.h> |
#include <stdio.h> |
||
Line 215: | Line 777: | ||
return 0; |
return 0; |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
A C pre-processor macro may be created for ease of use: |
A C pre-processor macro may be created for ease of use: |
||
<syntaxhighlight lang="c"> |
|||
<lang c> |
|||
#define ARRAY_LENGTH(A) (sizeof(A) / sizeof(A[0])) |
#define ARRAY_LENGTH(A) (sizeof(A) / sizeof(A[0])) |
||
</syntaxhighlight> |
|||
</lang> |
|||
Note that these arrays become pointers when passed as a parameter to a function. |
Note that these arrays become pointers when passed as a parameter to a function. |
||
Thus, the length of an array parameter may not be required directly - a dedicated length parameter would be required. |
Thus, the length of an array parameter may not be required directly - a dedicated length parameter would be required. |
||
== |
===Safe solution=== |
||
<p> |
|||
The C language uses arrays of a declared size (including variable length arrays, |
|||
i.e. VLA) and dynamically allocated memory blocks. While they are mostly the same, |
|||
it is important that the sizeof operator, which returns a number of bytes, |
|||
behaves quite differently for arrays and for memory pointers. |
|||
</p><p> |
|||
The problem is that arrays are passed to functions (procedures) via pointers. |
|||
Even if we define a global variable as an array, after using it as a function |
|||
argument the appropriate parameter will "forget" what size the array is. |
|||
</p><p> |
|||
Therefore, an object-oriented technique is used in the solution below. (This is possible even with standard C, i.e. C without ++.) Block of memory in which is stored the array is wrapped in structure and thus the size of the array can be easily stored. It is very convenient. Having defined such "classes" as StringArray, their use is easy and hassle-free. Nevertheless, the C language is not designed for OOP, and therefore C ++ is simply better for these kinds of applications. |
|||
</p> |
|||
====Solution==== |
|||
<syntaxhighlight lang="c">#define _CRT_SECURE_NO_WARNINGS // turn off panic warnings |
|||
#define _CRT_NONSTDC_NO_WARNINGS // enable old-gold POSIX names in MSVS |
|||
#include <stdarg.h> |
|||
C++ follows the same rules as C regarding static and dynamic arrays. |
|||
#include <stdio.h> |
|||
#include <stdlib.h> |
|||
#include <string.h> |
|||
#include <assert.h> |
|||
However, C++ has an additional std::array type (amongst other collections) in its standard library: |
|||
struct StringArray |
|||
<lang cpp> |
|||
{ |
|||
#include <array> |
|||
size_t sizeOfArray; |
|||
#include <iostream> |
|||
size_t numberOfElements; |
|||
#include <string> |
|||
char** elements; |
|||
}; |
|||
typedef struct StringArray* StringArray; |
|||
StringArray StringArray_new(size_t size) |
|||
int main() |
|||
{ |
{ |
||
StringArray this = calloc(1, sizeof(struct StringArray)); |
|||
std::array<std::string, 2> fruit { "apples", "oranges" }; |
|||
if (this) |
|||
{ |
|||
this->elements = calloc(size, sizeof(int)); |
|||
if (this->elements) |
|||
this->sizeOfArray = size; |
|||
else |
|||
{ |
|||
free(this); |
|||
this = NULL; |
|||
} |
|||
} |
|||
return this; |
|||
} |
} |
||
</lang> |
|||
void StringArray_delete(StringArray* ptr_to_this) |
|||
Note that char* or const char* could have been used instead of std::string. |
|||
{ |
|||
assert(ptr_to_this != NULL); |
|||
StringArray this = (*ptr_to_this); |
|||
if (this) |
|||
{ |
|||
for (size_t i = 0; i < this->sizeOfArray; i++) |
|||
free(this->elements[i]); |
|||
free(this->elements); |
|||
free(this); |
|||
this = NULL; |
|||
} |
|||
} |
|||
void StringArray_add(StringArray this, ...) |
|||
In addition to the std::array type, the C++ standard library also provides dynamically-sized containers to hold arbitrary objects. |
|||
{ |
|||
These all support similar interfaces, though their implementations have different performance characteristics. |
|||
char* s; |
|||
<lang cpp> |
|||
va_list args; |
|||
std::vector<std::string> fruitV({ "apples", "oranges" }); |
|||
va_start(args, this); |
|||
std::list<std::string> fruitL({ "apples", "oranges" }); |
|||
while (this->numberOfElements < this->sizeOfArray && (s = va_arg(args, char*))) |
|||
std::deque<std::string> fruitD({ "apples", "oranges" }); |
|||
this->elements[this->numberOfElements++] = strdup(s); |
|||
std::cout << fruitV.size() << fruitL.size() << fruitD.size() << std::endl; |
|||
va_end(args); |
|||
</lang> |
|||
} |
|||
Of these, vector is probably the most widely used. |
|||
int main(int argc, char* argv[]) |
|||
{ |
|||
StringArray a = StringArray_new(10); |
|||
StringArray_add(a, "apple", "orange", NULL); |
|||
printf( |
|||
"There are %d elements in an array with a capacity of %d elements:\n\n", |
|||
a->numberOfElements, a->sizeOfArray); |
|||
for (size_t i = 0; i < a->numberOfElements; i++) |
|||
printf(" the element %d is the string \"%s\"\n", i, a->elements[i]); |
|||
StringArray_delete(&a); |
|||
return EXIT_SUCCESS; |
|||
}</syntaxhighlight> |
|||
{{output}} |
|||
<pre>There are 2 elements in an array with a capacity of 10 elements: |
|||
the element 0 is the string "apple" |
|||
the element 1 is the string "orange"</pre> |
|||
====An example why sizeof(A)/sizeof(E) may be a bad idea in C==== |
|||
<syntaxhighlight lang="c">#define _CRT_SECURE_NO_WARNINGS // turn off panic warnings |
|||
#define _CRT_NONSTDC_NO_WARNINGS // enable old-gold POSIX names in MSVS |
|||
#include <stdio.h> |
|||
#include <stdlib.h> |
|||
#include <time.h> |
|||
#define N 10 |
|||
// Fixed size global arrays |
|||
static const int scGlobal[N]; |
|||
const int cGlobal[N]; |
|||
static int sGlobal[N]; |
|||
int Global[N]; |
|||
#define TEST(A, N) \ |
|||
do { \ |
|||
puts(""); \ |
|||
printf("directly called: sizeof(%8s) = %2d, length = %2d, %s\n",\ |
|||
#A, \ |
|||
sizeof(A), \ |
|||
sizeof(A) / sizeof(int), \ |
|||
sizeof(A) / sizeof(int) == N ? "pass" : "fail"); \ |
|||
\ |
|||
test1(#A, A, N); \ |
|||
test2(#A, A, N); \ |
|||
test3(#A, A, N); \ |
|||
} while (0); |
|||
void test1(char* name, int* A, int n) |
|||
{ |
|||
printf("as parameter int* A: sizeof(%8s) = %2d, length = %2d, %s\n", |
|||
name, |
|||
sizeof(A), |
|||
sizeof(A) / sizeof(int), |
|||
sizeof(A) / sizeof(int) == n ? "pass" : "fail"); |
|||
} |
|||
void test2(char* name, int A[], int n) |
|||
{ |
|||
printf("as parameter int A[]: sizeof(%8s) = %2d, length = %2d, %s\n", |
|||
name, |
|||
sizeof(A), |
|||
sizeof(A) / sizeof(int), |
|||
sizeof(A) / sizeof(int) == n ? "pass" : "fail"); |
|||
} |
|||
void test3(char* name, int A[10], int n) |
|||
{ |
|||
printf("as parameter int A[10]: sizeof(%8s) = %2d, length = %2d, %s\n", |
|||
name, |
|||
sizeof(A), |
|||
sizeof(A) / sizeof(int), |
|||
sizeof(A) / sizeof(int) == n ? "pass" : "fail"); |
|||
} |
|||
int main(int argc, char argv[]) |
|||
{ |
|||
// Fixed size local arrays (defined inside curly braces block) |
|||
static const int scLocal[N]; |
|||
const int cLocal[N]; |
|||
static int sLocal[N]; |
|||
auto int aLocal[N]; |
|||
int Local[N]; |
|||
// Fixed size VLA arrays can/should be used instead dynamically alocated |
|||
// blocks. VLA has not implemented in Microsoft Visual Studio C. |
|||
srand(time(NULL)); |
|||
int n = N + rand() % 2; // the value of n is unknow in the compile time? |
|||
#ifndef _MSC_VER |
|||
int vlaLocal[n]; |
|||
#endif |
|||
// Memory blocks as ersatz arrays. This is not all possible ways to allocate |
|||
// memory. There are other functions, like LocalAlloc, HeapAlloc, sbreak... |
|||
// Don't use alloca in any serious program - this function is really bad |
|||
// choice - it can corrupt the program stack and generate a stack overflow. |
|||
int* mBlock = (int*)malloc(n * sizeof(int)); |
|||
int* cBlock = (int*)calloc(n, sizeof(int)); |
|||
int* aBlock = (int*)_alloca(n * sizeof(int)); // don't use in your programs! |
|||
TEST(scGlobal, N); |
|||
TEST(cGlobal, N); |
|||
TEST(sGlobal, N); |
|||
TEST(Global, N); |
|||
TEST(scLocal, N); |
|||
TEST(cLocal, N); |
|||
TEST(sLocal, N); |
|||
TEST(aLocal, N); |
|||
TEST(Local, N); |
|||
#ifndef _MSC_VER |
|||
TEST(vlaLocal, n); |
|||
#endif |
|||
TEST(mBlock, N); |
|||
TEST(cBlock, N); |
|||
TEST(aBlock, N); |
|||
free(mBlock, N); |
|||
free(cBlock, N); |
|||
// free must not be called on aBlock |
|||
return 0; |
|||
}</syntaxhighlight> |
|||
<p> |
|||
As we can see the ''sizeof(ArrayType)/sizeof(ElementType)'' approach mostly fail. |
|||
</p> |
|||
{{output}} |
|||
<pre>directly called: sizeof(scGlobal) = 40, length = 10, pass |
|||
as parameter int* A: sizeof(scGlobal) = 4, length = 1, fail |
|||
as parameter int A[]: sizeof(scGlobal) = 4, length = 1, fail |
|||
as parameter int A[10]: sizeof(scGlobal) = 4, length = 1, fail |
|||
directly called: sizeof( cGlobal) = 40, length = 10, pass |
|||
as parameter int* A: sizeof( cGlobal) = 4, length = 1, fail |
|||
as parameter int A[]: sizeof( cGlobal) = 4, length = 1, fail |
|||
as parameter int A[10]: sizeof( cGlobal) = 4, length = 1, fail |
|||
directly called: sizeof( sGlobal) = 40, length = 10, pass |
|||
as parameter int* A: sizeof( sGlobal) = 4, length = 1, fail |
|||
as parameter int A[]: sizeof( sGlobal) = 4, length = 1, fail |
|||
as parameter int A[10]: sizeof( sGlobal) = 4, length = 1, fail |
|||
directly called: sizeof( Global) = 40, length = 10, pass |
|||
as parameter int* A: sizeof( Global) = 4, length = 1, fail |
|||
as parameter int A[]: sizeof( Global) = 4, length = 1, fail |
|||
as parameter int A[10]: sizeof( Global) = 4, length = 1, fail |
|||
directly called: sizeof( scLocal) = 40, length = 10, pass |
|||
as parameter int* A: sizeof( scLocal) = 4, length = 1, fail |
|||
as parameter int A[]: sizeof( scLocal) = 4, length = 1, fail |
|||
as parameter int A[10]: sizeof( scLocal) = 4, length = 1, fail |
|||
directly called: sizeof( cLocal) = 40, length = 10, pass |
|||
as parameter int* A: sizeof( cLocal) = 4, length = 1, fail |
|||
as parameter int A[]: sizeof( cLocal) = 4, length = 1, fail |
|||
as parameter int A[10]: sizeof( cLocal) = 4, length = 1, fail |
|||
directly called: sizeof( sLocal) = 40, length = 10, pass |
|||
as parameter int* A: sizeof( sLocal) = 4, length = 1, fail |
|||
as parameter int A[]: sizeof( sLocal) = 4, length = 1, fail |
|||
as parameter int A[10]: sizeof( sLocal) = 4, length = 1, fail |
|||
directly called: sizeof( aLocal) = 40, length = 10, pass |
|||
as parameter int* A: sizeof( aLocal) = 4, length = 1, fail |
|||
as parameter int A[]: sizeof( aLocal) = 4, length = 1, fail |
|||
as parameter int A[10]: sizeof( aLocal) = 4, length = 1, fail |
|||
directly called: sizeof( Local) = 40, length = 10, pass |
|||
as parameter int* A: sizeof( Local) = 4, length = 1, fail |
|||
as parameter int A[]: sizeof( Local) = 4, length = 1, fail |
|||
as parameter int A[10]: sizeof( Local) = 4, length = 1, fail |
|||
directly called: sizeof( mBlock) = 4, length = 1, fail |
|||
as parameter int* A: sizeof( mBlock) = 4, length = 1, fail |
|||
as parameter int A[]: sizeof( mBlock) = 4, length = 1, fail |
|||
as parameter int A[10]: sizeof( mBlock) = 4, length = 1, fail |
|||
directly called: sizeof( cBlock) = 4, length = 1, fail |
|||
as parameter int* A: sizeof( cBlock) = 4, length = 1, fail |
|||
as parameter int A[]: sizeof( cBlock) = 4, length = 1, fail |
|||
as parameter int A[10]: sizeof( cBlock) = 4, length = 1, fail |
|||
directly called: sizeof( aBlock) = 4, length = 1, fail |
|||
as parameter int* A: sizeof( aBlock) = 4, length = 1, fail |
|||
as parameter int A[]: sizeof( aBlock) = 4, length = 1, fail |
|||
as parameter int A[10]: sizeof( aBlock) = 4, length = 1, fail</pre> |
|||
=={{header|C sharp|C#}}== |
=={{header|C sharp|C#}}== |
||
< |
<syntaxhighlight lang="csharp"> |
||
using System; |
using System; |
||
Line 271: | Line 1,074: | ||
} |
} |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
Note that any of the following array declarations could be used: |
Note that any of the following array declarations could be used: |
||
< |
<syntaxhighlight lang="csharp"> |
||
var fruit = new[] { "apple", "orange" }; |
var fruit = new[] { "apple", "orange" }; |
||
var fruit = new string[] { "apple", "orange" }; |
var fruit = new string[] { "apple", "orange" }; |
||
Line 281: | Line 1,084: | ||
string[] fruit = new string[] { "apple", "orange" }; |
string[] fruit = new string[] { "apple", "orange" }; |
||
string[] fruit = { "apple", "orange" }; |
string[] fruit = { "apple", "orange" }; |
||
</syntaxhighlight> |
|||
</lang> |
|||
A shorter variant could also have been used: |
A shorter variant could also have been used: |
||
< |
<syntaxhighlight lang="csharp"> |
||
using static System.Console; |
using static System.Console; |
||
Line 295: | Line 1,098: | ||
} |
} |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|C++}}== |
|||
C++ follows the same rules as C regarding static and dynamic arrays. |
|||
However, C++ has an additional <code>std::array</code> type (amongst other collections) in its standard library: |
|||
<syntaxhighlight lang="cpp">#include <array> |
|||
#include <iostream> |
|||
#include <string> |
|||
int main() |
|||
{ |
|||
std::array<std::string, 2> fruit { "apples", "oranges" }; |
|||
std::cout << fruit.size(); |
|||
return 0; |
|||
}</syntaxhighlight> |
|||
Note that <code>char*</code> or <code>const char*</code> could have been used instead of <code>std::string</code>. |
|||
In addition to the <code>std::array</code> type, the C++ standard library also provides dynamically-sized containers to hold arbitrary objects. |
|||
These all support similar interfaces, though their implementations have different performance characteristics. |
|||
<syntaxhighlight lang="cpp"> std::vector<std::string> fruitV({ "apples", "oranges" }); |
|||
std::list<std::string> fruitL({ "apples", "oranges" }); |
|||
std::deque<std::string> fruitD({ "apples", "oranges" }); |
|||
std::cout << fruitV.size() << fruitL.size() << fruitD.size() << std::endl;</syntaxhighlight> |
|||
Of these, vector is probably the most widely used. |
|||
=={{header|Ceylon}}== |
=={{header|Ceylon}}== |
||
< |
<syntaxhighlight lang="ceylon">shared void run() { |
||
value array = ["apple", "orange"]; |
value array = ["apple", "orange"]; |
||
print(array.size); |
print(array.size); |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Clipper/XBase++}}== |
=={{header|Clipper/XBase++}}== |
||
<syntaxhighlight lang="clipper/xbase++">/* |
|||
<lang Clipper/XBase++>/* |
|||
* nizchka: March - 2016 |
* nizchka: March - 2016 |
||
* This is a Clipper/XBase++ of RosettaCode Array_Length |
* This is a Clipper/XBase++ of RosettaCode Array_Length |
||
Line 315: | Line 1,146: | ||
? LEN(FRUIT) |
? LEN(FRUIT) |
||
RETURN |
RETURN |
||
</syntaxhighlight> |
|||
</lang> |
|||
Outputs:<pre>2</pre> |
Outputs:<pre>2</pre> |
||
[[User:nizchka|nizchka]] 23:27, 16 March 2016 (UTC) |
[[User:nizchka|nizchka]] 23:27, 16 March 2016 (UTC) |
||
Line 321: | Line 1,152: | ||
=={{header|Clojure}}== |
=={{header|Clojure}}== |
||
< |
<syntaxhighlight lang="clojure">; using count: |
||
(count ["apple" "orange"]) |
(count ["apple" "orange"]) |
||
; OR alength if using Java arrays: |
; OR alength if using Java arrays: |
||
(alength (into-array ["apple" "orange"]))</ |
(alength (into-array ["apple" "orange"]))</syntaxhighlight> |
||
=={{header|COBOL}}== |
=={{header|COBOL}}== |
||
Arrays in COBOL are usually referred to as tables. Tables can have fixed or variable (with known maximum) allocations, using a syntax of OCCURS DEPENDING ON. The value of the ODO identifier is the number of active elements in the table. |
Arrays in COBOL are usually referred to as tables. Tables can have fixed or variable (with known maximum) allocations, using a syntax of OCCURS DEPENDING ON. The value of the ODO identifier is the number of active elements in the table. |
||
< |
<syntaxhighlight lang="cobol"> identification division. |
||
program-id. array-length. |
program-id. array-length. |
||
Line 369: | Line 1,200: | ||
. |
. |
||
end program array-length.</ |
end program array-length.</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>$ cobc -xjd array-length.cob |
<pre>$ cobc -xjd array-length.cob |
||
Line 378: | Line 1,209: | ||
=={{header|ColdFusion}}== |
=={{header|ColdFusion}}== |
||
< |
<syntaxhighlight lang="coldfusion"> |
||
<cfset testArray = ["apple","orange"]> |
<cfset testArray = ["apple","orange"]> |
||
<cfoutput>Array Length = #ArrayLen(testArray)#</cfoutput> |
<cfoutput>Array Length = #ArrayLen(testArray)#</cfoutput> |
||
</syntaxhighlight> |
|||
</lang> |
|||
Outputs:<pre>Array Length = 2</pre> |
Outputs:<pre>Array Length = 2</pre> |
||
[[User:grandnegus|Mike Knapp]] 15:57, 26 May 2016 (UTC) |
[[User:grandnegus|Mike Knapp]] 15:57, 26 May 2016 (UTC) |
||
=={{header|Common Lisp}}== |
=={{header|Common Lisp}}== |
||
<syntaxhighlight lang="lisp"> |
|||
<lang Lisp> |
|||
(print (length #("apple" "orange"))) |
(print (length #("apple" "orange"))) |
||
</syntaxhighlight> |
|||
</lang> |
|||
===Alternate solution=== |
|||
I use [https://franz.com/downloads/clp/survey Allegro CL 10.1] |
|||
<syntaxhighlight lang="lisp"> |
|||
;; Project : Array length |
|||
(setf my-array (make-array '(2))) |
|||
(setf (aref my-array 0) "apple") |
|||
(setf (aref my-array 1) "orange") |
|||
(format t "~a" "length of my-array: ") |
|||
(length my-array) |
|||
(terpri) |
|||
</syntaxhighlight> |
|||
Output: |
|||
<pre> |
|||
length of my-array: 2 |
|||
</pre> |
|||
=={{header|Component Pascal}}== |
|||
{{works with|BlackBox Component Builder}} |
|||
<syntaxhighlight lang="oberon2"> |
|||
MODULE AryLen; |
|||
IMPORT StdLog; |
|||
TYPE |
|||
String = POINTER TO ARRAY OF CHAR; |
|||
VAR |
|||
a: ARRAY 16 OF String; |
|||
PROCEDURE NewString(s: ARRAY OF CHAR): String; |
|||
VAR |
|||
str: String; |
|||
BEGIN |
|||
NEW(str,LEN(s$) + 1);str^ := s$; RETURN str |
|||
END NewString; |
|||
PROCEDURE Length(a: ARRAY OF String): INTEGER; |
|||
VAR |
|||
i: INTEGER; |
|||
BEGIN |
|||
i := 0; |
|||
WHILE a[i] # NIL DO INC(i) END; |
|||
RETURN i |
|||
END Length; |
|||
PROCEDURE Do*; |
|||
BEGIN |
|||
a[0] := NewString("Apple"); |
|||
a[1] := NewString("Orange"); |
|||
StdLog.String("Length:> ");StdLog.Int(Length(a));StdLog.Ln |
|||
END Do; |
|||
END AryLen. |
|||
</syntaxhighlight> |
|||
Execute: ^Q AryLen.Do |
|||
{{out}} |
|||
<pre> |
|||
Length:> 2 |
|||
</pre> |
|||
=={{header|Crystal}}== |
|||
<syntaxhighlight lang="ruby"> |
|||
puts ["apple", "orange"].size |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2 |
|||
</pre> |
|||
=={{header|D}}== |
=={{header|D}}== |
||
<syntaxhighlight lang="d"> |
|||
<lang d> |
|||
import std.stdio; |
import std.stdio; |
||
Line 401: | Line 1,301: | ||
return 0; |
return 0; |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
Or a somewhat shorter... |
Or a somewhat shorter... |
||
<syntaxhighlight lang="d"> |
|||
<lang d> |
|||
import std.stdio; |
import std.stdio; |
||
Line 411: | Line 1,311: | ||
["apple", "orange"].length.writeln; |
["apple", "orange"].length.writeln; |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header| |
=={{header|Dart}}== |
||
<syntaxhighlight lang="dart"> |
|||
<lang delphi> |
|||
arrLength(arr) { |
|||
var a := ['apple', 'orange']; |
|||
return arr.length; |
|||
PrintLn(a.Length); |
|||
} |
|||
</lang> |
|||
main() { |
|||
var fruits = ['apple', 'orange']; |
|||
print(arrLength(fruits)); |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|DataWeave}}== |
|||
<syntaxhighlight lang="dataweave">var arr = ["apple", "orange"] |
|||
sizeOf(arr) |
|||
</syntaxhighlight> |
|||
=={{header|Delphi}}== |
|||
<syntaxhighlight lang="delphi"> |
|||
showmessage( length(['a','b','c']).ToString ); |
|||
</syntaxhighlight> |
|||
=={{header|Diego}}== |
|||
<syntaxhighlight lang="diego">set_namespace(rosettacode)_me(); |
|||
me_msg()_array()_values(apple,orange)_length(); |
|||
reset_namespace[];</syntaxhighlight> |
|||
{{out}} |
|||
<pre>2</pre> |
|||
=={{header|Dragon}}== |
|||
<syntaxhighlight lang="dragon">select "std" |
|||
a = ["apple","orange"] |
|||
b = length(a) |
|||
show b |
|||
</syntaxhighlight> |
|||
=={{header|dt}}== |
|||
<syntaxhighlight lang="dt">[ "apple" "orange" ] len</syntaxhighlight> |
|||
=={{header|Dyalect}}== |
|||
<syntaxhighlight lang="dyalect">var xs = ["apple", "orange"] |
|||
print(xs.Length())</syntaxhighlight> |
|||
=={{header|EasyLang}}== |
|||
<syntaxhighlight lang="text">fruit$[] = [ "apples" "oranges" ] |
|||
print len fruit$[]</syntaxhighlight> |
|||
=={{header|EchoLisp}}== |
=={{header|EchoLisp}}== |
||
< |
<syntaxhighlight lang="scheme"> |
||
(length '("apple" "orange")) ;; list |
(length '("apple" "orange")) ;; list |
||
→ 2 |
→ 2 |
||
(vector-length #("apple" "orange")) ;; vector |
(vector-length #("apple" "orange")) ;; vector |
||
→ 2 |
→ 2 |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Ecstasy}}== |
|||
<syntaxhighlight lang="java">String[] array = ["apple", "orange"]; |
|||
Int length = array.size;</syntaxhighlight> |
|||
=={{header|Ela}}== |
=={{header|Ela}}== |
||
<lang |
<syntaxhighlight lang="ela">length [1..10]</syntaxhighlight> |
||
=={{header|Elena}}== |
|||
ELENA 5.0 : |
|||
<syntaxhighlight lang="elena"> |
|||
var array := new string[]{"apple", "orange"}; |
|||
var length := array.Length; |
|||
</syntaxhighlight> |
|||
=={{header|Elixir}}== |
|||
<syntaxhighlight lang="elixir">iex(1)> length( ["apple", "orange"] ) # List |
|||
2 |
|||
iex(2)> tuple_size( {"apple", "orange"} ) # Tuple |
|||
2</syntaxhighlight> |
|||
=={{header|Elm}}== |
=={{header|Elm}}== |
||
< |
<syntaxhighlight lang="elm"> |
||
import Array |
import Array |
||
import Html |
import Html |
||
Line 440: | Line 1,405: | ||
|> Array.fromList |
|> Array.fromList |
||
|> Array.length |
|> Array.length |
||
|> |
|> String.fromInt |
||
|> Html.text |
|> Html.text |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Emacs Lisp}}== |
=={{header|Emacs Lisp}}== |
||
< |
<syntaxhighlight lang="lisp">(length ["apple" "orange"]) |
||
=> 2</ |
=> 2</syntaxhighlight> |
||
<code>length</code> also accepts a list or a string. |
<code>length</code> also accepts a list or a string. |
||
=={{header| |
=={{header|EMal}}== |
||
<syntaxhighlight lang="emal"> |
|||
<lang elena> |
|||
writeLine(text["apple", "orange"].length) |
|||
</syntaxhighlight> |
|||
#var length := a length. |
|||
</lang> |
|||
=={{header| |
=={{header|Erlang}}== |
||
<syntaxhighlight lang="erlang"> |
|||
<lang elixir>iex(1)> length( ["apple", "orange"] ) # List |
|||
1> length(["apple", "orange"]). %using a list |
|||
2 |
2 |
||
1> tuple_size({"apple", "orange"}). %using a tuple |
|||
2 |
|||
2</lang> |
|||
</syntaxhighlight> |
|||
=={{header|Frink}}== |
|||
<lang frink> |
|||
a = ["apple", "orange"] |
|||
println[length[a]] |
|||
</lang> |
|||
=={{header| |
=={{header|Euphoria}}== |
||
<syntaxhighlight lang="euphoria"> |
|||
The philosophy of Chuck Moore, the creator of Forth was that he did not want to write code for something he may never use. General purpose code was never optimal for him. So Forth has very few pre-fab data structures. |
|||
sequence s = {"apple","orange",2.95} -- Euphoria doesn't care what you put in a sequence |
|||
His solution was to distill his language into a large set of very simple routines that control the hardware directly. This is a cardinal error by conventional thinking but Forth makes it simple and the freedom is eye-opening. |
|||
? length(s) |
|||
By separating the return stack from the parameter stack Forth allows seamless concatenation of these simple routines into higher level functions. The stack management sounds tricky, but in fact, factoring allows you to manage only 2 or 3 parameters per function. |
|||
3 -- three objects |
|||
So this demonstration to show ARRAY Length must build "arrays" from scratch. In Forth, like in Assembler, you can do this any way you want. This demonstration adds new words to Forth that make a syntax to create simple variable length string arrays. Each string is a counted string with no trailing zero. |
|||
? length(s[1]) |
|||
In this example we are configuring memory directly. There are no "pointers". They are just addresses in memory. |
|||
The code is heavily commented to explain what is going on for those unfamiliar with Forth. |
|||
5 -- apple has 5 characters |
|||
<lang>: STRING, ( addr len -- ) \ allocate space & compile string into memory |
|||
here over 1+ allot place ; |
|||
? length(s[1][$]) |
|||
: ," ( -- ) [CHAR] " PARSE STRING, ; \ Parse input to " and compile to memory |
|||
1 -- 'e' is an atomic value |
|||
\ array delimiter words |
|||
: [[ 0 c, ; \ compile 0 as char into memory for start of array |
|||
: ]] [[ ; \ same, but for end of array |
|||
\ list operator words |
|||
: nth ( n list-addr -- addr) \ returns address of the Nth item in the array |
|||
swap 0 do count + loop ; |
|||
? length(s[$]) |
|||
: items ( list-addr -- n ) \ returns the number of strings in the array |
|||
0 \ create an accumulator on the stack |
|||
begin |
|||
1+ 2dup swap nth C@ \ inc. counter, fetch length byte of each item |
|||
0= until \ loop until we hit a zero length (end of list) |
|||
nip \ remove 2nd item from stack (list-addr) leaving the accumulator |
|||
1- ; \ decrement the accumulator |
|||
1 -- 2.95 is an atomic value |
|||
</syntaxhighlight> |
|||
\ use our new string array words to create some lists |
|||
create q [[ ," Apples" ," Oranges" ]] |
|||
create w [[ ," This" ," has" ," more" ," items" ," in the array" ]]</lang> |
|||
Test code at Forth console |
|||
<PRE> |
|||
=={{header|F_Sharp|F#}}== |
|||
Q items . 2 ok |
|||
<syntaxhighlight lang="fsharp">[|1;2;3|].Length |> printfn "%i"</syntaxhighlight> |
|||
W items . 5 ok |
|||
Or: |
|||
</PRE> |
|||
<syntaxhighlight lang="fsharp">[|1;2;3|] |> Array.length |> printfn "%i"</syntaxhighlight> |
|||
=={{header|Factor}}== |
|||
<syntaxhighlight lang="factor"> |
|||
{ "apple" "orange" } length |
|||
</syntaxhighlight> |
|||
=={{header|Fennel}}== |
|||
<syntaxhighlight lang="fennel">(length [:apple :orange])</syntaxhighlight> |
|||
=={{header|Forth}}== |
|||
The philosophy of Chuck Moore, the creator of Forth was that he did not want to write code for something he may never use. His solution was to distill his language into a large set of very simple routines that control the hardware directly. |
|||
This demonstration must build "arrays" from scratch. In Forth, like in Assembler, you can do this any way you want. This demonstration adds new words to Forth that make a syntax to create simple variable length string arrays. Each string is a counted string with no trailing zero. |
|||
The code is commented to explain what is going on for those unfamiliar with Forth. |
|||
<syntaxhighlight lang="forth">: STRING, ( caddr len -- ) \ Allocate space & compile string into memory |
|||
HERE OVER CHAR+ ALLOT PLACE ; |
|||
: " ( -- ) [CHAR] " PARSE STRING, ; \ Parse input to " and compile to memory |
|||
\ Array delimiter words |
|||
: { ALIGN 0 C, ; \ Compile 0 byte start/end of array |
|||
: } ALIGN 0 C, ; |
|||
\ String array words |
|||
: {NEXT} ( str -- next_str) \ Iterate to next string |
|||
COUNT + ; |
|||
: {NTH} ( n array_addr -- str) \ Returns address of the Nth item in the array |
|||
SWAP 0 DO {NEXT} LOOP ; |
|||
: {LEN} ( array_addr -- n) \ count strings in the array |
|||
0 >R \ Counter on Rstack |
|||
{NEXT} |
|||
BEGIN |
|||
DUP C@ \ Fetch length byte |
|||
WHILE \ While true |
|||
R> 1+ >R \ Inc. counter |
|||
{NEXT} |
|||
REPEAT |
|||
DROP |
|||
R> ; \ return counter to data stack </syntaxhighlight> |
|||
Test code at Forth console |
|||
<syntaxhighlight lang="forth">CREATE Q { " Apples" " Oranges" } q {len} . 2 ok</syntaxhighlight> |
|||
=={{header|Fortran}}== |
=={{header|Fortran}}== |
||
Early fortrans offered no protocol for ascertaining the length (or dimensionality) of arrays, though the compiler has this information. Thus a statement such as <code>PRINT A</code> would print all the elements of a variable <code>A</code> according to its definition. A subprogram that received a parameter would have no access to these details, so its parameter might be declared as <code>A(12345)</code> simply to signify that it was an array (rather than an ordinary variable) and the programmer would rely on other data to know the upper bound to employ, for instance via an additional parameter. ''Any mistakes would cause crashes!'' On the other hand, with heavy computational tasks, it was common to take advantage of the opportunities. Thus, a subprogram might regard its array parameter as one-dimensional even though the actual parameter was not. Carefully-programmed routines might thusly process a sequence of elements via 1-D indexing, far faster than the 2-D or higher order indexing of the original. Success at this game required understanding how array elements were arranged in multidimensional arrays. |
Early fortrans offered no protocol for ascertaining the length (or dimensionality) of arrays, though the compiler has this information. Thus a statement such as <code>PRINT A</code> would print all the elements of a variable <code>A</code> according to its definition. A subprogram that received a parameter would have no access to these details, so its parameter might be declared as <code>A(12345)</code> simply to signify that it was an array (rather than an ordinary variable) and the programmer would rely on other data to know the upper bound to employ, for instance via an additional parameter. ''Any mistakes would cause crashes!'' On the other hand, with heavy computational tasks, it was common to take advantage of the opportunities. Thus, a subprogram might regard its array parameter as one-dimensional even though the actual parameter was not. Carefully-programmed routines might thusly process a sequence of elements via 1-D indexing, far faster than the 2-D or higher order indexing of the original. Success at this game required understanding how array elements were arranged in multidimensional arrays. |
||
Later fortrans allowed <code>A(*)</code> to signify an array parameter of unstated upper bound, but there was still a problem with higher dimensions. All but the last dimension has to be stated correctly if a multi-dimensional array parameter is to be indexed correctly. |
Later fortrans allowed <code>A(*)</code> to signify an array parameter of unstated upper bound, but there was still a problem with higher dimensions. All but the last dimension has to be stated correctly if a multi-dimensional array parameter is to be indexed correctly - Fortran stores array elements in [[Array#Fortran|column-major]] order. |
||
With Fortran 90, a new protocol was introduced, whereby the parameter might be declared as <code>A(:)</code> signifying an array of one dimension, of bounds unstated. A 2-D array would have <code>A(:,:)</code> and so on. Further, arrays could have arbitrary lower bounds as well, as in <code>A(-7:12)</code> but if no colon appeared for a dimension, the lower bound would be assumed to be one so <code>A(2)</code> means an array of two elements, as before. And as before, a bound could be explicitly stated, perhaps via an explicit parameter such as <code>N</code>, but now with the : scheme, the compiler is passing secret additional parameters to the subprogram giving the bounds of the array, and these can be accessed via the library functions LBOUND and UBOUND. For multi-dimensional arrays there are multiple bounds, and an invocation might be <code>UBOUND(A,DIM = 2)</code> but in the example only a one-dimensional array is involved. These facilities are available only if the new MODULE protocol is employed. |
With Fortran 90, a new protocol was introduced, whereby the parameter might be declared as <code>A(:)</code> signifying an array of one dimension, of bounds unstated. A 2-D array would have <code>A(:,:)</code> and so on. Further, arrays could have arbitrary lower bounds as well, as in <code>A(-7:12)</code> but if no colon appeared for a dimension, the lower bound would be assumed to be one so <code>A(2)</code> means an array of two elements, as before. And as before, in a subprogram a bound could be explicitly stated, perhaps via an explicit parameter such as <code>N</code>, but now with the <code>:</code> scheme, the compiler is passing secret additional parameters to the subprogram giving the bounds of the array, and these can be accessed via the library functions LBOUND and UBOUND. For multi-dimensional arrays there are multiple bounds, and an invocation might be <code>UBOUND(A,DIM = 2)</code> but in the example only a one-dimensional array is involved. These facilities are available only if the new MODULE protocol is employed. |
||
The task is in terms of an array holding the texts "Apple" and "Orange", so a CHARACTER*6 element size will do; the subprogram receives yet another secret parameter specifying the size of CHARACTER parameters. This size can be accessed via the LEN function, and, since in principle the index span is arbitrary, no constant index is sure to be a valid index of some single element: thus the LBOUND function is used to finger one that is. |
The task is in terms of an array holding the texts "Apple" and "Orange", so a CHARACTER*6 element size will do; the subprogram receives yet another secret parameter specifying the size of CHARACTER parameters. This size can be accessed via the LEN function, and, since in principle the index span is arbitrary, no constant index is sure to be a valid index of some single element: thus the LBOUND function is used to finger one that is. |
||
Line 522: | Line 1,512: | ||
For a simple example, the WRITE(6,*) suffices: write to standard output (the 6), in free-format (the *). |
For a simple example, the WRITE(6,*) suffices: write to standard output (the 6), in free-format (the *). |
||
<syntaxhighlight lang="fortran"> |
|||
<lang Fortran> |
|||
MODULE EXAMPLE |
MODULE EXAMPLE |
||
CONTAINS |
CONTAINS |
||
Line 543: | Line 1,533: | ||
WRITE (6,*) "L. bound",LBOUND(ARRAY),", U. bound",UBOUND(ARRAY) |
WRITE (6,*) "L. bound",LBOUND(ARRAY),", U. bound",UBOUND(ARRAY) |
||
END |
END |
||
</syntaxhighlight> |
|||
</lang> |
|||
Output: |
Output: |
||
Line 552: | Line 1,542: | ||
L. bound -1 , U. bound 1 |
L. bound -1 , U. bound 1 |
||
Notice that the subprogram sees the array as an old-style array starting with index one! If it is to work with a lower bound other than one, the declaration in the subprogram must state it, perhaps as A(-1:) or as A(START:), ''etc''. The upper bound remains unspecified, and with that declaration, UBOUND returns 1 instead of 3, corresponding to the shift. Thus, UBOUND returns not the actual upper bound of the array parameter (as supplied) but the upper bound relative to the lower bound in use ''in'' the subprogram so that UBOUND - LBOUND + 1 does give the number of elements. |
|||
Notice that the subprogram sees the array as an old-style array starting with index one! |
|||
If in the subprogram the bounds are fixed (say as <code>A(-1:6)</code>) then a CALL ABOUND(ARRAY) may provoke a compiler complaint if ARRAY is not a suitable size. |
|||
=={{header|FreeBASIC}}== |
|||
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64 |
|||
Dim fruit(1) As String = {"apple", "orange"} |
|||
Dim length As Integer = UBound(fruit) - LBound(fruit) + 1 |
|||
Print "The length of the fruit array is"; length |
|||
Print |
|||
Print "Press any key to quit the program" |
|||
Sleep</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
The length of the fruit array is 2 |
|||
</pre> |
|||
=={{header|Frink}}== |
|||
<syntaxhighlight lang="frink"> |
|||
a = ["apple", "orange"] |
|||
println[length[a]] |
|||
</syntaxhighlight> |
|||
=={{header|FurryScript}}== |
=={{header|FurryScript}}== |
||
< |
<syntaxhighlight lang="furryscript">THE_LIST( <apple> <orange> ) |
||
COUNT[ 0 SW ~| COUNT_STEP# 0 SW SU ] |
COUNT[ 0 SW ~| COUNT_STEP# 0 SW SU ] |
||
COUNT_STEP[ DR 1 SU ] |
COUNT_STEP[ DR 1 SU ] |
||
`THE_LIST COUNT# +<></ |
`THE_LIST COUNT# +<></syntaxhighlight> |
||
=={{header|F_Sharp|F#}}== |
|||
<lang fsharp>[|1;2;3|].Length |> printfn "%i"</lang> |
|||
Or: |
|||
<lang fsharp>[|1;2;3|] |> Array.length |> printfn "%i"</lang> |
|||
=={{header|Futhark}}== |
=={{header|Futhark}}== |
||
{{needs-review|Futhark}} |
|||
The <code>shape</code> builtin returns the shape of an array as an array of integers. The length is element 0 of the shape: |
The <code>shape</code> builtin returns the shape of an array as an array of integers. The length is element 0 of the shape: |
||
<syntaxhighlight lang="futhark"> |
|||
<lang Futhark> |
|||
fun length(as: []int): int = (shape as)[0] |
fun length(as: []int): int = (shape as)[0] |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|FutureBasic}}== |
|||
NSUInteger count = fn ArrayCount( ''array'' ). Example: |
|||
<syntaxhighlight lang="futurebasic"> |
|||
window 1 |
|||
print fn ArrayCount( @[@"apple",@"orange",@"cherry",@"grape",@"lemon"] ) |
|||
HandleEvents |
|||
</syntaxhighlight> |
|||
We can also use FB's len() function to get the length of an array. |
|||
<syntaxhighlight lang="futurebasic"> |
|||
void local fn DoIt |
|||
CFArrayRef array = @[@"apple",@"orange",@"cherry",@"grape",@"lemon"] |
|||
print len(array) |
|||
end fn |
|||
fn DoIt |
|||
HandleEvents |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
5 |
|||
</pre> |
|||
=={{header|Fōrmulæ}}== |
|||
{{FormulaeEntry|page=https://formulae.org/?script=examples/Array_length}} |
|||
'''Solution''' |
|||
The cardinality expression reduces to the number of subexpressions the given expression has, including if the expressions is a list: |
|||
[[File:Fōrmulæ - Array length 01.png]] |
|||
[[File:Fōrmulæ - Array length 02.png]] |
|||
=={{header|Gambas}}== |
|||
'''[https://gambas-playground.proko.eu/?gist=2a452c807c7030eb64a2f1d60d31a830 Click this link to run this code]''' |
|||
<syntaxhighlight lang="gambas">Public Sub Main() |
|||
Dim siList As Short[] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] |
|||
Print siList.Count |
|||
End</syntaxhighlight> |
|||
Output: |
|||
<pre> |
|||
10 |
|||
</pre> |
|||
=={{header|Genie}}== |
|||
<syntaxhighlight lang="genie">[indent=4] |
|||
/* Array length, in Genie */ |
|||
init |
|||
arr:array of string = {"apple", "orange"} |
|||
stdout.printf("%d ", arr.length) |
|||
print arr[1]</syntaxhighlight> |
|||
{{out}} |
|||
<pre>prompt$ valac array_length.gs |
|||
prompt$ ./array_length |
|||
2 orange</pre> |
|||
=={{header|Go}}== |
=={{header|Go}}== |
||
< |
<syntaxhighlight lang="go">package main |
||
import "fmt" |
import "fmt" |
||
Line 584: | Line 1,655: | ||
fmt.Printf("Length of %v is %v.\n", arr, len(arr)) |
fmt.Printf("Length of %v is %v.\n", arr, len(arr)) |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
|||
<pre> |
|||
Length of [apple orange pear] is 3. |
|||
</pre> |
|||
=={{header|Groovy}}== |
=={{header|Groovy}}== |
||
<syntaxhighlight lang="groovy"> |
|||
<lang Groovy> |
|||
def fruits = ['apple','orange'] |
def fruits = ['apple','orange'] |
||
println fruits.size() |
println fruits.size() |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header| |
=={{header|Harbour}}== |
||
<syntaxhighlight lang="visualfoxpro"> |
|||
<lang futurebasic> |
|||
LOCAL aFruits := {"apple", "orange"} |
|||
include "ConsoleWindow" |
|||
Qout( Len( aFruits ) ) // --> 2 |
|||
</syntaxhighlight> |
|||
=={{header|Haskell}}== |
|||
dim as CFArrayRef array |
|||
dim as Str255 s |
|||
dim as CFStringRef fruits, tempStr |
|||
dim as CFIndex ubound, i |
|||
<syntaxhighlight lang="haskell">-- [[Char]] -> Int |
|||
fruits = @"apples,bananas,cherries,dates,grapes,lemon,lime,orange,peach,pear,pineapple,strawberries,watermelon" |
|||
length ["apple", "orange"]</syntaxhighlight> |
|||
array = fn CFStringCreateArrayBySeparatingStrings( _kCFAllocatorDefault, fruits, @"," ) |
|||
=={{header|hexiscript}}== |
|||
ubound = fn CFArrayGetCount( array ) |
|||
<syntaxhighlight lang="hexiscript">let a arr 2 |
|||
for i = 0 to ubound - 1 |
|||
let a[0] "apple" |
|||
tempStr = fn CFArrayGetValueAtIndex( array, i ) |
|||
let a[1] "orange" |
|||
fn CFStringGetPascalString( tempStr, @s, 256, _kCFStringEncodingMacRoman ) |
|||
println len a</syntaxhighlight> |
|||
CFRelease( tempStr ) |
|||
print "Fruit"; i; " = "; s |
|||
next |
|||
</lang> |
|||
Output: |
|||
<pre> |
|||
Fruit 0 = apples |
|||
Fruit 1 = bananas |
|||
Fruit 2 = cherries |
|||
Fruit 3 = dates |
|||
Fruit 4 = grapes |
|||
Fruit 5 = lemon |
|||
Fruit 6 = lime |
|||
Fruit 7 = orange |
|||
Fruit 8 = peach |
|||
Fruit 9 = pear |
|||
Fruit 10 = pineapple |
|||
Fruit 11 = strawberries |
|||
Fruit 12 = watermelon |
|||
</pre> |
|||
=={{header| |
=={{header|Hoon}}== |
||
<syntaxhighlight lang="hoon">|= arr=(list *) (lent arr)</syntaxhighlight> |
|||
=={{header|i}}== |
|||
<lang Haskell>-- [[Char]] -> Int |
|||
<syntaxhighlight lang="i">main: print(#["apple", "orange"])</syntaxhighlight> |
|||
=={{header| |
=={{header|Icon}} and {{header|Unicon}}== |
||
Icon, and therefore Unicon, includes a prefix size operator, star <code>*</code>. This operator can be applied to just about any data type or data structure. |
|||
In I, strings need to be hashed in order to be stored in an array. |
|||
<lang i>software { |
|||
<syntaxhighlight lang="unicon">write(*["apple", "orange"])</syntaxhighlight> |
|||
print(len(a)) |
|||
}</lang> |
|||
=={{header|Idris}}== |
=={{header|Idris}}== |
||
< |
<syntaxhighlight lang="idris">length ["apple", "orange"]</syntaxhighlight> |
||
=={{header|Insitux}}== |
|||
<syntaxhighlight lang="insitux">(len ['apple' 'orange'])</syntaxhighlight> |
|||
=={{header|J}}== |
=={{header|J}}== |
||
Tally (<code>#</code>) returns the length of the leading dimension of an array (or 1 if the array has no dimensions). Shape Of (<code>$</code>) returns the length of each dimension of an array. |
Tally (<code>#</code>) returns the length of the leading dimension of an array (or 1 if the array has no dimensions). Shape Of (<code>$</code>) returns the length of each dimension of an array. |
||
< |
<syntaxhighlight lang="j"> # 'apple';'orange' |
||
2 |
2 |
||
$ 'apple';'orange' |
$ 'apple';'orange' |
||
2</ |
2</syntaxhighlight> |
||
For the list array example given, the result appears to be the same. The difference is that the result of Tally is a scalar (array of 0 dimensions) whereas the result of Shape Of is a list (1 dimensional array), of length 1 in this case. |
For the list array example given, the result appears to be the same. The difference is that the result of Tally is a scalar (array of 0 dimensions) whereas the result of Shape Of is a list (1 dimensional array), of length 1 in this case. |
||
< |
<syntaxhighlight lang="j"> $#'apple';'orange' |
||
$$'apple';'orange' |
$$'apple';'orange' |
||
1</ |
1</syntaxhighlight> |
||
This might be a clearer concept with a few more examples. Here's an array with two dimensions: |
This might be a clearer concept with a few more examples. Here's an array with two dimensions: |
||
< |
<syntaxhighlight lang="j"> >'apple';'orange' |
||
apple |
apple |
||
orange |
orange |
||
Line 664: | Line 1,723: | ||
2 6 |
2 6 |
||
#>'apple';'orange' |
#>'apple';'orange' |
||
2</ |
2</syntaxhighlight> |
||
And, here's an array with no dimensions: |
And, here's an array with no dimensions: |
||
<lang> 9001 |
<syntaxhighlight lang="text"> 9001 |
||
9001 |
9001 |
||
#9001 |
#9001 |
||
1 |
1 |
||
$9001 |
$9001 |
||
</syntaxhighlight> |
|||
</lang> |
|||
You can count the number of dimensions of an array (the length of the list of lengths) using <code>#$array</code>: |
You can count the number of dimensions of an array (the length of the list of lengths) using <code>#$array</code>: |
||
<syntaxhighlight lang="j"> |
|||
<lang j> |
|||
#$9001 |
#$9001 |
||
0 |
0 |
||
Line 679: | Line 1,738: | ||
1 |
1 |
||
#$>'apple';'orange' |
#$>'apple';'orange' |
||
2</ |
2</syntaxhighlight> |
||
=={{header|Janet}}== |
|||
<syntaxhighlight lang="janet"> |
|||
(def our-array @["apple" "orange"]) |
|||
(length our-array) |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2 |
|||
</pre> |
|||
=={{header|Java}}== |
=={{header|Java}}== |
||
The resulting ''array'' object will have a ''length'' field. |
|||
<lang java>public class ArrayLength { |
|||
<syntaxhighlight lang="java"> |
|||
public static void main(String[] args) { |
|||
String[] strings = { "apple", "orange" }; |
|||
int length = strings.length; |
|||
} |
|||
</syntaxhighlight> |
|||
}</lang> |
|||
Additionally, you can do this in one line, if need be. |
|||
<syntaxhighlight lang="java"> |
|||
int length = new String[] { "apple", "orange" }.length; |
|||
</syntaxhighlight> |
|||
=={{header|JavaScript}}== |
=={{header|JavaScript}}== |
||
< |
<syntaxhighlight lang="javascript">console.log(['apple', 'orange'].length);</syntaxhighlight> |
||
However, determining the length of a list, array, or collection may simply be the wrong thing to do. |
However, determining the length of a list, array, or collection may simply be the wrong thing to do. |
||
Line 696: | Line 1,771: | ||
If, for example, the actual task (undefined here, unfortunately) requires retrieving the final item, while it is perfectly possible to write '''last''' in terms of '''length''' |
If, for example, the actual task (undefined here, unfortunately) requires retrieving the final item, while it is perfectly possible to write '''last''' in terms of '''length''' |
||
< |
<syntaxhighlight lang="javascript">function last(lst) { |
||
return lst[lst.length - 1]; |
return lst[lst.length - 1]; |
||
}</ |
}</syntaxhighlight> |
||
using length has the disadvantage that it leaves ''last'' simply undefined for an empty list. |
using length has the disadvantage that it leaves ''last'' simply undefined for an empty list. |
||
Line 704: | Line 1,779: | ||
We might do better to drop the narrow focus on length, and instead use a fold (''reduce'', in JS terms) which can return a default value of some kind. |
We might do better to drop the narrow focus on length, and instead use a fold (''reduce'', in JS terms) which can return a default value of some kind. |
||
< |
<syntaxhighlight lang="javascript">function last(lst) { |
||
return lst.reduce(function (a, x) { |
return lst.reduce(function (a, x) { |
||
return x; |
return x; |
||
}, null); |
}, null); |
||
}</ |
}</syntaxhighlight> |
||
Alternatively, rather than scanning the entire list to simply get the final value, it might sometimes be better to test the length: |
Alternatively, rather than scanning the entire list to simply get the final value, it might sometimes be better to test the length: |
||
< |
<syntaxhighlight lang="javascript">function last(list, defaultValue) { |
||
return list.length ?list[list.length-1] :defaultValue; |
return list.length ?list[list.length-1] :defaultValue; |
||
}</ |
}</syntaxhighlight> |
||
Or use other built-in functions – this, for example, seems fairly clear, and is already 100+ times faster than unoptimised tail recursion in ES5 (testing with a list of 1000 elements): |
Or use other built-in functions – this, for example, seems fairly clear, and is already 100+ times faster than unoptimised tail recursion in ES5 (testing with a list of 1000 elements): |
||
< |
<syntaxhighlight lang="javascript">function last(list, defaultValue) { |
||
return list.slice(-1)[0] || defaultValue; |
return list.slice(-1)[0] || defaultValue; |
||
}</ |
}</syntaxhighlight> |
||
=={{header| |
=={{header|Joy}}== |
||
<syntaxhighlight lang="joy">["apple" "orange"] size.</syntaxhighlight> |
|||
{{out}} |
|||
<pre>2</pre> |
|||
=={{header|jq}}== |
|||
<lang jq>["apple","orange"] | length</lang> |
|||
<syntaxhighlight lang="jq">["apple","orange"] | length</syntaxhighlight> |
|||
Output: |
Output: |
||
<lang |
<syntaxhighlight lang="sh">2</syntaxhighlight> |
||
Note that the ''length'' filter is polymorphic, so for example the empty string (""), the empty list ([]), and ''null'' all have ''length'' 0. |
Note that the ''length'' filter is polymorphic, so for example the empty string (""), the empty list ([]), and ''null'' all have ''length'' 0. |
||
=={{header|Jsish}}== |
|||
<syntaxhighlight lang="javascript">/* Array length, in jsish */ |
|||
var arr = new Array('apple', 'orange'); |
|||
puts(arr.length); |
|||
puts(arr[1]);</syntaxhighlight> |
|||
{{out}} |
|||
<pre>prompt$ jsish arrayLength.jsi |
|||
2 |
|||
orange</pre> |
|||
=={{header|Julia}}== |
=={{header|Julia}}== |
||
<syntaxhighlight lang="julia"> |
|||
<lang Julia> |
|||
a = ["apple","orange"] |
a = ["apple","orange"] |
||
length(a) |
length(a) |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|K}}== |
|||
<syntaxhighlight lang="k">#("apple";"orange")</syntaxhighlight> |
|||
{{out}} |
|||
<pre>2</pre> |
|||
=={{header|Klingphix}}== |
|||
<syntaxhighlight lang="klingphix">include ..\Utilitys.tlhy |
|||
( "apple" "orange" ) len print |
|||
" " input</syntaxhighlight> |
|||
{{out}} |
|||
<pre>2</pre> |
|||
=={{header|Klong}}== |
|||
<syntaxhighlight lang="k"> |
|||
#["apple" "orange"] |
|||
</syntaxhighlight> |
|||
=={{header|Kotlin}}== |
=={{header|Kotlin}}== |
||
<syntaxhighlight lang="scala">fun main(args: Array<String>) { |
|||
<lang Kotlin> |
|||
fun main(args: Array<String>) { |
|||
println(arrayOf("apple", "orange").size) |
println(arrayOf("apple", "orange").size) |
||
}</syntaxhighlight> |
|||
} |
|||
</lang> |
|||
=={{header|Lambdatalk}}== |
|||
<syntaxhighlight lang="scheme"> |
|||
{A.length {A.new 1 2 3}} |
|||
-> 3 |
|||
</syntaxhighlight> |
|||
=={{header|Lang}}== |
|||
<syntaxhighlight lang="lang"> |
|||
&arr $= [apple, orange] |
|||
# Array length function |
|||
fn.println(fn.arrayLength(&arr)) |
|||
# Length operator function |
|||
fn.println(fn.len(&arr)) |
|||
# Length operator |
|||
fn.println(parser.op(@&arr)) |
|||
</syntaxhighlight> |
|||
=={{header|Latitude}}== |
|||
In Latitude, <code>length</code> and <code>size</code> are synonymous and will both retrieve the size of a collection. |
|||
<syntaxhighlight lang="latitude">println: ["apple", "orange"] length.</syntaxhighlight> |
|||
=={{header|LDPL}}== |
|||
<syntaxhighlight lang="ldpl">data: |
|||
fruits is text list |
|||
len is number |
|||
procedure: |
|||
push "apple" to fruits |
|||
push "orange" to fruits |
|||
get length of fruits in len |
|||
display len lf |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2 |
|||
</pre> |
|||
=={{header|Liberty BASIC}}== |
=={{header|Liberty BASIC}}== |
||
Line 753: | Line 1,904: | ||
NOTE -- This program runs only under LB Booster version 3.05 or higher because of arrays with more than two dimensions, passed array names to functions and subroutines as a parameter, and structured error trapping syntax. Get the LBB compiler here: http://lbbooster.com/ |
NOTE -- This program runs only under LB Booster version 3.05 or higher because of arrays with more than two dimensions, passed array names to functions and subroutines as a parameter, and structured error trapping syntax. Get the LBB compiler here: http://lbbooster.com/ |
||
{{works with|LB Booster}} |
|||
<syntaxhighlight lang="lb"> |
|||
<lang lb> |
|||
FruitList$(0)="apple" 'assign 2 cells of a list array |
FruitList$(0)="apple" 'assign 2 cells of a list array |
||
FruitList$(1)="orange" |
FruitList$(1)="orange" |
||
Line 866: | Line 2,017: | ||
print ")" |
print ")" |
||
end sub |
end sub |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 873: | Line 2,024: | ||
DIM array$(10) |
DIM array$(10) |
||
</pre> |
</pre> |
||
=={{header|LIL}}== |
|||
LIL does not use arrays, but indexed lists. The builtin '''count''' command returns the item count in a list. The '''length''' command returns the length of the list after string conversion. |
|||
<syntaxhighlight lang="tcl"># Array length, in LIL |
|||
set a [list "apple"] |
|||
append a "orange" |
|||
print [count $a] |
|||
print [index $a 1]</syntaxhighlight> |
|||
{{out}} |
|||
<pre>prompt$ lil arrayLength.lil |
|||
2 |
|||
orange</pre> |
|||
=={{header|Limbo}}== |
|||
<syntaxhighlight lang="limbo">implement Command; |
|||
include "sys.m"; |
|||
sys: Sys; |
|||
include "draw.m"; |
|||
include "sh.m"; |
|||
init(nil: ref Draw->Context, nil: list of string) |
|||
{ |
|||
sys = load Sys Sys->PATH; |
|||
a := array[] of {"apple", "orange"}; |
|||
sys->print("length of a: %d\n", len a); |
|||
}</syntaxhighlight> |
|||
=={{header|Lingo}}== |
|||
<syntaxhighlight lang="lingo">fruits = ["apple", "orange"] |
|||
put fruits.count |
|||
-- 2</syntaxhighlight> |
|||
=={{header|Little}}== |
=={{header|Little}}== |
||
< |
<syntaxhighlight lang="c">string fruit[] = {"apples", "oranges"}; |
||
puts(length(fruit));</ |
puts(length(fruit));</syntaxhighlight> |
||
=={{header|LiveCode}}== |
=={{header|LiveCode}}== |
||
< |
<syntaxhighlight lang="livecode">put "apple","orange" into fruit |
||
split fruit using comma |
split fruit using comma |
||
answer the number of elements of fruit</ |
answer the number of elements of fruit</syntaxhighlight> |
||
=={{header|Lua}}== |
=={{header|Lua}}== |
||
<syntaxhighlight lang="lua">-- For tables as simple arrays, use the # operator: |
|||
<lang Lua> |
|||
-- For tables as simple arrays, use the # operator: |
|||
fruits = {"apple", "orange"} |
fruits = {"apple", "orange"} |
||
print(#fruits) |
print(#fruits) |
||
Line 896: | Line 2,083: | ||
-- For this you can use this short function: |
-- For this you can use this short function: |
||
function size (tab) |
function size (tab) |
||
local count = 0 |
|||
for k, v in pairs(tab) do |
|||
count = count + 1 |
|||
end |
|||
return count |
|||
end |
end |
||
print(size(fruits)) |
print(size(fruits))</syntaxhighlight> |
||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 911: | Line 2,097: | ||
2 |
2 |
||
</pre> |
</pre> |
||
=={{header|M2000 Interpreter}}== |
|||
<syntaxhighlight lang="m2000 interpreter"> |
|||
\\ A is a pointer to array |
|||
A=("Apple", "Orange") |
|||
Print Len(A)=2 ' True |
|||
Print Dimension(A, 0) ' LBound (0 or 1), here 0 |
|||
Print Dimension(A) ' No of Dimensions 1 |
|||
Print Dimension(A, 1) ' for 1 dimension array this is also Length=2 |
|||
\\ A$( ) is an Array (not a pointer to array) |
|||
Dim Base 1, A$(2) |
|||
A$(1)="Apple", "Orange" |
|||
Print Dimension(A$(), 0) ' LBound (0 or 1), here 1 |
|||
Print Dimension(A$()) ' No of Dimensions 1 |
|||
Print Dimension(A$(), 1) ' for 1 dimension array this is also Length=2 |
|||
Link A to B$() ' B$() is a reference to A |
|||
Print B$(0)=A$(1) |
|||
Print B$(1)=A$(2) |
|||
Dim C$() |
|||
\\ C$() get a copy of B$() |
|||
C$()=B$() |
|||
Print C$() ' prints Apple Orange |
|||
\\ An array can link to a new name as reference, and can change major type |
|||
\\ here A$() get A() so we can read/store numbers and read/store strings in same array |
|||
\\ using two names |
|||
Link A$() to A() |
|||
\\ An array pointer can point to another array |
|||
A=A() |
|||
Print Dimension(A, 0) ' LBound (0 or 1), here 1 (was 0) |
|||
\\ Because B$() is reference of A: |
|||
Print Dimension(B$(), 0) ' LBound (0 or 1), here 1 (was 0) |
|||
Print B$(1)=A$(1) |
|||
Print B$(2)=A$(2) |
|||
Print Dimension(C$(), 0) ' LBound (0 or 1), here 0 |
|||
\\ change base preserve items |
|||
Dim Base 1, C$(Dimension(C$(), 1)) |
|||
Print Dimension(C$(), 0) ' LBound (0 or 1), here 1 (was 0) |
|||
Print C$() ' prints Apple Orange |
|||
Print Len(C$()) ' Len return all items of an array - can be 0 |
|||
Dim K(1,1,1,1,1,1) ' Maximum 10 dimensions |
|||
Print Len(K()=1 ' True |
|||
</syntaxhighlight> |
|||
=={{header|Maple}}== |
=={{header|Maple}}== |
||
< |
<syntaxhighlight lang="maple">a := Array(["apple", "orange"]); |
||
numelems(a);</ |
numelems(a);</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 921: | Line 2,149: | ||
</pre> |
</pre> |
||
=={{header|Mathematica}}== |
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
||
< |
<syntaxhighlight lang="mathematica">Length[{"apple", "orange"}]</syntaxhighlight> |
||
=={{header|MATLAB}} / {{header|Octave}}== |
=={{header|MATLAB}} / {{header|Octave}}== |
||
< |
<syntaxhighlight lang="matlab">length({'apple', 'orange'})</syntaxhighlight> |
||
For arrays with more than one dimension, length reports the length of the larges dimension. The number of elements in a multi-dimensional array can be obtained with numel. |
For arrays with more than one dimension, length reports the length of the larges dimension. The number of elements in a multi-dimensional array can be obtained with numel. |
||
< |
<syntaxhighlight lang="matlab">numel({'apple', 'orange'; 'pear', 'banana'})</syntaxhighlight> |
||
=={{header|Modula-3}}== |
|||
<syntaxhighlight lang="modula3">MODULE ArrayLength EXPORTS Main; |
|||
IMPORT IO; |
|||
VAR |
|||
Arr:ARRAY[1..2] OF TEXT := |
|||
ARRAY[1..2] OF TEXT{"apples", "oranges"}; |
|||
BEGIN |
|||
IO.PutInt(NUMBER(Arr)); |
|||
END ArrayLength.</syntaxhighlight> |
|||
=={{header|Mercury}}== |
|||
<syntaxhighlight lang="mercury">:- module array_length. |
|||
:- interface. |
|||
:- import_module io. |
|||
:- pred main(io::di, io::uo) is det. |
|||
:- implementation. |
|||
:- import_module array, list. |
|||
main(!IO) :- |
|||
Array = array(["apples", "oranges"]), |
|||
io.write_int(size(Array), !IO).</syntaxhighlight> |
|||
=={{header|min}}== |
|||
{{works with|min|0.19.3}} |
|||
<syntaxhighlight lang="min">("apple" "orange") size print</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2 |
|||
</pre> |
|||
=={{header|MiniScript}}== |
|||
<syntaxhighlight lang="miniscript"> |
|||
fruits = ["apple", "orange"] |
|||
print fruits.len |
|||
</syntaxhighlight> |
|||
=={{header|MiniZinc}}== |
|||
<syntaxhighlight lang="minizinc"> |
|||
array[int] of int: arr = [1,2,3]; |
|||
var int: size = length(arr); |
|||
solve satisfy; |
|||
output [show(size),"\n"]; |
|||
</syntaxhighlight> |
|||
=={{header|Nanoquery}}== |
|||
<syntaxhighlight lang="nanoquery">fruit = array(2) |
|||
fruit[0] = "apple" |
|||
fruit[1] = "orange" |
|||
println len(fruit) |
|||
// outputs 2</syntaxhighlight> |
|||
=={{header|Neko}}== |
=={{header|Neko}}== |
||
< |
<syntaxhighlight lang="neko">var fruit = $array("apple", "orange"); |
||
$print($asize(fruit));</ |
$print($asize(fruit));</syntaxhighlight> |
||
=={{header|NewLISP}}== |
|||
<syntaxhighlight lang="newlisp">(println (length '("apple" "orange"))) |
|||
; Nehal-Singhal 2018-05-25 |
|||
(length '(apple orange))</syntaxhighlight> |
|||
=={{header|NGS}}== |
=={{header|NGS}}== |
||
< |
<syntaxhighlight lang="ngs">echo(len(['apple', 'orange'])) |
||
# same |
# same |
||
echo(['apple', 'orange'].len())</ |
echo(['apple', 'orange'].len())</syntaxhighlight> |
||
=={{header|NewLISP}}== |
|||
<lang newslisp> |
|||
(println (length '("apple" "orange"))) |
|||
</lang> |
|||
=={{header|Nim}}== |
=={{header|Nim}}== |
||
<syntaxhighlight lang="nim">let fruit = ["apple", "orange"] |
|||
<lang nim> |
|||
echo "The length of the fruit array is ", len(fruit)</syntaxhighlight> |
|||
let fruit = ["apple", "orange"] |
|||
echo "The length of the fruit array is ", len(fruit) |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
Line 954: | Line 2,239: | ||
The length of the fruit array is 2 |
The length of the fruit array is 2 |
||
</pre> |
</pre> |
||
=={{header|Nu}}== |
|||
<syntaxhighlight lang="nu"> |
|||
[apple orange] | length |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2 |
|||
</pre> |
|||
=={{header|Nutt}}== |
|||
<syntaxhighlight lang="Nutt"> |
|||
module main |
|||
imports native.io.output.say |
|||
say(#{"apple","orange"}) |
|||
end |
|||
</syntaxhighlight> |
|||
=={{header|Oberon-2}}== |
=={{header|Oberon-2}}== |
||
{{works with|oo2c}} |
{{works with|oo2c}} |
||
< |
<syntaxhighlight lang="oberon2"> |
||
MODULE ArrayLength; |
MODULE ArrayLength; |
||
IMPORT |
IMPORT |
||
Line 989: | Line 2,293: | ||
Out.String("length: ");Out.Int(Length(a),0);Out.Ln |
Out.String("length: ");Out.Int(Length(a),0);Out.Ln |
||
END ArrayLength. |
END ArrayLength. |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 996: | Line 2,300: | ||
=={{header|Objeck}}== |
=={{header|Objeck}}== |
||
< |
<syntaxhighlight lang="objeck"> |
||
class Test { |
class Test { |
||
function : Main(args : String[]) ~ Nil { |
function : Main(args : String[]) ~ Nil { |
||
Line 1,002: | Line 2,306: | ||
fruit->Size()->PrintLine(); |
fruit->Size()->PrintLine(); |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
=={{header|OCaml}}== |
=={{header|OCaml}}== |
||
<syntaxhighlight lang="ocaml"> |
|||
<lang OCaml> |
|||
Array.length [|"apple"; "orange"|];; |
Array.length [|"apple"; "orange"|];; |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Oforth}}== |
=={{header|Oforth}}== |
||
< |
<syntaxhighlight lang="oforth">[ "apple", "orange" ] size</syntaxhighlight> |
||
=={{header|Ol}}== |
|||
All of these methods are equivalent. |
|||
<syntaxhighlight lang="scheme"> |
|||
(print (vector-length (vector "apple" "orange"))) |
|||
(print (vector-length #("apple" "orange"))) |
|||
(print (vector-length ["apple" "orange"])) |
|||
(print (size #("apple" "orange"))) |
|||
</syntaxhighlight> |
|||
=={{header|OmniMark}}== |
|||
In OmniMark, From [https://developers.stilo.com/docs/html/concept/629.html OmniMark v12 documentation]:<br> |
|||
<big>"</big> <small>Most programming languages allow programmers to store and manipulate values in arrays, associative arrays, queues, and stacks. Instead, OmniMark provides a data container called a shelf: a shelf can be used to accomplish all of the tasks normally carried out by these various structures in other programming languages. Like arrays, shelves can be indexed by numeric values that reflect the position of the elements they contain or, like associative arrays, these elements can be given names (keys) and then indexed by those keys.</small> <big>"</big> |
|||
<syntaxhighlight lang="omnimark"> |
|||
process |
|||
local stream s variable initial {"apple", "orange"} |
|||
local integer i initial {number of s} |
|||
put #main-output 'The number of fruit elements is %d(i).' |
|||
</syntaxhighlight> |
|||
'''Output:''' |
|||
<pre> |
|||
The number of fruit elements is 2. |
|||
</pre> |
|||
=={{header|Onyx}}== |
=={{header|Onyx}}== |
||
< |
<syntaxhighlight lang="onyx">[`apple' `orange'] length # leaves 2 on top of the stack</syntaxhighlight> |
||
=={{header|ooRexx}}== |
=={{header|ooRexx}}== |
||
< |
<syntaxhighlight lang="oorexx"> |
||
/* REXX */ |
/* REXX */ |
||
a = .array~of('apple','orange') |
a = .array~of('apple','orange') |
||
Line 1,025: | Line 2,354: | ||
say e |
say e |
||
End |
End |
||
Say "a[2]="a[2]</ |
Say "a[2]="a[2]</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>2 elements |
<pre>2 elements |
||
Line 1,033: | Line 2,362: | ||
=={{header|PARI/GP}}== |
=={{header|PARI/GP}}== |
||
< |
<syntaxhighlight lang="parigp">array = ["apple", "orange"] |
||
length(array) \\ == 2 |
length(array) \\ == 2 |
||
#array \\ == 2</ |
#array \\ == 2</syntaxhighlight> |
||
The <code>#</code> syntax is a handy shorthand. It usually looks best just on variables but it works on expressions too, possibly with parens to control precedence. |
The <code>#</code> syntax is a handy shorthand. It usually looks best just on variables but it works on expressions too, possibly with parens to control precedence. |
||
Line 1,045: | Line 2,374: | ||
{{works with|Free Pascal|2.6.2}} |
{{works with|Free Pascal|2.6.2}} |
||
<syntaxhighlight lang="pascal"> |
|||
<lang Pascal> |
|||
#!/usr/bin/instantfpc |
#!/usr/bin/instantfpc |
||
//program ArrayLength; |
//program ArrayLength; |
||
Line 1,060: | Line 2,389: | ||
WriteLn('Length of Fruits by bounds : ', High(Fruits) - Low(Fruits) + 1); |
WriteLn('Length of Fruits by bounds : ', High(Fruits) - Low(Fruits) + 1); |
||
END. |
END. |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
Line 1,068: | Line 2,397: | ||
Length of Fruits by bounds : 2 |
Length of Fruits by bounds : 2 |
||
</pre> |
|||
=={{header|PascalABC.NET}}== |
|||
<syntaxhighlight lang="pascal"> |
|||
// Array length. Nigel Galloway: September 2nd., 2022 |
|||
var n:array of string:=('apple','orange'); |
|||
begin |
|||
writeln(Length(n)); |
|||
end. |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2 |
|||
</pre> |
|||
Modern way: |
|||
<syntaxhighlight lang="pascal"> |
|||
// Array length. Mikhalkovich Stanislav: May 16, 2024 |
|||
## |
|||
var a := |'apple','orange'|; |
|||
a.Length.Print; |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2 |
|||
</pre> |
</pre> |
||
Line 1,074: | Line 2,428: | ||
The way to get the number of elements of an array in Perl is to put the array in scalar context. |
The way to get the number of elements of an array in Perl is to put the array in scalar context. |
||
< |
<syntaxhighlight lang="perl">my @array = qw "apple orange banana", 4, 42; |
||
scalar @array; # 5 |
scalar @array; # 5 |
||
Line 1,093: | Line 2,447: | ||
takes_a_scalar @array; |
takes_a_scalar @array; |
||
# the built-ins can also act like they have prototypes</ |
# the built-ins can also act like they have prototypes</syntaxhighlight> |
||
A common mistake is to use <code>length</code> which works on strings not arrays. |
A common mistake is to use <code>length</code> which works on strings not arrays. |
||
So using it on an array, as a side-effect, actually gives you a number which represents the order of magnitude. |
So using it on an array, as a side-effect, actually gives you a number which represents the order of magnitude. |
||
< |
<syntaxhighlight lang="perl">length '' . @array; # 1 |
||
length @array; # 1 |
length @array; # 1 |
||
Line 1,108: | Line 2,462: | ||
print 'the length of @array is on the order of '; |
print 'the length of @array is on the order of '; |
||
print 10 ** (length( @array )-1); # 100 |
print 10 ** (length( @array )-1); # 100 |
||
print " elements long\n";</ |
print " elements long\n";</syntaxhighlight> |
||
=={{header| |
=={{header|Phix}}== |
||
{{libheader|Phix/basics}} |
|||
{{works with|Rakudo|2015.12}} |
|||
<!--<syntaxhighlight lang="phix">--> |
|||
<span style="color: #008080;">constant</span> <span style="color: #000000;">fruits</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{<span style="color: #008000;">"apple"<span style="color: #0000FF;">,<span style="color: #008000;">"orange"<span style="color: #0000FF;">}</span> |
|||
To get the number of elements of an array in Perl 6 you put the array in a coercing Numeric context, or call <code>elems</code> on it. |
|||
<span style="color: #0000FF;">?<span style="color: #7060A8;">length<span style="color: #0000FF;">(<span style="color: #000000;">fruits<span style="color: #0000FF;">) |
|||
<!--</syntaxhighlight>--> |
|||
<lang perl6> |
|||
{{out}} |
|||
my @array = <apple orange banana>; |
|||
<pre> |
|||
2 |
|||
say @array.elems; # 3 |
|||
</pre> |
|||
say elems @array; # 3 |
|||
say +@array; # 3 |
|||
say @array + 1; # 4 |
|||
</lang> |
|||
Watch out for infinite/lazy arrays though. You can't get the length of those. |
|||
=={{header|Phixmonti}}== |
|||
<lang perl6>my @infinite = 1 .. Inf; # 1, 2, 3, 4, ... |
|||
<syntaxhighlight lang="phixmonti">"apple" "orange" stklen tolist len print</syntaxhighlight> |
|||
With syntactic sugar |
|||
say @infinite[5000]; # 5001 |
|||
<syntaxhighlight lang="phixmonti">include ..\Utilitys.pmt |
|||
say @infinite.elems; # Throws exception "Cannot .elems a lazy list" |
|||
( "apple" "orange" ) len print</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Phix}}== |
|||
<lang Phix>constant fruits = {"apple","orange"} |
|||
?length(fruits)</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 1,142: | Line 2,487: | ||
=={{header|PHP}}== |
=={{header|PHP}}== |
||
< |
<syntaxhighlight lang="php">print count(['apple', 'orange']); // Returns 2</syntaxhighlight> |
||
=={{header|Picat}}== |
|||
<syntaxhighlight lang="text">main => |
|||
L = ["apple", "orange"], |
|||
println(len(L))), |
|||
println(length(L)), |
|||
println(L.len), |
|||
println(L.length).</syntaxhighlight> |
|||
{{out}} |
|||
<pre>2 |
|||
2 |
|||
2 |
|||
2</pre> |
|||
=={{header|PicoLisp}}== |
=={{header|PicoLisp}}== |
||
< |
<syntaxhighlight lang="picolisp">: (length '(apple orange)) |
||
-> 2 |
-> 2 |
||
:</ |
:</syntaxhighlight> |
||
=={{header|Pike}}== |
=={{header|Pike}}== |
||
< |
<syntaxhighlight lang="pike">void main() |
||
{ |
{ |
||
array fruit = ({ "apple", "orange" }); |
array fruit = ({ "apple", "orange" }); |
||
write("%d\n", sizeof(fruit)); |
write("%d\n", sizeof(fruit)); |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 1,160: | Line 2,520: | ||
=={{header|PL/I}}== |
=={{header|PL/I}}== |
||
< |
<syntaxhighlight lang="pli"> p: Proc Options(main); |
||
Dcl a(2) Char(6) Init('apple','orange'); |
Dcl a(2) Char(6) Varying Init('apple','orange'); |
||
Put Edit('Array a has',(hbound(a)-lbound(a)+1),' elements.') |
Put Edit('Array a has',(hbound(a)-lbound(a)+1),' elements.') |
||
(Skip,a,f(2),a); |
(Skip,a,f(2),a); |
||
Put Skip Data(a); |
Put Skip Data(a); |
||
End;</ |
End;</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Array a has 2 elements. |
Array a has 2 elements. |
||
A(1)='apple |
A(1)='apple' A(2)='orange';</pre> |
||
=={{header|Plorth}}== |
|||
<syntaxhighlight lang="plorth">["apple", "orange"] length println</syntaxhighlight> |
|||
=={{header|Pony}}== |
|||
<syntaxhighlight lang="pony"> |
|||
actor Main |
|||
new create(env:Env)=> |
|||
var c=Array[String](2) |
|||
c.push("apple") |
|||
c.push("orange") |
|||
env.out.print("Array c is " + c.size().string() + " elements long!") |
|||
</syntaxhighlight> |
|||
=={{header|Potion}}== |
=={{header|Potion}}== |
||
< |
<syntaxhighlight lang="potion">("apple", "orange") length print</syntaxhighlight> |
||
=={{header|PowerShell}}== |
=={{header|PowerShell}}== |
||
<syntaxhighlight lang="powershell"> |
|||
<lang PowerShell> |
|||
$Array = @( "Apple", "Orange" ) |
$Array = @( "Apple", "Orange" ) |
||
$Array.Count |
$Array.Count |
||
$Array.Length</ |
$Array.Length</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
2 |
2 |
||
2</pre> |
2</pre> |
||
=={{header|Processing}}== |
|||
<syntaxhighlight lang="processing"> |
|||
String[] arr = {"apple", "orange"}; |
|||
void setup(){ |
|||
println(arr.length); |
|||
} |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2 |
|||
</pre> |
|||
==={{header|Processing Python mode}}=== |
|||
<syntaxhighlight lang="python"> |
|||
arr = ['apple', 'orange'] # a list for an array |
|||
def setup(): |
|||
println(len(arr)) |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2 |
|||
</pre> |
|||
=={{header|Prolog}}== |
=={{header|Prolog}}== |
||
< |
<syntaxhighlight lang="prolog">| ?- length(["apple", "orange"], X). |
||
X = 2 |
X = 2 |
||
yes</ |
yes</syntaxhighlight> |
||
=={{header|PureBasic}}== |
=={{header|PureBasic}}== |
||
<syntaxhighlight lang="purebasic"> |
|||
<lang PureBasic> |
|||
EnableExplicit |
EnableExplicit |
||
Define Dim fruit$(1); defines array with 2 elements at indices 0 and 1 |
Define Dim fruit$(1); defines array with 2 elements at indices 0 and 1 |
||
Line 1,205: | Line 2,603: | ||
CloseConsole() |
CloseConsole() |
||
EndIf |
EndIf |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
|||
<pre> |
|||
The length of the fruit array is 2 |
|||
</pre> |
|||
An abbreviated form of the above, not printing to console/terminal |
|||
<syntaxhighlight lang="purebasic"> |
|||
Dim fruit$(1); defines array with 2 elements at indices 0 and 1 |
|||
fruit$(0) = "apple" |
|||
fruit$(1) = "orange" |
|||
Debug ArraySize(fruit$()) + 1 ;the number of elements is equal to the size + 1. For example: Dim a(2) contains 3 elements from a(0) to a(2) for a size of 2. |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2 |
|||
</pre> |
|||
=={{header|Python}}== |
=={{header|Python}}== |
||
< |
<syntaxhighlight lang="python">>>> print(len(['apple', 'orange'])) |
||
2 |
2 |
||
>>> </ |
>>> </syntaxhighlight> |
||
=={{header|QB64}}== |
|||
<syntaxhighlight lang="qb64"> |
|||
Dim max As Integer, Index As Integer |
|||
Randomize Timer |
|||
max = Int(Rnd * 10) + 1 |
|||
Dim StringAr(1 To max) As String |
|||
For Index = 1 To max |
|||
If Int(Rnd * 6) + 1 <= 3 Then StringAr(Index) = "Apple" Else StringAr(Index) = "orange" |
|||
Next |
|||
Print UBound(Stringar) |
|||
End |
|||
</syntaxhighlight> |
|||
=={{header|Quackery}}== |
|||
<syntaxhighlight lang="quackery"> $ "apples" $ "oranges" 2 pack size echo</syntaxhighlight> |
|||
{{out}} |
|||
<pre>2</pre> |
|||
=={{header|R}}== |
=={{header|R}}== |
||
<syntaxhighlight lang="r"> |
|||
<lang R> |
|||
a <- c('apple','orange') # create a vector containing "apple" and "orange" |
a <- c('apple','orange') # create a vector containing "apple" and "orange" |
||
length(a) |
length(a) |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 1,224: | Line 2,660: | ||
=={{header|Racket}}== |
=={{header|Racket}}== |
||
{{trans|EchoLisp}} |
{{trans|EchoLisp}} |
||
< |
<syntaxhighlight lang="racket">#lang racket/base |
||
(length '("apple" "orange")) ;; list |
(length '("apple" "orange")) ;; list |
||
(vector-length #("apple" "orange")) ;; vector</ |
(vector-length #("apple" "orange")) ;; vector</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>2 |
<pre>2 |
||
2</pre> |
2</pre> |
||
=={{header|Raku}}== |
|||
(formerly Perl 6) |
|||
{{works with|Rakudo|2017.04}} |
|||
To get the number of elements of an array in Raku you put the array in a coercing Numeric context, or call <code>elems</code> on it. |
|||
<syntaxhighlight lang="raku" line> |
|||
my @array = <apple orange>; |
|||
say @array.elems; # 2 |
|||
say elems @array; # 2 |
|||
say + @array; # 2 |
|||
say @array + 0; # 2 |
|||
</syntaxhighlight> |
|||
Watch out for infinite/lazy arrays though. You can't get the length of those. |
|||
<syntaxhighlight lang="raku" line>my @infinite = 1 .. Inf; # 1, 2, 3, 4, ... |
|||
say @infinite[5000]; # 5001 |
|||
say @infinite.elems; # Throws exception "Cannot .elems a lazy list" |
|||
</syntaxhighlight> |
|||
=={{header|Rapira}}== |
|||
<syntaxhighlight lang="rapira">arr := <* "apple", "orange" *> |
|||
output: #arr</syntaxhighlight> |
|||
=={{header|REBOL}}== |
|||
<syntaxhighlight lang="rebol"> |
|||
>> length? ["apples" "oranges"] |
|||
== 2 |
|||
</syntaxhighlight> |
|||
=={{header|Red}}== |
|||
<syntaxhighlight lang="red">length? ["apples" "oranges"] |
|||
== 2</syntaxhighlight> |
|||
=={{header|Relation}}== |
|||
<syntaxhighlight lang="relation"> |
|||
relation fruit |
|||
insert "apples" |
|||
insert "oranges" |
|||
project fruit count |
|||
print |
|||
</syntaxhighlight> |
|||
{| border=1 |
|||
|- |
|||
! fruit_count |
|||
|- |
|||
| 2 |
|||
|} |
|||
=={{header|ReScript}}== |
|||
<syntaxhighlight lang="rescript">let fruits = ["apple", "orange"] |
|||
Js.log(Js.Array.length(fruits))</syntaxhighlight> |
|||
<syntaxhighlight lang="html"><!DOCTYPE html> |
|||
<html> |
|||
<head> |
|||
<title>ReScript: Array.length()</title> |
|||
<style rel="stylesheet" type="text/css"> |
|||
body { color:#EEE; background-color:#888; } |
|||
</style> |
|||
<script>var exports = {};</script> |
|||
<script src="./arrlen.js"></script> |
|||
</head> |
|||
<body> |
|||
</body> |
|||
</html></syntaxhighlight> |
|||
{{out}} |
|||
<pre>// Generated by ReScript, PLEASE EDIT WITH CARE |
|||
'use strict'; |
|||
var fruits = [ |
|||
"apple", |
|||
"orange" |
|||
]; |
|||
console.log(fruits.length); |
|||
exports.fruits = fruits; |
|||
/* Not a pure module */</pre> |
|||
=={{header|REXX}}== |
=={{header|REXX}}== |
||
< |
<syntaxhighlight lang="rexx">/* REXX ---------------------------------------------- |
||
* The compond variable a. implements an array |
* The compond variable a. implements an array |
||
* By convention, a.0 contains the number of elements |
* By convention, a.0 contains the number of elements |
||
Line 1,248: | Line 2,771: | ||
a.z=arg(1) |
a.z=arg(1) |
||
a.0=z |
a.0=z |
||
Return</ |
Return</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>There are 2 elements in the array: |
<pre>There are 2 elements in the array: |
||
Line 1,256: | Line 2,779: | ||
=={{header|Ring}}== |
=={{header|Ring}}== |
||
< |
<syntaxhighlight lang="python">See len(['apple', 'orange']) # output = 2 </syntaxhighlight> |
||
=={{header|Robotic}}== |
|||
As stated before in the [[Arrays#Robotic|arrays]] section on this Wiki, there is no functions listed for the manipulation/status of arrays. The best way we can count for length in an array is to have a variable keep track of it. |
|||
Example 1: |
|||
<syntaxhighlight lang="robotic"> |
|||
set "index" to 0 |
|||
set "$array&index&" to "apple" |
|||
inc "index" by 1 |
|||
set "$array&index&" to "orange" |
|||
* "Array length: ('index' + 1)" |
|||
</syntaxhighlight> |
|||
Example 2: |
|||
<syntaxhighlight lang="robotic"> |
|||
set "index" to 0 |
|||
set "local1" to random 1 to 99 |
|||
: "rand" |
|||
set "array&index&" to random 0 to 99 |
|||
inc "index" 1 |
|||
dec "local1" 1 |
|||
if "local1" > 1 then "rand" |
|||
* "Array length: ('index')" |
|||
</syntaxhighlight> |
|||
=={{header|RPL}}== |
|||
The <code>SIZE</code> instruction can be used for arrays (e.g. vectors) and lists. RPL arrays can only contain real or complex numbers, so we will use a list here. |
|||
{ "apple" "orange" } SIZE |
|||
{{out}} |
|||
<pre> |
|||
1: 2 |
|||
</pre> |
|||
=={{header|Ruby}}== |
=={{header|Ruby}}== |
||
< |
<syntaxhighlight lang="ruby">puts ['apple', 'orange'].length # or .size</syntaxhighlight> |
||
=={{header|Rust}}== |
=={{header|Rust}}== |
||
Line 1,266: | Line 2,821: | ||
By default arrays are immutable in rust. |
By default arrays are immutable in rust. |
||
< |
<syntaxhighlight lang="rust"> |
||
fn main() { |
fn main() { |
||
let array = ["foo", "bar", "baz", "biff"]; |
let array = ["foo", "bar", "baz", "biff"]; |
||
println!("the array has {} elements", array.len()); |
println!("the array has {} elements", array.len()); |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|S-BASIC}}== |
|||
Finding the size of an S-BASIC array at run-time is convoluted, to say the least, but it can be done. (It would also generally be pointless, since the size of an array is fixed - and thus presumably known - at compile time.) Each array has an associated data structure (referred to in the documentation as "SPEC") containing information such as the number of dimensions, the size of an array element, the size of each dimension, and so on. The address of the SPEC for an array can be obtained using the LOCATION statement. For a single-dimension array, the number of elements will be found five bytes into the structure, at a point described in the documentation as the "dope vector". |
|||
<syntaxhighlight lang = "BASIC"> |
|||
dim string animals(2) rem here is our array |
|||
var array_struct_address = integer |
|||
based array_size = integer |
|||
animals(1) = "ardvark" |
|||
animals(2) = "bison" |
|||
location spec array_struct_address = animals |
|||
base array_size at array_struct_address + 5 |
|||
print "Size of array ="; array_size |
|||
end |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Size of array = 2 |
|||
</pre> |
|||
=={{header|Scala}}== |
=={{header|Scala}}== |
||
< |
<syntaxhighlight lang="scala"> |
||
println(Array("apple", "orange").length) |
println(Array("apple", "orange").length) |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header| |
=={{header|Scheme}}== |
||
<lang haskell> |
|||
Using Scheme's vector type as an equivalent to an array: |
|||
arr := ["apple", "orange"]; |
|||
print(# arr); -- '#' is the cardinality operator. Works on strings, tuples, and sets. |
|||
<syntaxhighlight lang="scheme"> |
|||
</lang> |
|||
(display (vector-length #("apple" "orange"))) |
|||
</syntaxhighlight> |
|||
=={{header|Seed7}}== |
|||
The function [http://seed7.sourceforge.net/libraries/array.htm#length(in_arrayType) length] |
|||
determines the length of an array. |
|||
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i"; |
|||
const array string: anArray is [] ("apple", "orange"); |
|||
const proc: main is func |
|||
begin |
|||
writeln(length(anArray)); |
|||
end func;</syntaxhighlight> |
|||
=={{header|SenseTalk}}== |
|||
<syntaxhighlight lang="sensetalk">put ("apple", "orange", "pear", "banana", "aubergine") into fruits |
|||
put the number of items in fruits</syntaxhighlight> |
|||
=={{header|Shen}}== |
|||
<syntaxhighlight lang="shen"> |
|||
\\ Using a vector |
|||
\\ @v creates the vector |
|||
\\ <> ends the vector |
|||
\\ limit returns the length of a vector |
|||
\\ apple and orange are symbols (vs strings) in this case. |
|||
(limit (@v apple orange <>)) |
|||
\\ As an list |
|||
(length [apple orange]) |
|||
</syntaxhighlight> |
|||
=={{header|Sidef}}== |
=={{header|Sidef}}== |
||
< |
<syntaxhighlight lang="ruby">var arr = ['apple', 'orange']; |
||
say arr.len; #=> 2 |
say arr.len; #=> 2 |
||
say arr.end; #=> 1 (zero based)</ |
say arr.end; #=> 1 (zero based)</syntaxhighlight> |
||
=={{header| |
=={{header|Simula}}== |
||
<syntaxhighlight lang="simula">COMMENT ARRAY-LENGTH; |
|||
<lang smalltalk> |
|||
BEGIN |
|||
a := #('apple' 'orange'). |
|||
a size</lang> |
|||
INTEGER PROCEDURE ARRAYLENGTH(A); TEXT ARRAY A; |
|||
BEGIN |
|||
ARRAYLENGTH := UPPERBOUND(A, 1) - LOWERBOUND(A, 1) + 1; |
|||
END ARRAYLENGTH; |
|||
TEXT ARRAY A(1:2); |
|||
INTEGER L; |
|||
A(1) :- "APPLE"; |
|||
A(2) :- "ORANGE"; |
|||
L := ARRAYLENGTH(A); |
|||
OUTINT(L, 0); |
|||
OUTIMAGE; |
|||
END |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2 |
|||
</pre> |
|||
=={{heaer|Slope}}== |
|||
<syntaxhighlight lang="slope">(length ["apple" "orange"])</syntaxhighlight> |
|||
=={{header|SmallBASIC}}== |
|||
<syntaxhighlight lang="SmallBASIC"> |
|||
A = ["apple", "orange"] |
|||
print len(A) |
|||
</syntaxhighlight> |
|||
=={{header|Smalltalk}}== |
|||
<syntaxhighlight lang="smalltalk"> |
|||
a := #('apple' 'orange'). |
|||
a size</syntaxhighlight> |
|||
=={{header|SNOBOL4}}== |
=={{header|SNOBOL4}}== |
||
< |
<syntaxhighlight lang="snobol4"> ar = ARRAY('2,2') |
||
ar<1,1> = 'apple' |
ar<1,1> = 'apple' |
||
ar<1,2> = 'first' |
ar<1,2> = 'first' |
||
Line 1,304: | Line 2,943: | ||
ar<2,2> = 'second' |
ar<2,2> = 'second' |
||
OUTPUT = IDENT(DATATYPE(ar), 'ARRAY') PROTOTYPE(ar) |
OUTPUT = IDENT(DATATYPE(ar), 'ARRAY') PROTOTYPE(ar) |
||
end</ |
end</syntaxhighlight> |
||
{{out}}<pre>2,2</pre> |
{{out}}<pre>2,2</pre> |
||
=={{header|SPL}}== |
|||
<syntaxhighlight lang="spl">a = ["apple","orange"] |
|||
#.output("Number of elements in array: ",#.size(a,1))</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Number of elements in array: 2 |
|||
</pre> |
|||
=={{header|SQL}}== |
=={{header|SQL}}== |
||
< |
<syntaxhighlight lang="sql">SELECT COUNT() FROM (VALUES ('apple'),('orange'));</syntaxhighlight> |
||
=={{header|Standard ML}}== |
=={{header|Standard ML}}== |
||
< |
<syntaxhighlight lang="sml">let |
||
val a = Array.fromList ["apple", "orange"] |
val a = Array.fromList ["apple", "orange"] |
||
in |
in |
||
Array.length a |
Array.length a |
||
end;</ |
end;</syntaxhighlight> |
||
=={{header| |
=={{header|Stata}}== |
||
String data may be stored either in a Stata dataset or in a Mata matrix, not in a Stata matrix, which may hold only numeric data. A list of strings may also be stored in a Stata macro. |
|||
=== Dimensions of a dataset === |
|||
<lang Swift>import Cocoa //include Cocoa library (standard in OS X) |
|||
<syntaxhighlight lang="stata">clear |
|||
input str10 fruit |
|||
apple |
|||
orange |
|||
end |
|||
di _N |
|||
let fruits = ["apple", "orange"] //declare constant array literal |
|||
di c(N) " " c(k)</syntaxhighlight> |
|||
let fruitsCount = fruits.count //declare constant array length (count) |
|||
=== Length of a macro list === |
|||
print(fruitsCount) //print array length to output window</lang> |
|||
Use either the '''[https://www.stata.com/help.cgi?macrolists sizeof]''' macro list function or the '''[https://www.stata.com/help.cgi?extended_fcn word count]''' extended macro function. Notice that the argument of the former is the macro ''name'', while the argument of the latter is the macro ''contents''. |
|||
<syntaxhighlight lang="stata">local fruits apple orange |
|||
di `: list sizeof fruits' |
|||
di `: word count `fruits''</syntaxhighlight> |
|||
=== Mata === |
|||
For a Mata array, use '''[https://www.stata.com/help.cgi?mf_rows rows]''' and similar functions: |
|||
<syntaxhighlight lang="stata">mata |
|||
a=st_sdata(.,"fruit") |
|||
rows(a) |
|||
cols(a) |
|||
length(a) |
|||
end</syntaxhighlight> |
|||
=={{header|Swift}}== |
|||
<syntaxhighlight lang="swift">let fruits = ["apple", "orange"] // Declare constant array literal |
|||
let fruitsCount = fruits.count // Declare constant array length (count) |
|||
print(fruitsCount) // Print array length to output window</syntaxhighlight> |
|||
{{out}}<pre>2</pre> |
{{out}}<pre>2</pre> |
||
=={{header|Symsyn}}== |
|||
<syntaxhighlight lang="symsyn"> |
|||
| Symsyn does not support Array of Strings |
|||
| The following code for an Array of Integers |
|||
A : 125 0 |
|||
#A [] |
|||
| shows 125 |
|||
| A list of fixed length strings can be handled this way |
|||
S : 'apple ' : 'orange' |
|||
div #S 6 sz |
|||
sz [] |
|||
| shows 2 |
|||
</syntaxhighlight> |
|||
=={{header|Tailspin}}== |
|||
<syntaxhighlight lang="tailspin"> |
|||
['apple', 'orange'] -> $::length -> !OUT::write |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre>2</pre> |
|||
=={{header|Tcl}}== |
=={{header|Tcl}}== |
||
<!-- http://ideone.com/uotEvm --> |
<!-- http://ideone.com/uotEvm --> |
||
< |
<syntaxhighlight lang="tcl">;# not recommended: |
||
set mylistA {apple orange} ;# actually a string |
set mylistA {apple orange} ;# actually a string |
||
set mylistA "Apple Orange" ;# same - this works only for simple cases |
set mylistA "Apple Orange" ;# same - this works only for simple cases |
||
Line 1,344: | Line 3,044: | ||
set lenB [llength $mylistB] |
set lenB [llength $mylistB] |
||
puts "$mylistB : $lenB" |
puts "$mylistB : $lenB" |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
Line 1,353: | Line 3,053: | ||
{{works with|TI-83 2.55MP}} |
{{works with|TI-83 2.55MP}} |
||
Use function <code>dim()</code>. |
Use function <code>dim()</code>. |
||
< |
<syntaxhighlight lang="ti83b">{1,3,–5,4,–2,–1}→L1 |
||
dim(L1)</ |
dim(L1)</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
6 |
6 |
||
</pre> |
|||
=={{header|Transd}}== |
|||
<syntaxhighlight lang="scheme">#lang transd |
|||
MainModule : { |
|||
_start: (lambda |
|||
(with v ["apple", "orange"] |
|||
(lout (size v)) |
|||
) |
|||
(lout (size ["apple", "orange"])) |
|||
) |
|||
}</syntaxhighlight>{{out}} |
|||
<pre> |
|||
2 |
|||
2 |
|||
</pre> |
|||
=={{header|Uiua}}== |
|||
{{works with|Uiua|0.11.1}} |
|||
It would be more accurate to say this is the number of ''rows'' in an array. |
|||
<syntaxhighlight lang="uiua"> |
|||
⧻{"apple" "orange"} |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2 |
|||
</pre> |
|||
=={{header|UNIX Shell}}== |
|||
<syntaxhighlight lang="bash">#!/bin/bash |
|||
array=("orange" "apple") |
|||
echo "${#array[@]}"</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2 |
|||
</pre> |
</pre> |
||
Line 1,368: | Line 3,104: | ||
11 |
11 |
||
> </pre> |
> </pre> |
||
=={{header|Vala}}== |
|||
<syntaxhighlight lang="vala">void main() { |
|||
string[] fruit = {"apple", "orange"}; |
|||
stdout.printf("%d\n", fruit.length); |
|||
}</syntaxhighlight> |
|||
Note that any of the following array declarations could be used: |
|||
<syntaxhighlight lang="vala"> |
|||
var fruit = new string[] { "apple", "orange" }; |
|||
string[] fruit = new string[] { "apple", "orange" }; |
|||
string[] fruit = { "apple", "orange" }; |
|||
</syntaxhighlight> |
|||
A shorter variant could also have been used: |
|||
<syntaxhighlight lang="vala"> |
|||
void main() { |
|||
stdout.printf("%d\n", new string[] {"apples", "orange"}.length); |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|VBA}}== |
=={{header|VBA}}== |
||
One-liner. Assumes array lower bound, which is not always safe. |
|||
<lang vb>Debug.Print "Array Length: " & UBound(Array("apple", "orange")) + 1</lang> |
|||
<syntaxhighlight lang="vb">Debug.Print "Array Length: " & UBound(Array("apple", "orange")) + 1</syntaxhighlight> |
|||
Works regardless of lower bound: |
|||
<syntaxhighlight lang="vb">Dim funkyArray(7 to 8) As String |
|||
Public Function SizeOfArray(ar As Variant) As Long |
|||
SizeOfArray = UBound(ar) - LBound(ar) + 1 |
|||
End Function |
|||
'call the function |
|||
Debug.Print "Array Length: " & SizeOfArray(funkyArray)</syntaxhighlight> |
|||
{{Out}} |
{{Out}} |
||
In this instance, same output for both. |
|||
<pre>Array Length: 2</pre> |
<pre>Array Length: 2</pre> |
||
=={{header|VBScript}}== |
=={{header|VBScript}}== |
||
< |
<syntaxhighlight lang="vb">arr = Array("apple","orange") |
||
WScript.StdOut.WriteLine UBound(arr) + 1</ |
WScript.StdOut.WriteLine UBound(arr) - LBound(arr) + 1 </syntaxhighlight> |
||
{{Out}} |
{{Out}} |
||
<pre>2</pre> |
<pre>2</pre> |
||
=={{header|Visual Basic}}== |
|||
The amount of elements in an array in Visual Basic is computed via the upper bound and lower bound indices. In Visual Basic the indices of arrays have to be numeric, but it is even possible to have negative values for them. Of course the element numbering is continuous. |
|||
<syntaxhighlight lang="vb"> |
|||
' declared in a module |
|||
Public Function LengthOfArray(ByRef arr As Variant) As Long |
|||
If IsArray(arr) Then |
|||
LengthOfArray = UBound(arr) - LBound(arr) + 1 |
|||
Else |
|||
LengthOfArray = -1 |
|||
End If |
|||
End Function |
|||
' somewhere in the programm |
|||
' example 1 |
|||
Dim arr As Variant |
|||
arr = Array("apple", "orange") |
|||
Debug.Print LengthOfArray(arr) ' prints 2 as result |
|||
' example 2 |
|||
Dim arr As Variant |
|||
ReDim arr(-2 To -1) |
|||
arr(-2) = "apple" |
|||
arr(-1) = "orange" |
|||
Debug.Print LengthOfArray(arr) ' prints 2 as result |
|||
</syntaxhighlight> |
|||
=={{header|Visual Basic .NET}}== |
|||
{{works with|Visual Basic .NET|9.0+}} |
|||
<syntaxhighlight lang="vbnet">Module ArrayLength |
|||
Sub Main() |
|||
Dim array() As String = {"apple", "orange"} |
|||
Console.WriteLine(array.Length) |
|||
End Sub |
|||
End Module |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2 |
|||
</pre> |
|||
=={{header|V (Vlang)}}== |
|||
A '''len''' property is maintained for all V (Vlang) arrays. |
|||
<syntaxhighlight lang="go">// V, array length |
|||
// Tectonics: v run array-length.v |
|||
module main |
|||
// access array length |
|||
pub fn main() { |
|||
arr := ["apple", "orange"] |
|||
println(arr.len) |
|||
}</syntaxhighlight> |
|||
{{out}}<pre>prompt$ v run array-length.v |
|||
2</pre> |
|||
=={{header|WDTE}}== |
|||
<syntaxhighlight lang="wdte">let io => import 'io'; |
|||
let a => ['apple'; 'orange']; |
|||
len a -- io.writeln io.stdout;</syntaxhighlight> |
|||
=={{header|Wren}}== |
=={{header|Wren}}== |
||
< |
<syntaxhighlight lang="wren">var arr = ["apple", "orange"] |
||
System.print(arr.count)</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
|||
<pre> |
|||
2 |
|||
</pre> |
|||
=={{header|XLISP}}== |
=={{header|XLISP}}== |
||
< |
<syntaxhighlight lang="lisp">(vector-length #("apple" "orange"))</syntaxhighlight> |
||
=={{header|Yabasic}}== |
|||
<syntaxhighlight lang="yabasic"> |
|||
dim fruta$(3) |
|||
read fruta$(1), fruta$(2), fruta$(3) |
|||
data "apple", "orange", "pear" |
|||
print arraysize(fruta$(),1) |
|||
print fruta$(2) |
|||
end |
|||
</syntaxhighlight> |
|||
<pre> |
|||
3 |
|||
orange |
|||
</pre> |
|||
=={{header|Z80 Assembly}}== |
|||
Arrays don't have an "end" as defined by the language, so there are a couple ways to mark the end of an array. One is with a null terminator, and the other is with a pre-defined size byte stored at the beginning. Using a null terminator isn't the best choice for a general-purpose array since it means your array cannot contain that value anywhere except at the end. However, since having the size already determined defeats the purpose of this task, the null-terminator method will be used for this example. |
|||
The simplest way to implement an array of variable-length strings is to have the array contain pointers to said strings rather than the strings themselves. That way, the elements of the array are of equal length, which makes any array <b>much</b> easier to work with. |
|||
<syntaxhighlight lang="z80"> org &8000 |
|||
ld hl,TestArray |
|||
call GetArrayLength_WordData_NullTerminated |
|||
call Monitor ;show registers to screen, code omitted to keep this example short |
|||
ReturnToBasic: |
|||
RET |
|||
GetArrayLength_WordData_NullTerminated: |
|||
push hl ;we'll need this later |
|||
loop_GetArrayLength_WordData_NullTerminated |
|||
ld a,(hl) ;get the low byte |
|||
ld e,a ;stash it in E |
|||
inc hl ;next byte |
|||
ld a,(hl) ;get the high byte |
|||
dec hl ;go back to low byte, otherwise our length will be off. |
|||
or a ;compare to zero. This is a shorter and faster way to compare A to zero than "CP 0" |
|||
jr nz,keepGoing |
|||
cp e ;compare to E |
|||
jr z,Terminated_GetArrayLength ;both bytes were zero. |
|||
KeepGoing: |
|||
inc hl |
|||
inc hl ;next word |
|||
jp loop_GetArrayLength_WordData_NullTerminated ;back to start |
|||
Terminated_GetArrayLength: |
|||
pop de ;original array address is in DE |
|||
;or a ;normally it's best to clear the carry, but in this situation execution only arrives here after a compare that |
|||
;resulted in an equality to zero, which means the carry is guaranteed to be cleared. |
|||
sbc hl,de ;there is no sub hl,de; only sbc |
|||
srl h |
|||
rr l ;divide HL by 2, since each element is 2 bytes. |
|||
ret ;returns length in hl |
|||
TestArray: |
|||
word Apple,Orange |
|||
byte 0,0 |
|||
Apple: |
|||
byte "Apple",0 |
|||
Orange: |
|||
byte "Orange",0</syntaxhighlight> |
|||
{{out}} |
|||
<pre>(HL contains length of the array) |
|||
HL:0002 |
|||
</pre> |
|||
=={{header|zkl}}== |
=={{header|zkl}}== |
||
zkl doesn't support arrays natively, use lists instead. |
zkl doesn't support arrays natively, use lists instead. |
||
< |
<syntaxhighlight lang="zkl">List("apple", "orange").len().println() //-->2, == L("apple", "orange") |
||
T("apple", "orange").len().println() //-->2, read only list (ROList) </ |
T("apple", "orange").len().println() //-->2, read only list (ROList) </syntaxhighlight> |
||
=={{header|Zig}}== |
|||
<syntaxhighlight lang="zig">const std = @import("std"); |
|||
pub fn main() !void { |
|||
// left hand side type can be ommitted |
|||
const fruit: [2][]const u8 = [_][]const u8{ "apples", "oranges" }; |
|||
const stdout_wr = std.io.getStdOut().writer(); |
|||
// slices and arrays have an len field |
|||
try stdout_wr.print("fruit.len = {d}\n", .{fruit.len}); |
|||
}</syntaxhighlight> |
|||
=={{header|Zoea}}== |
|||
<syntaxhighlight lang="zoea"> |
|||
program: array_length |
|||
input: [a,b,c] |
|||
output: 3 |
|||
</syntaxhighlight> |
|||
=={{header|Zoea Visual}}== |
|||
[http://zoea.co.uk/examples/zv-rc/Array_length.png Array Length] |
|||
=={{header|zonnon}}== |
|||
<syntaxhighlight lang="zonnon"> |
|||
module AryLength; |
|||
type |
|||
Vector = array 12 of string; |
|||
Matrix = array *,* of string; |
|||
var |
|||
a: Vector; |
|||
b: Matrix; |
|||
begin |
|||
writeln(len(a):4); (* len(a) = len(a,0) *) |
|||
b := new Matrix(10,11); |
|||
writeln(len(b,0):4); (* first dimension *) |
|||
writeln(len(b,1):4) (* second dimension *) |
|||
end AryLength. |
|||
</syntaxhighlight> |
Latest revision as of 03:06, 29 June 2024
![Task](http://static.miraheze.org/rosettacodewiki/thumb/b/ba/Rcode-button-task-crushed.png/64px-Rcode-button-task-crushed.png)
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
Determine the amount of elements in an array.
As an example use an array holding the strings 'apple' and 'orange'.
- Metrics
- Counting
- Word frequency
- Letter frequency
- Jewels and stones
- I before E except after C
- Bioinformatics/base count
- Count occurrences of a substring
- Count how many vowels and consonants occur in a string
- Remove/replace
- XXXX redacted
- Conjugate a Latin verb
- Remove vowels from a string
- String interpolation (included)
- Strip block comments
- Strip comments from a string
- Strip a set of characters from a string
- Strip whitespace from a string -- top and tail
- Strip control codes and extended characters from a string
- Anagrams/Derangements/shuffling
- Word wheel
- ABC problem
- Sattolo cycle
- Knuth shuffle
- Ordered words
- Superpermutation minimisation
- Textonyms (using a phone text pad)
- Anagrams
- Anagrams/Deranged anagrams
- Permutations/Derangements
- Find/Search/Determine
- ABC words
- Odd words
- Word ladder
- Semordnilap
- Word search
- Wordiff (game)
- String matching
- Tea cup rim text
- Alternade words
- Changeable words
- State name puzzle
- String comparison
- Unique characters
- Unique characters in each string
- Extract file extension
- Levenshtein distance
- Palindrome detection
- Common list elements
- Longest common suffix
- Longest common prefix
- Compare a list of strings
- Longest common substring
- Find common directory path
- Words from neighbour ones
- Change e letters to i in words
- Non-continuous subsequences
- Longest common subsequence
- Longest palindromic substrings
- Longest increasing subsequence
- Words containing "the" substring
- Sum of the digits of n is substring of n
- Determine if a string is numeric
- Determine if a string is collapsible
- Determine if a string is squeezable
- Determine if a string has all unique characters
- Determine if a string has all the same characters
- Longest substrings without repeating characters
- Find words which contains all the vowels
- Find words which contain the most consonants
- Find words which contains more than 3 vowels
- Find words whose first and last three letters are equal
- Find words with alternating vowels and consonants
- Formatting
- Substring
- Rep-string
- Word wrap
- String case
- Align columns
- Literals/String
- Repeat a string
- Brace expansion
- Brace expansion using ranges
- Reverse a string
- Phrase reversals
- Comma quibbling
- Special characters
- String concatenation
- Substring/Top and tail
- Commatizing numbers
- Reverse words in a string
- Suffixation of decimal numbers
- Long literals, with continuations
- Numerical and alphabetical suffixes
- Abbreviations, easy
- Abbreviations, simple
- Abbreviations, automatic
- Song lyrics/poems/Mad Libs/phrases
- Mad Libs
- Magic 8-ball
- 99 bottles of beer
- The Name Game (a song)
- The Old lady swallowed a fly
- The Twelve Days of Christmas
- Tokenize
- Text between
- Tokenize a string
- Word break problem
- Tokenize a string with escaping
- Split a character string based on change of character
- Sequences
11l
print([‘apple’, ‘orange’].len)
- Output:
2
360 Assembly
Array length is computed at compilation time with the formula : (AEND-A)/L'A
* Array length 22/02/2017
ARRAYLEN START
USING ARRAYLEN,12
LR 12,15 end of prolog
LA 1,(AEND-A)/L'A hbound(a)
XDECO 1,PG+13 edit
XPRNT PG,L'PG print
BR 14 exit
A DC CL6'apple',CL6'orange' array
AEND DC 0C
PG DC CL25'Array length=' buffer
END ARRAYLEN
- Output:
Array length= 2
6502 Assembly
Array length is computed at compilation time with the formula: (Array_End-Array). Even though the labels Array and Array_End are both 16-bit values, if their difference fits into 8 bits the assembler will allow you to load it into a register.
start:
LDA #(Array_End-Array) ;evaluates to 13
RTS
Array:
byte "apple",0
byte "orange",0
Array_End:
68000 Assembly
Array length is computed at compilation time with the formula: (Array_End-Array). The "bit width" of this value is the bit width of the result, not the bit width of the inputs. In other words, even though code labels are 32-bit memory addresses, if their difference is 8 or 16-bit you can use a .B
or .W
instruction or directive on them without a compile-time error.
The biggest limitation to the (Array_End-Array) method is that it always measures in total bytes. So if your array elements are of a different type you'll have to adjust accordingly. For an array strings, you should instead construct an array of pointers to strings and divide the result of the difference by 4 to get the total number of "strings" in the array.
start:
MOVE.B #(MyArray_End-MyArray)/4 ;evaluates to 2
RTS
Apple:
DC.B "apple",0
even
Orange:
DC.B "orange",0
even
MyArray:
DC.L Apple
DC.L Orange
MyArray_End:
8th
["apples", "oranges"] a:len . cr
- Output:
2
AArch64 Assembly
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program lenAreaString64.s */
/*******************************************/
/* Constantes file */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
/*******************************************/
/* Initialized data */
/*******************************************/
.data
szMessLenArea: .asciz "The length of area is : @ \n"
szCarriageReturn: .asciz "\n"
/* areas strings */
szString1: .asciz "Apples"
szString2: .asciz "Oranges"
/* pointer items area */
tablesPoi:
ptApples: .quad szString1
ptOranges: .quad szString2
ptVoid: .quad 0
/*******************************************/
/* UnInitialized data */
/*******************************************/
.bss
sZoneConv: .skip 30
/*******************************************/
/* code section */
/*******************************************/
.text
.global main
main: // entry of program
ldr x1,qAdrtablesPoi // begin pointer table
mov x0,0 // counter
1: // begin loop
ldr x2,[x1,x0,lsl 3] // read string pointer address item x0 (8 bytes by pointer)
cmp x2,0 // is null ?
cinc x0,x0,ne // no increment counter
bne 1b // and loop
ldr x1,qAdrsZoneConv // conversion decimal
bl conversion10S
ldr x0,qAdrszMessLenArea
ldr x1,qAdrsZoneConv
bl strInsertAtCharInc // insert result at @ character
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 call
qAdrtablesPoi: .quad tablesPoi
qAdrszMessLenArea: .quad szMessLenArea
qAdrsZoneConv: .quad sZoneConv
qAdrszCarriageReturn: .quad szCarriageReturn
/********************************************************/
/* File Include fonctions */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
ABAP
The concept of arrays does not exist in ABAP, instead internal tables are used. Since ABAP Version 7.40 they can be accessed with the common index notation. Note that the index starts at 1 and out of bound access raises an exception. The built-in function "lines" returns the number of records.
report z_array_length.
data(internal_table) = value stringtab( ( `apple` ) ( `orange` ) ).
write: internal_table[ 1 ] , internal_table[ 2 ] , lines( internal_table ).
- Output:
apple orange 2
Ada
with Ada.Text_IO; use Ada.Text_IO;
with System;
procedure Array_Length is
Fruits : constant array (Positive range <>) of access constant String
:= (new String'("orange"),
new String'("apple"));
Memory_Size : constant Integer := Fruits'Size / System.Storage_Unit;
begin
Put_Line ("Number of elements : " & Fruits'Length'Image);
Put_Line ("Array memory Size : " & Memory_Size'Image & " bytes" );
Put_Line (" " & Integer'Image (Memory_Size * System.Storage_Unit / System.Word_Size) & " words" );
end Array_Length;
- Output:
Number of elements : 2 Array memory Size : 32 bytes 4 words
ALGOL 68
# UPB returns the upper bound of an array, LWB the lower bound #
[]STRING fruits = ( "apple", "orange" );
print( ( ( UPB fruits - LWB fruits ) + 1, newline ) ) # prints 2 #
AntLang
array: seq["apple"; "orange"]
length[array]
/Works as a one liner: length[seq["apple"; "orange"]]
Apex
System.debug(new String[] { 'apple', 'banana' }.size()); // Prints 2
APL
⍴'apple' 'orange'
Output:
2
AppleScript
set theList to {"apple", "orange"}
count theList
-- or
length of theList
-- or
number of items in theList
Strictly speaking, 'items in' can be omitted from the last example, since 'number of' does essentially the same as 'length of'. The additional stage of extracting theList's 'items' is inefficient.
- Output:
2
No context or goal is provided for this task – sometimes for example, we may simply want to take the last member of an array, and counting the length to derive an index might well not be the best route.
More generally, we may learn more about AppleScript by defining length() ourselves. There are two basic functional approaches to doing that – we can write a simple recursive definition, or, if we have a higher order fold/reduce function (see Catamorphism) we can derive length() as:
fold (λx n -> 1 + n) 0
on run
set xs to ["alpha", "beta", "gamma", "delta", "epsilon", ¬
"zeta", "eta", "theta", "iota", "kappa", "lambda", "mu"]
{_length(xs), fold(xs, succ, 0), item 12 of xs, item -1 of xs}
--> {12, 12, "mu", "mu"}
end run
-- TWO FUNCTIONAL DEFINITIONS OF LENGTH
-- 1. Recursive definition
on _length(xs)
if xs is [] then
0
else
1 + _length(rest of xs)
end if
end _length
-- 2. fold (λx n -> 1 + n) 0
on succ(x)
1 + x
end succ
--[a] - > (a - > b) - > b - > [b]
on fold(xs, f, startValue)
script mf
property lambda : f
end script
set v to startValue
repeat with x in xs
set v to mf's lambda(v, x)
end repeat
end fold
- Output:
{12, 12, "mu", "mu"}
ARM Assembly
/* ARM assembly Raspberry PI */
/* program lenAreaString.s */
/* Constantes */
.equ STDOUT, 1 @ Linux output console
.equ EXIT, 1 @ Linux syscall
.equ WRITE, 4 @ Linux syscall
/* Initialized data */
.data
szMessLenArea: .ascii "The length of area is : "
sZoneconv: .fill 12,1,' '
szCarriageReturn: .asciz "\n"
/* areas strings */
szString1: .asciz "Apples"
szString2: .asciz "Oranges"
/* pointer items area */
tablesPoi:
ptApples: .int szString1
ptOranges: .int szString2
ptVoid: .int 0
/* UnInitialized data */
.bss
/* code section */
.text
.global main
main: /* entry of program */
push {fp,lr} /* saves 2 registers */
ldr r1,iAdrtablesPoi @ begin pointer table
mov r0,#0 @ counter
1: @ begin loop
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
ldr r1,iAdrsZoneconv @ conversion decimal
bl conversion10S
ldr r0,iAdrszMessLenArea
bl affichageMess
2:
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 call
iAdrtablesPoi: .int tablesPoi
iAdrszMessLenArea: .int szMessLenArea
iAdrsZoneconv: .int sZoneconv
iAdrszCarriageReturn: .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
fruit: ["apple" "orange"]
print ["array length =" size fruit]
- Output:
array length = 2
ATS
#include
"share/atspre_staload.hats"
#include
"share/atspre_staload_libats_ML.hats"
val A0 =
array0_tuple<string>
( "apple", "orange" )
val () =
println!("length(A0) = ", length(A0))
implement main0((*void*)) = ((*void*))
AutoHotkey
MsgBox % ["apple","orange"].MaxIndex()
- Output:
2
AutoIt
Opt('MustDeclareVars',1) ; 1 = Variables must be pre-declared.
Local $aArray[2] = ["Apple", "Orange"]
Local $Max = UBound($aArray)
ConsoleWrite("Elements in array: " & $Max & @CRLF)
For $i = 0 To $Max - 1
ConsoleWrite("aArray[" & $i & "] = '" & $aArray[$i] & "'" & @CRLF)
Next
- Output:
Elements in array: 2 aArray[0] = 'Apple' aArray[1] = 'Orange'
Avail
Using Avail's tuples and the `|_|` method:
|<"Apple", "Orange">|
AWK
The main use of the length()-function is to determine the length of a string.
When used on an array, it returns the number of elements.
Another method to count the elements of the array is by using a variant of for().
# usage: awk -f arraylen.awk
#
function countElements(array) {
for( e in array ) {c++}
return c
}
BEGIN {
array[1] = "apple"
array[2] = "orange"
print "Array length :", length(array), countElements(array)
print "String length:", array[1], length(array[1])
}
- Output:
Array length : 2 2 String length: apple 5
BaCon
BaCon knows three types of arrays, the UBOUND function can query all.
' Static arrays
DECLARE fruit$[] = { "apple", "orange" }
PRINT UBOUND(fruit$)
' Dynamic arrays
DECLARE vegetable$ ARRAY 2
vegetable$[0] = "cabbage"
vegetable$[1] = "spinach"
PRINT UBOUND(vegetable$)
' Associative arrays
DECLARE meat$ ASSOC STRING
meat$("first") = "chicken"
meat$("second") = "pork"
PRINT UBOUND(meat$)
Bash
fruit=("apple" "orange" "lemon")
echo "${#fruit[@]}"
BASIC
DIM X$(1 TO 2)
X$(1) = "apple"
X$(2) = "orange"
PRINT UBOUND(X$) - LBOUND(X$) + 1
Applesoft BASIC
10 DIM A$(2)
20 A$(1) = "ORANGE"
30 A$(2) = "APPLE"
40 N$ = "A$": GOSUB 70: PRINT L$
60 PRINT
61 DIM A%(19,63,0),A3(4,5)
62 N$ = "A%": GOSUB 70: PRINT L$
63 N$ = "A3": GOSUB 70: PRINT L$
64 N$ = "COMMODORE"
65 GOSUB 70: PRINT L$: END
70 L$ = "":N0 = 0:N1 = 0
71 N0$ = LEFT$ (N$,1)
72 N1$ = MID$ (N$,2,2)
73 N1 = RIGHT$ (N$,1) = "$"
74 N0 = RIGHT$ (N$,1) = "%"
75 IF N0 THEN N1 = 1
76 I = LEN (N1$) - N1
77 N1$ = MID$ (N1$,1,I)
78 A = ASC (N1$ + CHR$ (0))
79 N1 = 128 * N1 + A
80 N0 = 128 * N0 + ASC (N0$)
90 DEF FN P(A) = PEEK (A) + PEEK (A + 1) * 256
100 I = FN P(109):A = FN P(107)
110 FOR A = A TO I STEP 0
128 IF PEEK (A) < > N0 OR PEEK (A + 1) < > N1 THEN A = A + FN P(A + 2): NEXT A: PRINT "ARRAY "N$" NOT FOUND": STOP
130 N0 = A + 4
140 N1 = N0 + FN P(N0) * 2
150 N0 = N0 + 2
160 FOR I = N1 TO N0 STEP - 2
170 L$ = L$ + STR$ ( FN P(I))
180 L$ = L$ + " ": NEXT I
190 RETURN
BASIC256
fruta$ = {"apple", "orange", "pear"}
print length(fruta$)
print fruta$[?]
print fruta$[1]
end
3 3 orange
Chipmunk Basic
Unless modified with OPTION BASE 1 or MAT ORIGIN 1, the lower limit of an array is 1.
10 dim fruta$(2)
20 read fruta$(0),fruta$(1),fruta$(2)
30 data "apple","orange","lemon"
40 print "The length of the array 'fruit$' is ";ubound(fruta$)+1
50 end
Commodore BASIC
Commodore BASIC has no way within the language to query an array for its length, but you can dive into the implementation to get that information. On a C-64 in particular, this works:
10 DIM A$(1):REM 1=LAST -> ROOM FOR 2
20 A$(0) = "ORANGE"
30 A$(1) = "APPLE"
40 AT=0:N$="":T=0:L=0:REM DECLARE ALL VARS BEFORE PEEKING
50 AT=PEEK(47)+256*PEEK(48):REM START OF ARRAYS IN MEMORY
60 N$=CHR$(PEEK(AT)AND127)+CHR$(PEEK(AT+1)AND127):REM NAME
70 T=(PEEK(AT) AND 128)*2+(PEEK(AT+1)AND128):REM TYPE
80 IF T=384 THEN N$=N$+"%": REM INTEGER
90 IF T=128 THEN N$=N$+"$": REM STRING
100 L=PEEK(AT+6): REM FIRST INDEX SIZE
110 PRINT N$" HAS"L"ELEMENTS."
- Output:
A$ HAS 2 ELEMENTS.
IS-BASIC
100 STRING X$(1 TO 2)
110 LET X$(1)="apple":LET X$(2)="orange"
120 PRINT "The length of the array 'X$' is";SIZE(X$)
True BASIC
DIM fruta$(2)
READ fruta$(1), fruta$(2)
DATA "apple", "orange"
LET tamano = UBound(fruta$) - LBound(fruta$) + 1
PRINT "La longitud del array fruta$ es" ; tamano
END
- Output:
La longitud del array fruta$ es 2
True BASIC's arrays are not fixed in length and, although True BASIC is a compiled-language, the number of elements can be changed during runtime using such functions as the MAT REDIM (matrix re-dimension) function. Although the starting index of 1 is in implicit, it can be changed by setting the lower and upper bounds (eg. fruit(0 to 3)) when declaring the array. Also, the example below uses the MAT READ function to read in the data elements into the array without having to explicitly list each variable-array index. The example also uses the SIZE function vs the bounds method to determine the length of the array. Finally, in this example the SIZE function was not assigned to a separate variable and instead is used within the PRINT function itself.
DIM fruit$(2)
MAT READ fruit$
DATA "apple", "orange"
PRINT "The length of the array 'fruit$' is "; SIZE(fruit$)
END
- Output:
The length of the array 'fruit$' is 2
XBasic
PROGRAM "Array length"
VERSION "0.0000"
DECLARE FUNCTION Entry ()
FUNCTION Entry ()
DIM F$[2]
F$[0] = "apple"
F$[1] = "orange"
F$[2] = "pear"
PRINT "The length of the fruit array is "; UBOUND(F$[])
PRINT F$[1]
END FUNCTION
END PROGRAM
- Output:
The length of the fruit array is 2 orange
Batch File
While batch files don't support arrays in the traditional sense, sets of variables forming somewhat of a pseudo-array are extremely useful. They are usually in the form of %name{number}%
. The below code gives an example of how to create an array from a list stored in a variable, and how to acquire the amount of entries in the array.
@echo off
:_main
setlocal enabledelayedexpansion
:: This block of code is putting a list delimitered by spaces into an pseudo-array
:: In practice, this could be its own function _createArray however for the demonstration, it is built in
set colour_list=red yellow blue orange green
set array_entry=0
for %%i in (%colour_list%) do (
set /a array_entry+=1
set colours[!array_entry!]=%%i
)
call:_arrayLength colours
echo _arrayLength returned %errorlevel%
pause>nul
exit /b
:: _arrayLength returns the length of the array parsed to it in the errorcode
:_arrayLength
setlocal enabledelayedexpansion
:loop
set /a arrayentry=%arraylength%+1
if "!%1[%arrayentry%]!"=="" exit /b %arraylength%
set /a arraylength+=1
goto loop
- Input:
red yellow blue orange green
- Output:
_arrayLength returned 5
BBC BASIC
DIM array$(1)
array$() = "apple", "orange"
PRINT "Number of elements in array = "; DIM(array$(), 1) + 1
PRINT "Number of bytes in all elements combined = "; SUMLEN(array$())
END
- Output:
Number of elements in array = 2 Number of bytes in all elements combined = 11
Beef
using System;
namespace ArrayLength
{
class Program
{
public static void Main()
{
var array = new String[]("apple", "orange");
Console.WriteLine(array.Count);
delete(array);
}
}
}
Brat
p ["apple", "orange"].length
Binary Lambda Calculus
BLC has no arrays, so here's a function to compute the length of a given list (as a church numeral) instead, corresponding to https://github.com/tromp/AIT/blob/master/lists/length.lam :
010001101000000101100000000000011100101010111111110111111101111011010000010
BQN
≠
gives the length of an array in BQN.
≠ 1‿"a"‿+
3
C
A commonly used solution
C features two kinds of arrays: static (compile-time, fixed size) and dynamic (allocated at runtime).
The length of a dynamic array cannot be acquired from the array itself - its length must be stored elsewhere.
For static arrays:
#include <stdio.h>
int main()
{
const char *fruit[2] = { "apples", "oranges" };
// Acquire the length of the array by dividing the size of all elements (found
// with sizeof(fruit)) by the size of the first element.
// Note that since the array elements are pointers to null-terminated character
// arrays, the size of the first element is actually the size of the pointer
// type - not the length of the string.
// This size, regardless of the type being pointed to, is 8 bytes, 4 bytes, or
// 2 bytes on 64-bit, 32-bit, or 16-bit platforms respectively.
int length = sizeof(fruit) / sizeof(fruit[0]);
printf("%d\n", length);
return 0;
}
A C pre-processor macro may be created for ease of use:
#define ARRAY_LENGTH(A) (sizeof(A) / sizeof(A[0]))
Note that these arrays become pointers when passed as a parameter to a function. Thus, the length of an array parameter may not be required directly - a dedicated length parameter would be required.
Safe solution
The C language uses arrays of a declared size (including variable length arrays, i.e. VLA) and dynamically allocated memory blocks. While they are mostly the same, it is important that the sizeof operator, which returns a number of bytes, behaves quite differently for arrays and for memory pointers.
The problem is that arrays are passed to functions (procedures) via pointers. Even if we define a global variable as an array, after using it as a function argument the appropriate parameter will "forget" what size the array is.
Therefore, an object-oriented technique is used in the solution below. (This is possible even with standard C, i.e. C without ++.) Block of memory in which is stored the array is wrapped in structure and thus the size of the array can be easily stored. It is very convenient. Having defined such "classes" as StringArray, their use is easy and hassle-free. Nevertheless, the C language is not designed for OOP, and therefore C ++ is simply better for these kinds of applications.
Solution
#define _CRT_SECURE_NO_WARNINGS // turn off panic warnings
#define _CRT_NONSTDC_NO_WARNINGS // enable old-gold POSIX names in MSVS
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
struct StringArray
{
size_t sizeOfArray;
size_t numberOfElements;
char** elements;
};
typedef struct StringArray* StringArray;
StringArray StringArray_new(size_t size)
{
StringArray this = calloc(1, sizeof(struct StringArray));
if (this)
{
this->elements = calloc(size, sizeof(int));
if (this->elements)
this->sizeOfArray = size;
else
{
free(this);
this = NULL;
}
}
return this;
}
void StringArray_delete(StringArray* ptr_to_this)
{
assert(ptr_to_this != NULL);
StringArray this = (*ptr_to_this);
if (this)
{
for (size_t i = 0; i < this->sizeOfArray; i++)
free(this->elements[i]);
free(this->elements);
free(this);
this = NULL;
}
}
void StringArray_add(StringArray this, ...)
{
char* s;
va_list args;
va_start(args, this);
while (this->numberOfElements < this->sizeOfArray && (s = va_arg(args, char*)))
this->elements[this->numberOfElements++] = strdup(s);
va_end(args);
}
int main(int argc, char* argv[])
{
StringArray a = StringArray_new(10);
StringArray_add(a, "apple", "orange", NULL);
printf(
"There are %d elements in an array with a capacity of %d elements:\n\n",
a->numberOfElements, a->sizeOfArray);
for (size_t i = 0; i < a->numberOfElements; i++)
printf(" the element %d is the string \"%s\"\n", i, a->elements[i]);
StringArray_delete(&a);
return EXIT_SUCCESS;
}
- Output:
There are 2 elements in an array with a capacity of 10 elements: the element 0 is the string "apple" the element 1 is the string "orange"
An example why sizeof(A)/sizeof(E) may be a bad idea in C
#define _CRT_SECURE_NO_WARNINGS // turn off panic warnings
#define _CRT_NONSTDC_NO_WARNINGS // enable old-gold POSIX names in MSVS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define N 10
// Fixed size global arrays
static const int scGlobal[N];
const int cGlobal[N];
static int sGlobal[N];
int Global[N];
#define TEST(A, N) \
do { \
puts(""); \
printf("directly called: sizeof(%8s) = %2d, length = %2d, %s\n",\
#A, \
sizeof(A), \
sizeof(A) / sizeof(int), \
sizeof(A) / sizeof(int) == N ? "pass" : "fail"); \
\
test1(#A, A, N); \
test2(#A, A, N); \
test3(#A, A, N); \
} while (0);
void test1(char* name, int* A, int n)
{
printf("as parameter int* A: sizeof(%8s) = %2d, length = %2d, %s\n",
name,
sizeof(A),
sizeof(A) / sizeof(int),
sizeof(A) / sizeof(int) == n ? "pass" : "fail");
}
void test2(char* name, int A[], int n)
{
printf("as parameter int A[]: sizeof(%8s) = %2d, length = %2d, %s\n",
name,
sizeof(A),
sizeof(A) / sizeof(int),
sizeof(A) / sizeof(int) == n ? "pass" : "fail");
}
void test3(char* name, int A[10], int n)
{
printf("as parameter int A[10]: sizeof(%8s) = %2d, length = %2d, %s\n",
name,
sizeof(A),
sizeof(A) / sizeof(int),
sizeof(A) / sizeof(int) == n ? "pass" : "fail");
}
int main(int argc, char argv[])
{
// Fixed size local arrays (defined inside curly braces block)
static const int scLocal[N];
const int cLocal[N];
static int sLocal[N];
auto int aLocal[N];
int Local[N];
// Fixed size VLA arrays can/should be used instead dynamically alocated
// blocks. VLA has not implemented in Microsoft Visual Studio C.
srand(time(NULL));
int n = N + rand() % 2; // the value of n is unknow in the compile time?
#ifndef _MSC_VER
int vlaLocal[n];
#endif
// Memory blocks as ersatz arrays. This is not all possible ways to allocate
// memory. There are other functions, like LocalAlloc, HeapAlloc, sbreak...
// Don't use alloca in any serious program - this function is really bad
// choice - it can corrupt the program stack and generate a stack overflow.
int* mBlock = (int*)malloc(n * sizeof(int));
int* cBlock = (int*)calloc(n, sizeof(int));
int* aBlock = (int*)_alloca(n * sizeof(int)); // don't use in your programs!
TEST(scGlobal, N);
TEST(cGlobal, N);
TEST(sGlobal, N);
TEST(Global, N);
TEST(scLocal, N);
TEST(cLocal, N);
TEST(sLocal, N);
TEST(aLocal, N);
TEST(Local, N);
#ifndef _MSC_VER
TEST(vlaLocal, n);
#endif
TEST(mBlock, N);
TEST(cBlock, N);
TEST(aBlock, N);
free(mBlock, N);
free(cBlock, N);
// free must not be called on aBlock
return 0;
}
As we can see the sizeof(ArrayType)/sizeof(ElementType) approach mostly fail.
- Output:
directly called: sizeof(scGlobal) = 40, length = 10, pass as parameter int* A: sizeof(scGlobal) = 4, length = 1, fail as parameter int A[]: sizeof(scGlobal) = 4, length = 1, fail as parameter int A[10]: sizeof(scGlobal) = 4, length = 1, fail directly called: sizeof( cGlobal) = 40, length = 10, pass as parameter int* A: sizeof( cGlobal) = 4, length = 1, fail as parameter int A[]: sizeof( cGlobal) = 4, length = 1, fail as parameter int A[10]: sizeof( cGlobal) = 4, length = 1, fail directly called: sizeof( sGlobal) = 40, length = 10, pass as parameter int* A: sizeof( sGlobal) = 4, length = 1, fail as parameter int A[]: sizeof( sGlobal) = 4, length = 1, fail as parameter int A[10]: sizeof( sGlobal) = 4, length = 1, fail directly called: sizeof( Global) = 40, length = 10, pass as parameter int* A: sizeof( Global) = 4, length = 1, fail as parameter int A[]: sizeof( Global) = 4, length = 1, fail as parameter int A[10]: sizeof( Global) = 4, length = 1, fail directly called: sizeof( scLocal) = 40, length = 10, pass as parameter int* A: sizeof( scLocal) = 4, length = 1, fail as parameter int A[]: sizeof( scLocal) = 4, length = 1, fail as parameter int A[10]: sizeof( scLocal) = 4, length = 1, fail directly called: sizeof( cLocal) = 40, length = 10, pass as parameter int* A: sizeof( cLocal) = 4, length = 1, fail as parameter int A[]: sizeof( cLocal) = 4, length = 1, fail as parameter int A[10]: sizeof( cLocal) = 4, length = 1, fail directly called: sizeof( sLocal) = 40, length = 10, pass as parameter int* A: sizeof( sLocal) = 4, length = 1, fail as parameter int A[]: sizeof( sLocal) = 4, length = 1, fail as parameter int A[10]: sizeof( sLocal) = 4, length = 1, fail directly called: sizeof( aLocal) = 40, length = 10, pass as parameter int* A: sizeof( aLocal) = 4, length = 1, fail as parameter int A[]: sizeof( aLocal) = 4, length = 1, fail as parameter int A[10]: sizeof( aLocal) = 4, length = 1, fail directly called: sizeof( Local) = 40, length = 10, pass as parameter int* A: sizeof( Local) = 4, length = 1, fail as parameter int A[]: sizeof( Local) = 4, length = 1, fail as parameter int A[10]: sizeof( Local) = 4, length = 1, fail directly called: sizeof( mBlock) = 4, length = 1, fail as parameter int* A: sizeof( mBlock) = 4, length = 1, fail as parameter int A[]: sizeof( mBlock) = 4, length = 1, fail as parameter int A[10]: sizeof( mBlock) = 4, length = 1, fail directly called: sizeof( cBlock) = 4, length = 1, fail as parameter int* A: sizeof( cBlock) = 4, length = 1, fail as parameter int A[]: sizeof( cBlock) = 4, length = 1, fail as parameter int A[10]: sizeof( cBlock) = 4, length = 1, fail directly called: sizeof( aBlock) = 4, length = 1, fail as parameter int* A: sizeof( aBlock) = 4, length = 1, fail as parameter int A[]: sizeof( aBlock) = 4, length = 1, fail as parameter int A[10]: sizeof( aBlock) = 4, length = 1, fail
C#
using System;
class Program
{
public static void Main()
{
var fruit = new[] { "apple", "orange" };
Console.WriteLine(fruit.Length);
}
}
Note that any of the following array declarations could be used:
var fruit = new[] { "apple", "orange" };
var fruit = new string[] { "apple", "orange" };
string[] fruit = new[] { "apple", "orange" };
string[] fruit = new string[] { "apple", "orange" };
string[] fruit = { "apple", "orange" };
A shorter variant could also have been used:
using static System.Console;
class Program
{
public static void Main()
{
WriteLine(new[] { "apples", "oranges" }.Length);
}
}
C++
C++ follows the same rules as C regarding static and dynamic arrays.
However, C++ has an additional std::array
type (amongst other collections) in its standard library:
#include <array>
#include <iostream>
#include <string>
int main()
{
std::array<std::string, 2> fruit { "apples", "oranges" };
std::cout << fruit.size();
return 0;
}
Note that char*
or const char*
could have been used instead of std::string
.
In addition to the std::array
type, the C++ standard library also provides dynamically-sized containers to hold arbitrary objects.
These all support similar interfaces, though their implementations have different performance characteristics.
std::vector<std::string> fruitV({ "apples", "oranges" });
std::list<std::string> fruitL({ "apples", "oranges" });
std::deque<std::string> fruitD({ "apples", "oranges" });
std::cout << fruitV.size() << fruitL.size() << fruitD.size() << std::endl;
Of these, vector is probably the most widely used.
Ceylon
shared void run() {
value array = ["apple", "orange"];
print(array.size);
}
Clipper/XBase++
/*
* nizchka: March - 2016
* This is a Clipper/XBase++ of RosettaCode Array_Length
*/
PROCEDURE MAIN()
LOCAL FRUIT := { "apples","oranges" }
? LEN(FRUIT)
RETURN
Outputs:
2
nizchka 23:27, 16 March 2016 (UTC)
Clojure
; using count:
(count ["apple" "orange"])
; OR alength if using Java arrays:
(alength (into-array ["apple" "orange"]))
COBOL
Arrays in COBOL are usually referred to as tables. Tables can have fixed or variable (with known maximum) allocations, using a syntax of OCCURS DEPENDING ON. The value of the ODO identifier is the number of active elements in the table.
identification division.
program-id. array-length.
environment division.
configuration section.
repository.
function all intrinsic.
data division.
working-storage section.
01 table-one.
05 str-field pic x(7) occurs 0 to 5 depending on t1.
77 t1 pic 99.
procedure division.
array-length-main.
perform initialize-table
perform display-table-info
goback.
initialize-table.
move 1 to t1
move "apples" to str-field(t1)
add 1 to t1
move "oranges" to str-field(t1).
*> add an extra element and then retract table size
add 1 to t1
move "bananas" to str-field(t1).
subtract 1 from t1
.
display-table-info.
display "Elements: " t1 ", using " length(table-one) " bytes"
display table-one
.
end program array-length.
- Output:
$ cobc -xjd array-length.cob Elements: 02, using 000000014 bytes apples oranges
ColdFusion
<cfset testArray = ["apple","orange"]>
<cfoutput>Array Length = #ArrayLen(testArray)#</cfoutput>
Outputs:
Array Length = 2
Mike Knapp 15:57, 26 May 2016 (UTC)
Common Lisp
(print (length #("apple" "orange")))
Alternate solution
I use Allegro CL 10.1
;; Project : Array length
(setf my-array (make-array '(2)))
(setf (aref my-array 0) "apple")
(setf (aref my-array 1) "orange")
(format t "~a" "length of my-array: ")
(length my-array)
(terpri)
Output:
length of my-array: 2
Component Pascal
MODULE AryLen;
IMPORT StdLog;
TYPE
String = POINTER TO ARRAY OF CHAR;
VAR
a: ARRAY 16 OF String;
PROCEDURE NewString(s: ARRAY OF CHAR): String;
VAR
str: String;
BEGIN
NEW(str,LEN(s$) + 1);str^ := s$; RETURN str
END NewString;
PROCEDURE Length(a: ARRAY OF String): INTEGER;
VAR
i: INTEGER;
BEGIN
i := 0;
WHILE a[i] # NIL DO INC(i) END;
RETURN i
END Length;
PROCEDURE Do*;
BEGIN
a[0] := NewString("Apple");
a[1] := NewString("Orange");
StdLog.String("Length:> ");StdLog.Int(Length(a));StdLog.Ln
END Do;
END AryLen.
Execute: ^Q AryLen.Do
- Output:
Length:> 2
Crystal
puts ["apple", "orange"].size
- Output:
2
D
import std.stdio;
int main()
{
auto fruit = ["apple", "orange"];
fruit.length.writeln;
return 0;
}
Or a somewhat shorter...
import std.stdio;
void main()
{
["apple", "orange"].length.writeln;
}
Dart
arrLength(arr) {
return arr.length;
}
main() {
var fruits = ['apple', 'orange'];
print(arrLength(fruits));
}
DataWeave
var arr = ["apple", "orange"]
sizeOf(arr)
Delphi
showmessage( length(['a','b','c']).ToString );
Diego
set_namespace(rosettacode)_me();
me_msg()_array()_values(apple,orange)_length();
reset_namespace[];
- Output:
2
Dragon
select "std"
a = ["apple","orange"]
b = length(a)
show b
dt
[ "apple" "orange" ] len
Dyalect
var xs = ["apple", "orange"]
print(xs.Length())
EasyLang
fruit$[] = [ "apples" "oranges" ]
print len fruit$[]
EchoLisp
(length '("apple" "orange")) ;; list
→ 2
(vector-length #("apple" "orange")) ;; vector
→ 2
Ecstasy
String[] array = ["apple", "orange"];
Int length = array.size;
Ela
length [1..10]
Elena
ELENA 5.0 :
var array := new string[]{"apple", "orange"};
var length := array.Length;
Elixir
iex(1)> length( ["apple", "orange"] ) # List
2
iex(2)> tuple_size( {"apple", "orange"} ) # Tuple
2
Elm
import Array
import Html
main : Html.Html
main =
["apple", "orange"]
|> Array.fromList
|> Array.length
|> String.fromInt
|> Html.text
Emacs Lisp
(length ["apple" "orange"])
=> 2
length
also accepts a list or a string.
EMal
writeLine(text["apple", "orange"].length)
Erlang
1> length(["apple", "orange"]). %using a list
2
1> tuple_size({"apple", "orange"}). %using a tuple
2
Euphoria
sequence s = {"apple","orange",2.95} -- Euphoria doesn't care what you put in a sequence
? length(s)
3 -- three objects
? length(s[1])
5 -- apple has 5 characters
? length(s[1][$])
1 -- 'e' is an atomic value
? length(s[$])
1 -- 2.95 is an atomic value
F#
[|1;2;3|].Length |> printfn "%i"
Or:
[|1;2;3|] |> Array.length |> printfn "%i"
Factor
{ "apple" "orange" } length
Fennel
(length [:apple :orange])
Forth
The philosophy of Chuck Moore, the creator of Forth was that he did not want to write code for something he may never use. His solution was to distill his language into a large set of very simple routines that control the hardware directly. This demonstration must build "arrays" from scratch. In Forth, like in Assembler, you can do this any way you want. This demonstration adds new words to Forth that make a syntax to create simple variable length string arrays. Each string is a counted string with no trailing zero.
The code is commented to explain what is going on for those unfamiliar with Forth.
: STRING, ( caddr len -- ) \ Allocate space & compile string into memory
HERE OVER CHAR+ ALLOT PLACE ;
: " ( -- ) [CHAR] " PARSE STRING, ; \ Parse input to " and compile to memory
\ Array delimiter words
: { ALIGN 0 C, ; \ Compile 0 byte start/end of array
: } ALIGN 0 C, ;
\ String array words
: {NEXT} ( str -- next_str) \ Iterate to next string
COUNT + ;
: {NTH} ( n array_addr -- str) \ Returns address of the Nth item in the array
SWAP 0 DO {NEXT} LOOP ;
: {LEN} ( array_addr -- n) \ count strings in the array
0 >R \ Counter on Rstack
{NEXT}
BEGIN
DUP C@ \ Fetch length byte
WHILE \ While true
R> 1+ >R \ Inc. counter
{NEXT}
REPEAT
DROP
R> ; \ return counter to data stack
Test code at Forth console
CREATE Q { " Apples" " Oranges" } q {len} . 2 ok
Fortran
Early fortrans offered no protocol for ascertaining the length (or dimensionality) of arrays, though the compiler has this information. Thus a statement such as PRINT A
would print all the elements of a variable A
according to its definition. A subprogram that received a parameter would have no access to these details, so its parameter might be declared as A(12345)
simply to signify that it was an array (rather than an ordinary variable) and the programmer would rely on other data to know the upper bound to employ, for instance via an additional parameter. Any mistakes would cause crashes! On the other hand, with heavy computational tasks, it was common to take advantage of the opportunities. Thus, a subprogram might regard its array parameter as one-dimensional even though the actual parameter was not. Carefully-programmed routines might thusly process a sequence of elements via 1-D indexing, far faster than the 2-D or higher order indexing of the original. Success at this game required understanding how array elements were arranged in multidimensional arrays.
Later fortrans allowed A(*)
to signify an array parameter of unstated upper bound, but there was still a problem with higher dimensions. All but the last dimension has to be stated correctly if a multi-dimensional array parameter is to be indexed correctly - Fortran stores array elements in column-major order.
With Fortran 90, a new protocol was introduced, whereby the parameter might be declared as A(:)
signifying an array of one dimension, of bounds unstated. A 2-D array would have A(:,:)
and so on. Further, arrays could have arbitrary lower bounds as well, as in A(-7:12)
but if no colon appeared for a dimension, the lower bound would be assumed to be one so A(2)
means an array of two elements, as before. And as before, in a subprogram a bound could be explicitly stated, perhaps via an explicit parameter such as N
, but now with the :
scheme, the compiler is passing secret additional parameters to the subprogram giving the bounds of the array, and these can be accessed via the library functions LBOUND and UBOUND. For multi-dimensional arrays there are multiple bounds, and an invocation might be UBOUND(A,DIM = 2)
but in the example only a one-dimensional array is involved. These facilities are available only if the new MODULE protocol is employed.
The task is in terms of an array holding the texts "Apple" and "Orange", so a CHARACTER*6 element size will do; the subprogram receives yet another secret parameter specifying the size of CHARACTER parameters. This size can be accessed via the LEN function, and, since in principle the index span is arbitrary, no constant index is sure to be a valid index of some single element: thus the LBOUND function is used to finger one that is.
For a simple example, the WRITE(6,*) suffices: write to standard output (the 6), in free-format (the *).
MODULE EXAMPLE
CONTAINS
SUBROUTINE ABOUND(A)
CHARACTER*(*) A(:) !One dimensional array, unspecified bounds.
WRITE (6,*) "Lower bound",LBOUND(A),", Upper bound",UBOUND(A)
WRITE (6,*) "Element size",LEN(A(LBOUND(A)))
WRITE (6,*) A
END SUBROUTINE ABOUND
END MODULE EXAMPLE
PROGRAM SHOWBOUNDS
USE EXAMPLE
CHARACTER*6 ARRAY(-1:1)
ARRAY(-1) = "Apple"
ARRAY(0) = "Orange"
ARRAY(1) = ""
CALL ABOUND(ARRAY)
WRITE (6,*) "But, when it is at home..."
WRITE (6,*) "L. bound",LBOUND(ARRAY),", U. bound",UBOUND(ARRAY)
END
Output:
Lower bound 1 , Upper bound 3 Element size 6 Apple Orange But, when it is at home... L. bound -1 , U. bound 1
Notice that the subprogram sees the array as an old-style array starting with index one! If it is to work with a lower bound other than one, the declaration in the subprogram must state it, perhaps as A(-1:) or as A(START:), etc. The upper bound remains unspecified, and with that declaration, UBOUND returns 1 instead of 3, corresponding to the shift. Thus, UBOUND returns not the actual upper bound of the array parameter (as supplied) but the upper bound relative to the lower bound in use in the subprogram so that UBOUND - LBOUND + 1 does give the number of elements.
If in the subprogram the bounds are fixed (say as A(-1:6)
) then a CALL ABOUND(ARRAY) may provoke a compiler complaint if ARRAY is not a suitable size.
FreeBASIC
' FB 1.05.0 Win64
Dim fruit(1) As String = {"apple", "orange"}
Dim length As Integer = UBound(fruit) - LBound(fruit) + 1
Print "The length of the fruit array is"; length
Print
Print "Press any key to quit the program"
Sleep
- Output:
The length of the fruit array is 2
Frink
a = ["apple", "orange"]
println[length[a]]
FurryScript
THE_LIST( <apple> <orange> )
COUNT[ 0 SW ~| COUNT_STEP# 0 SW SU ]
COUNT_STEP[ DR 1 SU ]
`THE_LIST COUNT# +<>
Futhark
The shape
builtin returns the shape of an array as an array of integers. The length is element 0 of the shape:
fun length(as: []int): int = (shape as)[0]
FutureBasic
NSUInteger count = fn ArrayCount( array ). Example:
window 1
print fn ArrayCount( @[@"apple",@"orange",@"cherry",@"grape",@"lemon"] )
HandleEvents
We can also use FB's len() function to get the length of an array.
void local fn DoIt
CFArrayRef array = @[@"apple",@"orange",@"cherry",@"grape",@"lemon"]
print len(array)
end fn
fn DoIt
HandleEvents
- Output:
5
Fōrmulæ
Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.
Programs in Fōrmulæ are created/edited online in its website.
In this page you can see and run the program(s) related to this task and their results. You can also change either the programs or the parameters they are called with, for experimentation, but remember that these programs were created with the main purpose of showing a clear solution of the task, and they generally lack any kind of validation.
Solution
The cardinality expression reduces to the number of subexpressions the given expression has, including if the expressions is a list:
Gambas
Click this link to run this code
Public Sub Main()
Dim siList As Short[] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
Print siList.Count
End
Output:
10
Genie
[indent=4]
/* Array length, in Genie */
init
arr:array of string = {"apple", "orange"}
stdout.printf("%d ", arr.length)
print arr[1]
- Output:
prompt$ valac array_length.gs prompt$ ./array_length 2 orange
Go
package main
import "fmt"
func main() {
arr := [...]string{"apple", "orange", "pear"}
fmt.Printf("Length of %v is %v.\n", arr, len(arr))
}
- Output:
Length of [apple orange pear] is 3.
Groovy
def fruits = ['apple','orange']
println fruits.size()
Harbour
LOCAL aFruits := {"apple", "orange"}
Qout( Len( aFruits ) ) // --> 2
Haskell
-- [[Char]] -> Int
length ["apple", "orange"]
hexiscript
let a arr 2
let a[0] "apple"
let a[1] "orange"
println len a
Hoon
|= arr=(list *) (lent arr)
i
main: print(#["apple", "orange"])
Icon and Unicon
Icon, and therefore Unicon, includes a prefix size operator, star *
. This operator can be applied to just about any data type or data structure.
write(*["apple", "orange"])
Idris
length ["apple", "orange"]
Insitux
(len ['apple' 'orange'])
J
Tally (#
) returns the length of the leading dimension of an array (or 1 if the array has no dimensions). Shape Of ($
) returns the length of each dimension of an array.
# 'apple';'orange'
2
$ 'apple';'orange'
2
For the list array example given, the result appears to be the same. The difference is that the result of Tally is a scalar (array of 0 dimensions) whereas the result of Shape Of is a list (1 dimensional array), of length 1 in this case.
$#'apple';'orange'
$$'apple';'orange'
1
This might be a clearer concept with a few more examples. Here's an array with two dimensions:
>'apple';'orange'
apple
orange
$>'apple';'orange'
2 6
#>'apple';'orange'
2
And, here's an array with no dimensions:
9001
9001
#9001
1
$9001
You can count the number of dimensions of an array (the length of the list of lengths) using #$array
:
#$9001
0
#$'apple';'orange'
1
#$>'apple';'orange'
2
Janet
(def our-array @["apple" "orange"])
(length our-array)
- Output:
2
Java
The resulting array object will have a length field.
String[] strings = { "apple", "orange" };
int length = strings.length;
Additionally, you can do this in one line, if need be.
int length = new String[] { "apple", "orange" }.length;
JavaScript
console.log(['apple', 'orange'].length);
However, determining the length of a list, array, or collection may simply be the wrong thing to do.
If, for example, the actual task (undefined here, unfortunately) requires retrieving the final item, while it is perfectly possible to write last in terms of length
function last(lst) {
return lst[lst.length - 1];
}
using length has the disadvantage that it leaves last simply undefined for an empty list.
We might do better to drop the narrow focus on length, and instead use a fold (reduce, in JS terms) which can return a default value of some kind.
function last(lst) {
return lst.reduce(function (a, x) {
return x;
}, null);
}
Alternatively, rather than scanning the entire list to simply get the final value, it might sometimes be better to test the length:
function last(list, defaultValue) {
return list.length ?list[list.length-1] :defaultValue;
}
Or use other built-in functions – this, for example, seems fairly clear, and is already 100+ times faster than unoptimised tail recursion in ES5 (testing with a list of 1000 elements):
function last(list, defaultValue) {
return list.slice(-1)[0] || defaultValue;
}
Joy
["apple" "orange"] size.
- Output:
2
jq
["apple","orange"] | length
Output:
2
Note that the length filter is polymorphic, so for example the empty string (""), the empty list ([]), and null all have length 0.
Jsish
/* Array length, in jsish */
var arr = new Array('apple', 'orange');
puts(arr.length);
puts(arr[1]);
- Output:
prompt$ jsish arrayLength.jsi 2 orange
Julia
a = ["apple","orange"]
length(a)
K
#("apple";"orange")
- Output:
2
Klingphix
include ..\Utilitys.tlhy
( "apple" "orange" ) len print
" " input
- Output:
2
Klong
#["apple" "orange"]
Kotlin
fun main(args: Array<String>) {
println(arrayOf("apple", "orange").size)
}
Lambdatalk
{A.length {A.new 1 2 3}}
-> 3
Lang
&arr $= [apple, orange]
# Array length function
fn.println(fn.arrayLength(&arr))
# Length operator function
fn.println(fn.len(&arr))
# Length operator
fn.println(parser.op(@&arr))
Latitude
In Latitude, length
and size
are synonymous and will both retrieve the size of a collection.
println: ["apple", "orange"] length.
LDPL
data:
fruits is text list
len is number
procedure:
push "apple" to fruits
push "orange" to fruits
get length of fruits in len
display len lf
- Output:
2
Liberty BASIC
When a one or two dimensional array, A$, with subscript(s) of 10 or less is referenced (either by assigning or reading), the compiler does an implicit DIM A$(10) or DIM A$(10,10). Before referencing an array with any subscript numbered higher than 10, or arrays of three dimensions or more, the programmer must first issue an explicit DIM statement.
There is no function in Liberty Basic to directly read the size of an array. This program uses error trapping loops to, first, determine the number of dimensions of the array. Then, second, again uses error trapping loops to determine the number of elements in each dimension. Finally, it prints the DIM statement that was used to define the array.
I suppose the implicit DIM feature makes it a bit quicker to write short, simple programs. One or two dimension arrays may be resized with REDIM. Three dimension or more arrays can not be resized. All arrays may be cleared with REDIM. Keep in mind that A$(n) and A$(n,m) are the same array. You must refer to it with the correct arguments or get an error.
NOTE -- This program runs only under LB Booster version 3.05 or higher because of arrays with more than two dimensions, passed array names to functions and subroutines as a parameter, and structured error trapping syntax. Get the LBB compiler here: http://lbbooster.com/
FruitList$(0)="apple" 'assign 2 cells of a list array
FruitList$(1)="orange"
dimension=dimension(FruitList$()) 'first get the dimension of the array
if dimension>3 then
print "Sorry, program only written for array dimensions of 3 or less."
end
end if
call elements FruitList$(), dimension 'next get the size of each dimension
end
function dimension(array$())
for dimension=1 to 4
select case dimension
case 1
try: x$=array$(0)
catch: goto [TryNext]
end try
exit for
case 2
try: x$=array$(0,0)
catch: goto [TryNext]
end try
exit for
case 3
try: x$=array$(0,0,0)
catch: goto [TryNext]
end try
exit for
case 4
exit for
end select
[TryNext]
next dimension
if dimension<4 then print "array dimension = "; dimension
ArraySize(0)=dimension
end function
sub elements array$(), dimension
select case dimension
case 1
try
do
x$=array$(a)
a+=1
loop
catch: elements=a
end try
ArraySize(1)=elements-1
print "dimension 1 has "; elements; " elements (cells), "_
"numbered 0 to "; ArraySize(1)
case 2
try
do
x$=array$(a,0)
a+=1
loop
catch: elements=a
end try
ArraySize(1)=elements-1
print "dimension 1 has "; elements; " elements (cells), "_
"numbered 0 to "; ArraySize(1)
elements=0
try
do
x$=array$(0,b)
b+=1
loop
catch: elements=b
end try ArraySize(2)=elements-1
print "dimension 2 has "; elements; " elements (cells), "_
"numbered 0 to "; ArraySize(2)
case 3
try
do
x$=array$(a,0,0)
a+=1
loop
catch: elements=a
end try
ArraySize(1)=elements-1
print "dimension 1 has "; elements; " elements (cells), "_
"numbered 0 to "; ArraySize(1)
elements=0
try
do
x$=array$(0,b,0)
b+=1
loop
catch: elements=b
end try
ArraySize(2)=elements-1
print "dimension 2 has "; elements; " elements (cells), "_
"numbered 0 to "; ArraySize(2)
elements=0
try
do
x$=array$(0,0,c)
c+=1
loop
catch: elements=c
end try
ArraySize(3)=elements-1
print "dimension 3 has "; elements; " elements (cells), "_
"numbered 0 to "; ArraySize(3)
end select
'print the explicit or implied DIMension statement for this array
print "DIM array$("; a-1;
if b>0 then print ","; b-1;
if c>0 then print ","; c-1;
print ")"
end sub
- Output:
array dimension = 1 dimension 1 has 11 elements (cells), numbered 0 to 10 DIM array$(10)
LIL
LIL does not use arrays, but indexed lists. The builtin count command returns the item count in a list. The length command returns the length of the list after string conversion.
# Array length, in LIL
set a [list "apple"]
append a "orange"
print [count $a]
print [index $a 1]
- Output:
prompt$ lil arrayLength.lil 2 orange
Limbo
implement Command;
include "sys.m";
sys: Sys;
include "draw.m";
include "sh.m";
init(nil: ref Draw->Context, nil: list of string)
{
sys = load Sys Sys->PATH;
a := array[] of {"apple", "orange"};
sys->print("length of a: %d\n", len a);
}
Lingo
fruits = ["apple", "orange"]
put fruits.count
-- 2
Little
string fruit[] = {"apples", "oranges"};
puts(length(fruit));
LiveCode
put "apple","orange" into fruit
split fruit using comma
answer the number of elements of fruit
Lua
-- For tables as simple arrays, use the # operator:
fruits = {"apple", "orange"}
print(#fruits)
-- Note the # symbol does not work for non-integer-indexed tables:
fruits = {fruit1 = "apple", fruit2 = "orange"}
print(#fruits)
-- For this you can use this short function:
function size (tab)
local count = 0
for k, v in pairs(tab) do
count = count + 1
end
return count
end
print(size(fruits))
- Output:
2 0 2
M2000 Interpreter
\\ A is a pointer to array
A=("Apple", "Orange")
Print Len(A)=2 ' True
Print Dimension(A, 0) ' LBound (0 or 1), here 0
Print Dimension(A) ' No of Dimensions 1
Print Dimension(A, 1) ' for 1 dimension array this is also Length=2
\\ A$( ) is an Array (not a pointer to array)
Dim Base 1, A$(2)
A$(1)="Apple", "Orange"
Print Dimension(A$(), 0) ' LBound (0 or 1), here 1
Print Dimension(A$()) ' No of Dimensions 1
Print Dimension(A$(), 1) ' for 1 dimension array this is also Length=2
Link A to B$() ' B$() is a reference to A
Print B$(0)=A$(1)
Print B$(1)=A$(2)
Dim C$()
\\ C$() get a copy of B$()
C$()=B$()
Print C$() ' prints Apple Orange
\\ An array can link to a new name as reference, and can change major type
\\ here A$() get A() so we can read/store numbers and read/store strings in same array
\\ using two names
Link A$() to A()
\\ An array pointer can point to another array
A=A()
Print Dimension(A, 0) ' LBound (0 or 1), here 1 (was 0)
\\ Because B$() is reference of A:
Print Dimension(B$(), 0) ' LBound (0 or 1), here 1 (was 0)
Print B$(1)=A$(1)
Print B$(2)=A$(2)
Print Dimension(C$(), 0) ' LBound (0 or 1), here 0
\\ change base preserve items
Dim Base 1, C$(Dimension(C$(), 1))
Print Dimension(C$(), 0) ' LBound (0 or 1), here 1 (was 0)
Print C$() ' prints Apple Orange
Print Len(C$()) ' Len return all items of an array - can be 0
Dim K(1,1,1,1,1,1) ' Maximum 10 dimensions
Print Len(K()=1 ' True
Maple
a := Array(["apple", "orange"]);
numelems(a);
- Output:
a := [ "apple" "orange" ] 2
Mathematica /Wolfram Language
Length[{"apple", "orange"}]
MATLAB / Octave
length({'apple', 'orange'})
For arrays with more than one dimension, length reports the length of the larges dimension. The number of elements in a multi-dimensional array can be obtained with numel.
numel({'apple', 'orange'; 'pear', 'banana'})
Modula-3
MODULE ArrayLength EXPORTS Main;
IMPORT IO;
VAR
Arr:ARRAY[1..2] OF TEXT :=
ARRAY[1..2] OF TEXT{"apples", "oranges"};
BEGIN
IO.PutInt(NUMBER(Arr));
END ArrayLength.
Mercury
:- module array_length.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.
:- implementation.
:- import_module array, list.
main(!IO) :-
Array = array(["apples", "oranges"]),
io.write_int(size(Array), !IO).
min
("apple" "orange") size print
- Output:
2
MiniScript
fruits = ["apple", "orange"]
print fruits.len
MiniZinc
array[int] of int: arr = [1,2,3];
var int: size = length(arr);
solve satisfy;
output [show(size),"\n"];
Nanoquery
fruit = array(2)
fruit[0] = "apple"
fruit[1] = "orange"
println len(fruit)
// outputs 2
Neko
var fruit = $array("apple", "orange");
$print($asize(fruit));
NewLISP
(println (length '("apple" "orange")))
; Nehal-Singhal 2018-05-25
(length '(apple orange))
NGS
echo(len(['apple', 'orange']))
# same
echo(['apple', 'orange'].len())
Nim
let fruit = ["apple", "orange"]
echo "The length of the fruit array is ", len(fruit)
- Output:
The length of the fruit array is 2
Nu
[apple orange] | length
- Output:
2
Nutt
module main
imports native.io.output.say
say(#{"apple","orange"})
end
Oberon-2
MODULE ArrayLength;
IMPORT
Strings,
Out;
TYPE
String = POINTER TO ARRAY OF CHAR;
VAR
a: ARRAY 16 OF String;
PROCEDURE NewString(s: ARRAY OF CHAR): String;
VAR
str: String;
BEGIN
NEW(str,Strings.Length(s) + 1);COPY(s,str^);
RETURN str
END NewString;
PROCEDURE Length(a: ARRAY OF String): LONGINT;
VAR
i: LONGINT;
BEGIN
i := 0;
WHILE (a[i] # NIL) DO INC(i) END;
RETURN i;
END Length;
BEGIN
a[0] := NewString("apple");
a[1] := NewString("orange");
Out.String("length: ");Out.Int(Length(a),0);Out.Ln
END ArrayLength.
- Output:
length: 2
Objeck
class Test {
function : Main(args : String[]) ~ Nil {
fruit := ["apples", "oranges"];
fruit->Size()->PrintLine();
}
}
OCaml
Array.length [|"apple"; "orange"|];;
Oforth
[ "apple", "orange" ] size
Ol
All of these methods are equivalent.
(print (vector-length (vector "apple" "orange")))
(print (vector-length #("apple" "orange")))
(print (vector-length ["apple" "orange"]))
(print (size #("apple" "orange")))
OmniMark
In OmniMark, From OmniMark v12 documentation:
" Most programming languages allow programmers to store and manipulate values in arrays, associative arrays, queues, and stacks. Instead, OmniMark provides a data container called a shelf: a shelf can be used to accomplish all of the tasks normally carried out by these various structures in other programming languages. Like arrays, shelves can be indexed by numeric values that reflect the position of the elements they contain or, like associative arrays, these elements can be given names (keys) and then indexed by those keys. "
process
local stream s variable initial {"apple", "orange"}
local integer i initial {number of s}
put #main-output 'The number of fruit elements is %d(i).'
Output:
The number of fruit elements is 2.
Onyx
[`apple' `orange'] length # leaves 2 on top of the stack
ooRexx
/* REXX */
a = .array~of('apple','orange')
say a~size 'elements'
Do e over a
say e
End
Say "a[2]="a[2]
- Output:
2 elements apple orange a[2]=orange
PARI/GP
array = ["apple", "orange"]
length(array) \\ == 2
#array \\ == 2
The #
syntax is a handy shorthand. It usually looks best just on variables but it works on expressions too, possibly with parens to control precedence.
Both forms work on column vectors too, and also on strings and matrices. (For a matrix it is the number of columns.)
Pascal
#!/usr/bin/instantfpc
//program ArrayLength;
{$mode objfpc}{$H+}
uses SysUtils, Classes;
const
Fruits : array[0..1] of String = ('apple', 'orange');
begin
WriteLn('Length of Fruits by function : ', Length(Fruits));
WriteLn('Length of Fruits by bounds : ', High(Fruits) - Low(Fruits) + 1);
END.
- Output:
./ArrayLength.pas Length of Fruits by function : 2 Length of Fruits by bounds : 2
PascalABC.NET
// Array length. Nigel Galloway: September 2nd., 2022
var n:array of string:=('apple','orange');
begin
writeln(Length(n));
end.
- Output:
2
Modern way:
// Array length. Mikhalkovich Stanislav: May 16, 2024
##
var a := |'apple','orange'|;
a.Length.Print;
- Output:
2
Perl
The way to get the number of elements of an array in Perl is to put the array in scalar context.
my @array = qw "apple orange banana", 4, 42;
scalar @array; # 5
0 + @arrray; # 5
'' . @array; # "5"
my $elems = @array; # $elems = 5
scalar @{ [1,2,3] }; # [1,2,3] is a reference which is already a scalar
my $array_ref = \@array; # a reference
scalar @$array_ref;
# using subroutine prototypes, not generally recommended
# and not usually what you think they are
sub takes_a_scalar ($) { my ($a) = @_; return $a }
takes_a_scalar @array;
# the built-ins can also act like they have prototypes
A common mistake is to use length
which works on strings not arrays.
So using it on an array, as a side-effect, actually gives you a number which represents the order of magnitude.
length '' . @array; # 1
length @array; # 1
print '0.', scalar @array, 'e', length @array, "\n"; # 0.5e1
@array = 1..123;
print '0.', scalar @array, 'e', length @array, "\n"; # 0.123e3
print 'the length of @array is on the order of ';
print 10 ** (length( @array )-1); # 100
print " elements long\n";
Phix
constant fruits = {"apple","orange"} ?length(fruits)
- Output:
2
Phixmonti
"apple" "orange" stklen tolist len print
With syntactic sugar
include ..\Utilitys.pmt
( "apple" "orange" ) len print
- Output:
2
PHP
print count(['apple', 'orange']); // Returns 2
Picat
main =>
L = ["apple", "orange"],
println(len(L))),
println(length(L)),
println(L.len),
println(L.length).
- Output:
2 2 2 2
PicoLisp
: (length '(apple orange))
-> 2
:
Pike
void main()
{
array fruit = ({ "apple", "orange" });
write("%d\n", sizeof(fruit));
}
- Output:
2
PL/I
p: Proc Options(main);
Dcl a(2) Char(6) Varying Init('apple','orange');
Put Edit('Array a has',(hbound(a)-lbound(a)+1),' elements.')
(Skip,a,f(2),a);
Put Skip Data(a);
End;
- Output:
Array a has 2 elements. A(1)='apple' A(2)='orange';
Plorth
["apple", "orange"] length println
Pony
actor Main
new create(env:Env)=>
var c=Array[String](2)
c.push("apple")
c.push("orange")
env.out.print("Array c is " + c.size().string() + " elements long!")
Potion
("apple", "orange") length print
PowerShell
$Array = @( "Apple", "Orange" )
$Array.Count
$Array.Length
- Output:
2 2
Processing
String[] arr = {"apple", "orange"};
void setup(){
println(arr.length);
}
- Output:
2
Processing Python mode
arr = ['apple', 'orange'] # a list for an array
def setup():
println(len(arr))
- Output:
2
Prolog
| ?- length(["apple", "orange"], X).
X = 2
yes
PureBasic
EnableExplicit
Define Dim fruit$(1); defines array with 2 elements at indices 0 and 1
fruit$(0) = "apple"
fruit$(1) = "orange"
Define length = ArraySize(fruit$()) + 1; including the element at index 0
If OpenConsole()
PrintN("The length of the fruit array is " + length)
PrintN("")
PrintN("Press any key to close the console")
Repeat: Delay(10) : Until Inkey() <> ""
CloseConsole()
EndIf
- Output:
The length of the fruit array is 2
An abbreviated form of the above, not printing to console/terminal
Dim fruit$(1); defines array with 2 elements at indices 0 and 1
fruit$(0) = "apple"
fruit$(1) = "orange"
Debug ArraySize(fruit$()) + 1 ;the number of elements is equal to the size + 1. For example: Dim a(2) contains 3 elements from a(0) to a(2) for a size of 2.
- Output:
2
Python
>>> print(len(['apple', 'orange']))
2
>>>
QB64
Dim max As Integer, Index As Integer
Randomize Timer
max = Int(Rnd * 10) + 1
Dim StringAr(1 To max) As String
For Index = 1 To max
If Int(Rnd * 6) + 1 <= 3 Then StringAr(Index) = "Apple" Else StringAr(Index) = "orange"
Next
Print UBound(Stringar)
End
Quackery
$ "apples" $ "oranges" 2 pack size echo
- Output:
2
R
a <- c('apple','orange') # create a vector containing "apple" and "orange"
length(a)
- Output:
[1] 2
Racket
#lang racket/base
(length '("apple" "orange")) ;; list
(vector-length #("apple" "orange")) ;; vector
- Output:
2 2
Raku
(formerly Perl 6)
To get the number of elements of an array in Raku you put the array in a coercing Numeric context, or call elems
on it.
my @array = <apple orange>;
say @array.elems; # 2
say elems @array; # 2
say + @array; # 2
say @array + 0; # 2
Watch out for infinite/lazy arrays though. You can't get the length of those.
my @infinite = 1 .. Inf; # 1, 2, 3, 4, ...
say @infinite[5000]; # 5001
say @infinite.elems; # Throws exception "Cannot .elems a lazy list"
Rapira
arr := <* "apple", "orange" *>
output: #arr
REBOL
>> length? ["apples" "oranges"]
== 2
Red
length? ["apples" "oranges"]
== 2
Relation
relation fruit
insert "apples"
insert "oranges"
project fruit count
print
fruit_count |
---|
2 |
ReScript
let fruits = ["apple", "orange"]
Js.log(Js.Array.length(fruits))
<!DOCTYPE html>
<html>
<head>
<title>ReScript: Array.length()</title>
<style rel="stylesheet" type="text/css">
body { color:#EEE; background-color:#888; }
</style>
<script>var exports = {};</script>
<script src="./arrlen.js"></script>
</head>
<body>
</body>
</html>
- Output:
// Generated by ReScript, PLEASE EDIT WITH CARE 'use strict'; var fruits = [ "apple", "orange" ]; console.log(fruits.length); exports.fruits = fruits; /* Not a pure module */
REXX
/* REXX ----------------------------------------------
* The compond variable a. implements an array
* By convention, a.0 contains the number of elements
*---------------------------------------------------*/
a.=0 /* initialize the "array" */
call store 'apple'
Call store 'orange'
Say 'There are' a.0 'elements in the array:'
Do i=1 To a.0
Say 'Element' i':' a.i
End
Exit
store: Procedure Expose a.
z=a.0+1
a.z=arg(1)
a.0=z
Return
- Output:
There are 2 elements in the array: Element 1: apple Element 2: orange
Ring
See len(['apple', 'orange']) # output = 2
Robotic
As stated before in the arrays section on this Wiki, there is no functions listed for the manipulation/status of arrays. The best way we can count for length in an array is to have a variable keep track of it.
Example 1:
set "index" to 0
set "$array&index&" to "apple"
inc "index" by 1
set "$array&index&" to "orange"
* "Array length: ('index' + 1)"
Example 2:
set "index" to 0
set "local1" to random 1 to 99
: "rand"
set "array&index&" to random 0 to 99
inc "index" 1
dec "local1" 1
if "local1" > 1 then "rand"
* "Array length: ('index')"
RPL
The SIZE
instruction can be used for arrays (e.g. vectors) and lists. RPL arrays can only contain real or complex numbers, so we will use a list here.
{ "apple" "orange" } SIZE
- Output:
1: 2
Ruby
puts ['apple', 'orange'].length # or .size
Rust
By default arrays are immutable in rust.
fn main() {
let array = ["foo", "bar", "baz", "biff"];
println!("the array has {} elements", array.len());
}
S-BASIC
Finding the size of an S-BASIC array at run-time is convoluted, to say the least, but it can be done. (It would also generally be pointless, since the size of an array is fixed - and thus presumably known - at compile time.) Each array has an associated data structure (referred to in the documentation as "SPEC") containing information such as the number of dimensions, the size of an array element, the size of each dimension, and so on. The address of the SPEC for an array can be obtained using the LOCATION statement. For a single-dimension array, the number of elements will be found five bytes into the structure, at a point described in the documentation as the "dope vector".
dim string animals(2) rem here is our array
var array_struct_address = integer
based array_size = integer
animals(1) = "ardvark"
animals(2) = "bison"
location spec array_struct_address = animals
base array_size at array_struct_address + 5
print "Size of array ="; array_size
end
- Output:
Size of array = 2
Scala
println(Array("apple", "orange").length)
Scheme
Using Scheme's vector type as an equivalent to an array:
(display (vector-length #("apple" "orange")))
Seed7
The function length determines the length of an array.
$ include "seed7_05.s7i";
const array string: anArray is [] ("apple", "orange");
const proc: main is func
begin
writeln(length(anArray));
end func;
SenseTalk
put ("apple", "orange", "pear", "banana", "aubergine") into fruits
put the number of items in fruits
Shen
\\ Using a vector
\\ @v creates the vector
\\ <> ends the vector
\\ limit returns the length of a vector
\\ apple and orange are symbols (vs strings) in this case.
(limit (@v apple orange <>))
\\ As an list
(length [apple orange])
Sidef
var arr = ['apple', 'orange'];
say arr.len; #=> 2
say arr.end; #=> 1 (zero based)
Simula
COMMENT ARRAY-LENGTH;
BEGIN
INTEGER PROCEDURE ARRAYLENGTH(A); TEXT ARRAY A;
BEGIN
ARRAYLENGTH := UPPERBOUND(A, 1) - LOWERBOUND(A, 1) + 1;
END ARRAYLENGTH;
TEXT ARRAY A(1:2);
INTEGER L;
A(1) :- "APPLE";
A(2) :- "ORANGE";
L := ARRAYLENGTH(A);
OUTINT(L, 0);
OUTIMAGE;
END
- Output:
2
Template:Heaer
(length ["apple" "orange"])
SmallBASIC
A = ["apple", "orange"]
print len(A)
Smalltalk
a := #('apple' 'orange').
a size
SNOBOL4
ar = ARRAY('2,2')
ar<1,1> = 'apple'
ar<1,2> = 'first'
ar<2,1> = 'orange'
ar<2,2> = 'second'
OUTPUT = IDENT(DATATYPE(ar), 'ARRAY') PROTOTYPE(ar)
end
- Output:
2,2
SPL
a = ["apple","orange"]
#.output("Number of elements in array: ",#.size(a,1))
- Output:
Number of elements in array: 2
SQL
SELECT COUNT() FROM (VALUES ('apple'),('orange'));
Standard ML
let
val a = Array.fromList ["apple", "orange"]
in
Array.length a
end;
Stata
String data may be stored either in a Stata dataset or in a Mata matrix, not in a Stata matrix, which may hold only numeric data. A list of strings may also be stored in a Stata macro.
Dimensions of a dataset
clear
input str10 fruit
apple
orange
end
di _N
di c(N) " " c(k)
Length of a macro list
Use either the sizeof macro list function or the word count extended macro function. Notice that the argument of the former is the macro name, while the argument of the latter is the macro contents.
local fruits apple orange
di `: list sizeof fruits'
di `: word count `fruits''
Mata
For a Mata array, use rows and similar functions:
mata
a=st_sdata(.,"fruit")
rows(a)
cols(a)
length(a)
end
Swift
let fruits = ["apple", "orange"] // Declare constant array literal
let fruitsCount = fruits.count // Declare constant array length (count)
print(fruitsCount) // Print array length to output window
- Output:
2
Symsyn
| Symsyn does not support Array of Strings
| The following code for an Array of Integers
A : 125 0
#A []
| shows 125
| A list of fixed length strings can be handled this way
S : 'apple ' : 'orange'
div #S 6 sz
sz []
| shows 2
Tailspin
['apple', 'orange'] -> $::length -> !OUT::write
- Output:
2
Tcl
;# not recommended:
set mylistA {apple orange} ;# actually a string
set mylistA "Apple Orange" ;# same - this works only for simple cases
set lenA [llength $mylistA]
puts "$mylistA : $lenA"
# better: to build a list, use 'list' and/or 'lappend':
set mylistB [list apple orange "red wine" {green frog}]
lappend mylistB "blue bird"
set lenB [llength $mylistB]
puts "$mylistB : $lenB"
- Output:
Apple Orange : 2 apple orange {red wine} {green frog} {blue bird} : 5
TI-83 BASIC
Use function dim()
.
{1,3,–5,4,–2,–1}→L1
dim(L1)
- Output:
6
Transd
#lang transd
MainModule : {
_start: (lambda
(with v ["apple", "orange"]
(lout (size v))
)
(lout (size ["apple", "orange"]))
)
}
- Output:
2 2
Uiua
It would be more accurate to say this is the number of rows in an array.
⧻{"apple" "orange"}
- Output:
2
UNIX Shell
#!/bin/bash
array=("orange" "apple")
echo "${#array[@]}"
- Output:
2
Ursa
> decl string<> stream > append "two" "strings" stream > out (size stream) endl console 2 > out (size "test string") endl console 11 >
Vala
void main() {
string[] fruit = {"apple", "orange"};
stdout.printf("%d\n", fruit.length);
}
Note that any of the following array declarations could be used:
var fruit = new string[] { "apple", "orange" };
string[] fruit = new string[] { "apple", "orange" };
string[] fruit = { "apple", "orange" };
A shorter variant could also have been used:
void main() {
stdout.printf("%d\n", new string[] {"apples", "orange"}.length);
}
VBA
One-liner. Assumes array lower bound, which is not always safe.
Debug.Print "Array Length: " & UBound(Array("apple", "orange")) + 1
Works regardless of lower bound:
Dim funkyArray(7 to 8) As String
Public Function SizeOfArray(ar As Variant) As Long
SizeOfArray = UBound(ar) - LBound(ar) + 1
End Function
'call the function
Debug.Print "Array Length: " & SizeOfArray(funkyArray)
- Output:
In this instance, same output for both.
Array Length: 2
VBScript
arr = Array("apple","orange")
WScript.StdOut.WriteLine UBound(arr) - LBound(arr) + 1
- Output:
2
Visual Basic
The amount of elements in an array in Visual Basic is computed via the upper bound and lower bound indices. In Visual Basic the indices of arrays have to be numeric, but it is even possible to have negative values for them. Of course the element numbering is continuous.
' declared in a module
Public Function LengthOfArray(ByRef arr As Variant) As Long
If IsArray(arr) Then
LengthOfArray = UBound(arr) - LBound(arr) + 1
Else
LengthOfArray = -1
End If
End Function
' somewhere in the programm
' example 1
Dim arr As Variant
arr = Array("apple", "orange")
Debug.Print LengthOfArray(arr) ' prints 2 as result
' example 2
Dim arr As Variant
ReDim arr(-2 To -1)
arr(-2) = "apple"
arr(-1) = "orange"
Debug.Print LengthOfArray(arr) ' prints 2 as result
Visual Basic .NET
Module ArrayLength
Sub Main()
Dim array() As String = {"apple", "orange"}
Console.WriteLine(array.Length)
End Sub
End Module
- Output:
2
V (Vlang)
A len property is maintained for all V (Vlang) arrays.
// V, array length
// Tectonics: v run array-length.v
module main
// access array length
pub fn main() {
arr := ["apple", "orange"]
println(arr.len)
}
- Output:
prompt$ v run array-length.v 2
WDTE
let io => import 'io';
let a => ['apple'; 'orange'];
len a -- io.writeln io.stdout;
Wren
var arr = ["apple", "orange"]
System.print(arr.count)
- Output:
2
XLISP
(vector-length #("apple" "orange"))
Yabasic
dim fruta$(3)
read fruta$(1), fruta$(2), fruta$(3)
data "apple", "orange", "pear"
print arraysize(fruta$(),1)
print fruta$(2)
end
3 orange
Z80 Assembly
Arrays don't have an "end" as defined by the language, so there are a couple ways to mark the end of an array. One is with a null terminator, and the other is with a pre-defined size byte stored at the beginning. Using a null terminator isn't the best choice for a general-purpose array since it means your array cannot contain that value anywhere except at the end. However, since having the size already determined defeats the purpose of this task, the null-terminator method will be used for this example.
The simplest way to implement an array of variable-length strings is to have the array contain pointers to said strings rather than the strings themselves. That way, the elements of the array are of equal length, which makes any array much easier to work with.
org &8000
ld hl,TestArray
call GetArrayLength_WordData_NullTerminated
call Monitor ;show registers to screen, code omitted to keep this example short
ReturnToBasic:
RET
GetArrayLength_WordData_NullTerminated:
push hl ;we'll need this later
loop_GetArrayLength_WordData_NullTerminated
ld a,(hl) ;get the low byte
ld e,a ;stash it in E
inc hl ;next byte
ld a,(hl) ;get the high byte
dec hl ;go back to low byte, otherwise our length will be off.
or a ;compare to zero. This is a shorter and faster way to compare A to zero than "CP 0"
jr nz,keepGoing
cp e ;compare to E
jr z,Terminated_GetArrayLength ;both bytes were zero.
KeepGoing:
inc hl
inc hl ;next word
jp loop_GetArrayLength_WordData_NullTerminated ;back to start
Terminated_GetArrayLength:
pop de ;original array address is in DE
;or a ;normally it's best to clear the carry, but in this situation execution only arrives here after a compare that
;resulted in an equality to zero, which means the carry is guaranteed to be cleared.
sbc hl,de ;there is no sub hl,de; only sbc
srl h
rr l ;divide HL by 2, since each element is 2 bytes.
ret ;returns length in hl
TestArray:
word Apple,Orange
byte 0,0
Apple:
byte "Apple",0
Orange:
byte "Orange",0
- Output:
(HL contains length of the array) HL:0002
zkl
zkl doesn't support arrays natively, use lists instead.
List("apple", "orange").len().println() //-->2, == L("apple", "orange")
T("apple", "orange").len().println() //-->2, read only list (ROList)
Zig
const std = @import("std");
pub fn main() !void {
// left hand side type can be ommitted
const fruit: [2][]const u8 = [_][]const u8{ "apples", "oranges" };
const stdout_wr = std.io.getStdOut().writer();
// slices and arrays have an len field
try stdout_wr.print("fruit.len = {d}\n", .{fruit.len});
}
Zoea
program: array_length
input: [a,b,c]
output: 3
Zoea Visual
zonnon
module AryLength;
type
Vector = array 12 of string;
Matrix = array *,* of string;
var
a: Vector;
b: Matrix;
begin
writeln(len(a):4); (* len(a) = len(a,0) *)
b := new Matrix(10,11);
writeln(len(b,0):4); (* first dimension *)
writeln(len(b,1):4) (* second dimension *)
end AryLength.
- Simple
- Programming Tasks
- Solutions by Programming Task
- 11l
- 360 Assembly
- 6502 Assembly
- 68000 Assembly
- 8th
- AArch64 Assembly
- ABAP
- Ada
- ALGOL 68
- AntLang
- Apex
- APL
- AppleScript
- ARM Assembly
- Arturo
- ATS
- AutoHotkey
- AutoIt
- Avail
- AWK
- BaCon
- Bash
- BASIC
- Applesoft BASIC
- BASIC256
- Chipmunk Basic
- Commodore BASIC
- IS-BASIC
- True BASIC
- XBasic
- Batch File
- BBC BASIC
- Beef
- Brat
- Binary Lambda Calculus
- BQN
- C
- C sharp
- C++
- Ceylon
- Clipper/XBase++
- Clojure
- COBOL
- ColdFusion
- Common Lisp
- Component Pascal
- Crystal
- D
- Dart
- DataWeave
- Delphi
- Diego
- Dragon
- Dt
- Dyalect
- EasyLang
- EchoLisp
- Ecstasy
- Ela
- Elena
- Elixir
- Elm
- Emacs Lisp
- EMal
- Erlang
- Euphoria
- F Sharp
- Factor
- Fennel
- Forth
- Fortran
- FreeBASIC
- Frink
- FurryScript
- Futhark
- Futhark examples needing attention
- Examples needing attention
- FutureBasic
- Fōrmulæ
- Gambas
- Genie
- Go
- Groovy
- Harbour
- Haskell
- Hexiscript
- Hoon
- I
- Icon
- Unicon
- Idris
- Insitux
- J
- Janet
- Java
- JavaScript
- Joy
- Jq
- Jsish
- Julia
- K
- Klingphix
- Klong
- Kotlin
- Lambdatalk
- Lang
- Latitude
- LDPL
- Liberty BASIC
- LIL
- Limbo
- Lingo
- Little
- LiveCode
- Lua
- M2000 Interpreter
- Maple
- Mathematica
- Wolfram Language
- MATLAB
- Octave
- Modula-3
- Mercury
- Min
- MiniScript
- MiniZinc
- Nanoquery
- Neko
- NewLISP
- NGS
- Nim
- Nu
- Nutt
- Oberon-2
- Objeck
- OCaml
- Oforth
- Ol
- OmniMark
- Onyx
- OoRexx
- PARI/GP
- Pascal
- PascalABC.NET
- Perl
- Phix
- Phix/basics
- Phixmonti
- PHP
- Picat
- PicoLisp
- Pike
- PL/I
- Plorth
- Pony
- Potion
- PowerShell
- Processing
- Processing Python mode
- Prolog
- PureBasic
- Python
- QB64
- Quackery
- R
- Racket
- Raku
- Rapira
- REBOL
- Red
- Relation
- ReScript
- REXX
- Ring
- Robotic
- RPL
- Ruby
- Rust
- S-BASIC
- Scala
- Scheme
- Seed7
- SenseTalk
- Shen
- Sidef
- Simula
- SmallBASIC
- Smalltalk
- SNOBOL4
- SPL
- SQL
- Standard ML
- Stata
- Swift
- Symsyn
- Tailspin
- Tcl
- TI-83 BASIC
- Transd
- Uiua
- UNIX Shell
- Ursa
- Vala
- VBA
- VBScript
- Visual Basic
- Visual Basic .NET
- V (Vlang)
- WDTE
- Wren
- XLISP
- Yabasic
- Z80 Assembly
- Zkl
- Zig
- Zoea
- Zoea Visual
- Zonnon
- Pages with too many expensive parser function calls