Array length: Difference between revisions

=={{header|11l}}==

{{out}}

<pre>

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

Array length is computed at compilation time with the formula : (AEND-A)/L'A

ARRAYLEN START

USING ARRAYLEN,12

AEND DC 0C

PG DC CL25'Array length=' buffer

{{out}}

<pre>

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

LDA #(Array_End-Array) ;evaluates to 13

RTS

byte "apple",0

byte "orange",0

=={{header|68000 Assembly}}==

MOVE.B #(MyArray_End-MyArray)/4 ;evaluates to 2

RTS

DC.L Apple

DC.L Orange

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

["apples", "oranges"] a:len . cr

{{out}}

<pre>

=={{header|AArch64 Assembly}}==

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

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program lenAreaString64.s */

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

.include "../includeARM64.inc"

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

report z_array_length.

write: internal_table[ 1 ] , internal_table[ 2 ] , lines( internal_table ).

{{out}}

=={{header|Ada}}==

procedure Array_Length is

Ada.Text_IO.Put_Line (" Array Size : " & Integer'Image (Fruits'Length));

{{out}}

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

[]STRING fruits = ( "apple", "orange" );

=={{header|AntLang}}==

length[array]

=={{header|Apex}}==

=={{header|APL}}==

Output:

<pre>2</pre>

=={{header|AppleScript}}==

set theList to {"apple", "orange"}

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

{{out}}

<pre>fold (λx n -> 1 + n) 0</pre>

set xs to ["alpha", "beta", "gamma", "delta", "epsilon", ¬

end repeat

end fold

{{Out}}

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program lenAreaString.s */

.Ls_magic_number_10: .word 0x66666667

=={{header|Arturo}}==

{{out}}

=={{header|ATS}}==

#include

"share/atspre_staload.hats"

implement main0((*void*)) = ((*void*))

=={{header|AutoHotkey}}==

{{Out}}<pre>2</pre>

=={{header|AutoIt}}==

Local $aArray[2] = ["Apple", "Orange"]

ConsoleWrite("aArray[" & $i & "] = '" & $aArray[$i] & "'" & @CRLF)

Next

{{Out}}

<pre>Elements in array: 2

Using Avail's tuples and the `|_|` method:

=={{header|AWK}}==

Another method to count the elements of the array is by using a variant of for().

#

function countElements(array) {

print "String length:", array[1], length(array[1])

{{out}}

=={{header|BaCon}}==

BaCon knows three types of arrays, the UBOUND function can query all.

DECLARE fruit$[] = { "apple", "orange" }

meat$("first") = "chicken"

meat$("second") = "pork"

=={{header|Bash}}==

fruit=("apple" "orange" "lemon")

=={{header|BASIC}}==

X$(1) = "apple"

X$(2) = "orange"

==={{header|Applesoft BASIC}}===

20 A$(1) = "ORANGE"

30 A$(2) = "APPLE"

170 L$ = L$ + STR$ ( FN P(I))

180 L$ = L$ + " ": NEXT I

==={{header|BASIC256}}===

fruta$ = {"apple", "orange", "pear"}

print fruta$[1]

end

<pre>

3

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

20 A$(0) = "ORANGE"

30 A$(1) = "APPLE"

90 IF T=128 THEN N$=N$+"$": REM STRING

100 L=PEEK(AT+6): REM FIRST INDEX SIZE

{{Out}}

==={{header|True BASIC}}===

DIM fruta$(2)

READ fruta$(1), fruta$(2)

PRINT "La longitud del array fruta$ es" ; tamano

END

{{out}}

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$

PRINT "The length of the array 'fruit$' is "; SIZE(fruit$)

END

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.

@echo off

set /a arraylength+=1

goto loop

{{in}}

<pre>

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

{{works with|BBC BASIC for Windows}}

array$() = "apple", "orange"

PRINT "Number of elements in array = "; DIM(array$(), 1) + 1

PRINT "Number of bytes in all elements combined = "; SUMLEN(array$())

{{Out}}

=={{header|Brat}}==

p ["apple", "orange"].length

=={{header|BQN}}==

<code>≠</code> gives the length of an array in BQN.

[https://mlochbaum.github.io/BQN/try.html#code=4omgIDHigL8iYSLigL8r Try It!]

For static arrays:

#include <stdio.h>

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.

</p>

====Solution====

#define _CRT_NONSTDC_NO_WARNINGS // enable old-gold POSIX names in MSVS

return EXIT_SUCCESS;

{{output}}

<pre>There are 2 elements in an array with a capacity of 10 elements:

====An example why sizeof(A)/sizeof(E) may be a bad idea in C====

#define _CRT_NONSTDC_NO_WARNINGS // enable old-gold POSIX names in MSVS

return 0;

<p>

As we can see the ''sizeof(ArrayType)/sizeof(ElementType)'' approach mostly fail.

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

using System;

}

}

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 string[] { "apple", "orange" };

string[] fruit = { "apple", "orange" };

A shorter variant could also have been used:

using static System.Console;

}

}

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

However, C++ has an additional <code>std::array</code> type (amongst other collections) in its standard library:

#include <iostream>

#include <string>

std::cout << fruit.size();

return 0;

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.

std::list<std::string> fruitL({ "apples", "oranges" });

std::deque<std::string> fruitD({ "apples", "oranges" });

Of these, vector is probably the most widely used.

=={{header|Ceylon}}==

value array = ["apple", "orange"];

print(array.size);

=={{header|Clipper/XBase++}}==

* nizchka: March - 2016

* This is a Clipper/XBase++ of RosettaCode Array_Length

? LEN(FRUIT)

RETURN

Outputs:<pre>2</pre>

[[User:nizchka|nizchka]] 23:27, 16 March 2016 (UTC)

=={{header|Clojure}}==

(count ["apple" "orange"])

; OR alength if using Java arrays:

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

program-id. array-length.

.

{{out}}

<pre>$ cobc -xjd array-length.cob

=={{header|ColdFusion}}==

<cfset testArray = ["apple","orange"]>

<cfoutput>Array Length = #ArrayLen(testArray)#</cfoutput>

Outputs:<pre>Array Length = 2</pre>

[[User:grandnegus|Mike Knapp]] 15:57, 26 May 2016 (UTC)

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

(print (length #("apple" "orange")))

===Alternate solution===

I use [https://franz.com/downloads/clp/survey Allegro CL 10.1]

;; Project : Array length

(length my-array)

(terpri)

Output:

<pre>

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

{{works with|BlackBox Component Builder}}

MODULE AryLen;

IMPORT StdLog;

END AryLen.

Execute: ^Q AryLen.Do

{{out}}

=={{header|Crystal}}==

puts ["apple", "orange"].size

{{out}}

=={{header|D}}==

import std.stdio;

return 0;

}

Or a somewhat shorter...

import std.stdio;

["apple", "orange"].length.writeln;

}

=={{header|Dart}}==

arrLength(arr) {

return arr.length;

}

=={{header|DataWeave}}==

sizeOf(arr)

=={{header|Delphi}}==

showmessage( length(['a','b','c']).ToString );

=={{header|Diego}}==

me_msg()_array()_values(apple,orange)_length();

{{out}}

=={{header|Dragon}}==

a = ["apple","orange"]

show b

=={{header|Dyalect}}==

=={{header|EasyLang}}==

<lang>fruit$[] = [ "apples" "oranges" ]

=={{header|EchoLisp}}==

(length '("apple" "orange")) ;; list

→ 2

(vector-length #("apple" "orange")) ;; vector

→ 2

=={{header|Ela}}==

=={{header|Elena}}==

ELENA 5.0 :

var array := new string[]{"apple", "orange"};

var length := array.Length;

=={{header|Elixir}}==

2

iex(2)> tuple_size( {"apple", "orange"} ) # Tuple

=={{header|Elm}}==

import Array

import Html

|> Basics.toString

|> Html.text

=={{header|Emacs Lisp}}==

<code>length</code> also accepts a list or a string.

=={{header|Erlang}}==

1> length(["apple", "orange"]). %using a list

2

1> tuple_size({"apple", "orange"}). %using a tuple

2

=={{header|Euphoria}}==

sequence s = {"apple","orange",2.95} -- Euphoria doesn't care what you put in a sequence

1 -- 2.95 is an atomic value

=={{header|F_Sharp|F#}}==

Or:

=={{header|Factor}}==

{ "apple" "orange" } length

=={{header|Forth}}==

REPEAT

DROP

Test code at Forth console

=={{header|Fortran}}==

For a simple example, the WRITE(6,*) suffices: write to standard output (the 6), in free-format (the *).

MODULE EXAMPLE

CONTAINS

WRITE (6,*) "L. bound",LBOUND(ARRAY),", U. bound",UBOUND(ARRAY)

END

Output:

=={{header|FreeBASIC}}==

Dim fruit(1) As String = {"apple", "orange"}

Print

Print "Press any key to quit the program"

{{out}}

=={{header|Frink}}==

a = ["apple", "orange"]

println[length[a]]

=={{header|FurryScript}}==

COUNT[ 0 SW ~| COUNT_STEP# 0 SW SU ]

COUNT_STEP[ DR 1 SU ]

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

fun length(as: []int): int = (shape as)[0]

=={{header|FutureBasic}}==

NSUInteger count = fn ArrayCount( ''array'' ). Example:

window 1

print fn ArrayCount( @[@"apple",@"orange",@"cherry",@"grape",@"lemon"] )

HandleEvents

{{out}}

<pre>

=={{header|Gambas}}==

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

Dim siList As Short[] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]

Print siList.Count

Output:

<pre>

=={{header|Genie}}==

/* Array length, in Genie */

init

arr:array of string = {"apple", "orange"}

stdout.printf("%d ", arr.length)

{{out}}

=={{header|Go}}==

import "fmt"

fmt.Printf("Length of %v is %v.\n", arr, len(arr))

=={{header|Groovy}}==

def fruits = ['apple','orange']

println fruits.size()

=={{header|Harbour}}==

LOCAL aFruits := {"apple", "orange"}

Qout( Len( aFruits ) ) // --> 2

=={{header|Haskell}}==

=={{header|hexiscript}}==

let a[0] "apple"

let a[1] "orange"

=={{header|Hoon}}==

=={{header|i}}==

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

=={{header|Idris}}==

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

2

$ 'apple';'orange'

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'

This might be a clearer concept with a few more examples. Here's an array with two dimensions:

apple

orange

2 6

#>'apple';'orange'

And, here's an array with no dimensions:

<lang> 9001

1

$9001

You can count the number of dimensions of an array (the length of the list of lengths) using <code>#$array</code>:

#$9001

0

1

#$>'apple';'orange'

=={{header|Janet}}==

(def our-array @["apple" "orange"])

(length our-array)

{{out}}

=={{header|Java}}==

public static void main(String[] args) {

System.out.println(new String[]{"apple", "orange"}.length);

}

=={{header|JavaScript}}==

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

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.

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:

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

return list.slice(-1)[0] || defaultValue;

=={{header|jq}}==

Output:

Note that the ''length'' filter is polymorphic, so for example the empty string (""), the empty list ([]), and ''null'' all have ''length'' 0.

=={{header|Jsish}}==

var arr = new Array('apple', 'orange');

puts(arr.length);

{{out}}

=={{header|Julia}}==

a = ["apple","orange"]

length(a)

=={{header|Klingphix}}==

( "apple" "orange" ) len print

{{out}}

<pre>2</pre>

=={{header|Klong}}==

#["apple" "orange"]

=={{header|Kotlin}}==

println(arrayOf("apple", "orange").size)

=={{header|Lambdatalk}}==

{A.length {A.new 1 2 3}}

-> 3

=={{header|Latitude}}==

In Latitude, <code>length</code> and <code>size</code> are synonymous and will both retrieve the size of a collection.

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

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

FruitList$(0)="apple" 'assign 2 cells of a list array

FruitList$(1)="orange"

print ")"

end sub

{{out}}

<pre>

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.

set a [list "apple"]

append a "orange"

print [count $a]

{{out}}

=={{header|Limbo}}==

include "sys.m";

a := array[] of {"apple", "orange"};

sys->print("length of a: %d\n", len a);

=={{header|Lingo}}==

put fruits.count

=={{header|Little}}==

=={{header|LiveCode}}==

split fruit using comma

=={{header|Lua}}==

fruits = {"apple", "orange"}

print(#fruits)

end

{{out}}

<pre>

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

\\ A is a pointer to array

A=("Apple", "Orange")

Dim K(1,1,1,1,1,1) ' Maximum 10 dimensions

Print Len(K()=1 ' True

=={{header|Maple}}==

{{out}}

<pre>

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

=={{header|MATLAB}} / {{header|Octave}}==

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.

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

IMPORT IO;

BEGIN

IO.PutInt(NUMBER(Arr));

=={{header|Mercury}}==

:- interface.

main(!IO) :-

Array = array(["apples", "oranges"]),

=={{header|min}}==

{{works with|min|0.19.3}}

{{out}}

<pre>

=={{header|MiniScript}}==

fruits = ["apple", "orange"]

print fruits.len

=={{header|MiniZinc}}==

array[int] of int: arr = [1,2,3];

var int: size = length(arr);

output [show(size),"\n"];

=={{header|Nanoquery}}==

fruit[0] = "apple"

fruit[1] = "orange"

println len(fruit)

=={{header|Neko}}==

=={{header|NewLISP}}==

; Nehal-Singhal 2018-05-25

=={{header|NGS}}==

# same

=={{header|Nim}}==

{{out}}

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

{{works with|oo2c}}

MODULE ArrayLength;

IMPORT

Out.String("length: ");Out.Int(Length(a),0);Out.Ln

END ArrayLength.

{{out}}

<pre>

=={{header|Objeck}}==

class Test {

function : Main(args : String[]) ~ Nil {

fruit->Size()->PrintLine();

}

=={{header|OCaml}}==

Array.length [|"apple"; "orange"|];;

=={{header|Oforth}}==

=={{header|Ol}}==

All of these methods are equivalent.

(print (vector-length (vector "apple" "orange")))

(print (vector-length #("apple" "orange")))

(print (size #("apple" "orange")))