Array length: Difference between revisions

[[Category:Simple]]

 

;Task:

 

 

<br><br>

 

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

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

{{out}}

<pre>

2

</pre>

=={{header|Ada}}==

 

 

procedure Array_Length is

 

begin

 

{{out}}

 

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

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

 

=={{header|AntLang}}==

length[array]

 

=={{header|APL}}==

Output:

<pre>2</pre>

 

=={{header|AppleScript}}==

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

count theList

-- or

number of items in theList

{{out}}

<pre>2</pre>

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

 

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

end repeat

end fold

 

{{Out}}

 

<pre>{12, 12, "mu", "mu"}</pre>

 

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

aArray[0] = 'Apple'

aArray[1] = 'Orange'</pre>

 

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

String length: apple 5

</pre>

 

=={{header|BASIC}}==

X$(1) = "apple"

X$(2) = "orange"

 

=={{header|Brat}}==

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

 

 

C features two kinds of arrays: static (compile-time, fixed size) and dynamic (allocated at runtime).

 

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.

Thus, the length of an array parameter may not be required directly - a dedicated length parameter would be required.

 

 

 

 

 

{

}

 

 

 

 

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

 

=={{header|D}}==

import std.stdio;

 

return 0;

}

 

Or a somewhat shorter...

import std.stdio;

 

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

}

 

 

=={{header|EchoLisp}}==

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

→ 2

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

→ 2

 

=={{header|Ela}}==

 

=={{header|Elm}}==

import Array

import Html

|> Array.fromList

|> Array.length

|> Html.text

 

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

 

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

 

 

2

 

 

 

 

 

 

 

 

 

 

 

 

 

 

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

 

 

 

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

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

END

 

Output:

L. bound -1 , U. bound 1

 

 

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

 

 

import "fmt"

 

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

 

=={{header|Groovy}}==

 

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

println fruits.size()

 

 

 

 

 

 

 

 

 

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

9001

#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|Java}}==

 

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

 

 

Output:

 

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

=={{header|Julia}}==

 

a = ["apple","orange"]

length(a)

 

=={{header|Kotlin}}==

 

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

 

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

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

FruitList$(1)="orange"

print ")"

end sub

{{out}}

<pre>

DIM array$(10)

</pre>

 

=={{header|Little}}==

 

=={{header|LiveCode}}==

 

split fruit using comma

 

=={{header|Lua}}==

fruits = {"apple", "orange"}

print(#fruits)

-- For this you can use this short function:

function size (tab)

end

 

{{out}}

<pre>

2

</pre>

 

=={{header|Maple}}==

{{out}}

<pre>

</pre>

 

 

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

 

 

=={{header|NGS}}==

# same

 

=={{header|Nim}}==

 

{{out}}

The length of the fruit array is 2

</pre>

 

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

 

 

=={{header|ooRexx}}==

/* REXX */

a = .array~of('apple','orange')

say e

End

{{out}}

<pre>2 elements

 

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

length(array) \\ == 2

 

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.

{{works with|Free Pascal|2.6.2}}

 

#!/usr/bin/instantfpc

//program ArrayLength;

WriteLn('Length of Fruits by bounds : ', High(Fruits) - Low(Fruits) + 1);

END.

 

{{out}}

Length of Fruits by bounds : 2

 

</pre>

 

The way to get the number of elements of an array in Perl is to put the array in scalar context.

 

 

scalar @array; # 5

takes_a_scalar @array;

 

 

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.

 

length @array; # 1

 

print 'the length of @array is on the order of ';

print 10 ** (length( @array )-1); # 100

 

 

{{out}}

<pre>

=={{header|PHP}}==

 

 

=={{header|PicoLisp}}==

-> 2

 

=={{header|Pike}}==

{

array fruit = ({ "apple", "orange" });

write("%d\n", sizeof(fruit));

 

{{out}}

 

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

Put Edit('Array a has',(hbound(a)-lbound(a)+1),' elements.')

(Skip,a,f(2),a);

Put Skip Data(a);

{{out}}

<pre>

Array a has 2 elements.

 

=={{header|Potion}}==

 

=={{header|PowerShell}}==

$Array = @( "Apple", "Orange" )

$Array.Count

{{out}}

<pre>

2

2</pre>

 

=={{header|Prolog}}==

 

X = 2

 

 

=={{header|PureBasic}}==

EnableExplicit

Define Dim fruit$(1); defines array with 2 elements at indices 0 and 1

CloseConsole()

EndIf

 

=={{header|Python}}==

2

 

=={{header|R}}==

a <- c('apple','orange') # create a vector containing "apple" and "orange"

length(a)

{{out}}

<pre>

=={{header|Racket}}==

{{trans|EchoLisp}}

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

{{out}}

<pre>2

2</pre>

 

=={{header|REXX}}==

* The compond variable a. implements an array

* By convention, a.0 contains the number of elements

a.z=arg(1)

a.0=z

{{out}}

<pre>There are 2 elements in the array:

=={{header|Ring}}==

 

 

=={{header|Ruby}}==

 

 

=={{header|Rust}}==

By default arrays are immutable in rust.

 

fn main() {

let array = ["foo", "bar", "baz", "biff"];

println!("the array has {} elements", array.len());

}

 

=={{header|Scala}}==

 

println(Array("apple", "orange").length)

 

 

=={{header|Sidef}}==

say arr.len; #=> 2

 

 

 

 

=={{header|SNOBOL4}}==

ar<1,1> = 'apple'

ar<1,2> = 'first'

ar<2,2> = 'second'

OUTPUT = IDENT(DATATYPE(ar), 'ARRAY') PROTOTYPE(ar)

{{out}}<pre>2,2</pre>

 

=={{header|SQL}}==

 

 

=={{header|Standard ML}}==

val a = Array.fromList ["apple", "orange"]

in

Array.length a

 

 

 

 

{{out}}<pre>2</pre>

 

=={{header|Tcl}}==

<!-- http://ideone.com/uotEvm -->

 

set mylistA {apple orange} ;# actually a string

set mylistA "Apple Orange" ;# same - this works only for simple cases

set lenB [llength $mylistB]

puts "$mylistB : $lenB"

 

{{out}}

{{works with|TI-83 2.55MP}}

Use function <code>dim()</code>.

{{out}}

<pre>

6

</pre>

 

11

> </pre>

 

=={{header|VBA}}==

 

{{Out}}

<pre>Array Length: 2</pre>

 

=={{header|VBScript}}==

 

{{Out}}

<pre>2</pre>

 

=={{header|Wren}}==

 

=={{header|XLISP}}==

 

=={{header|zkl}}==

zkl doesn't support arrays natively, use lists instead.