Rosetta Code

Creating an Array: Difference between revisions

Page Discussion

Creating an Array (view source)

Revision as of 15:07, 29 November 2019

13,809 bytes removed ,  4 years ago
Blanked page since people can't / don't read
(Using Template:Libheader, instead of Template:Library)
(Blanked page since people can't / don't read)
 
(116 intermediate revisions by 42 users not shown)
Line 1:
{{taskDeprecatedTask}}
'''Please do not add new code, and merge existing code to the [[Arrays]] task.'''
This task is about [[numeric arrays]]. For '''hashes''' or '''associative arrays''', please see [[Creating an Associative Array]].
 
This task is about numerically-indexed arrays. For '''hashes''' or '''associative arrays''', please see [[Creating an Associative Array]].
 
In this task, the goal is to create an [[array]]. Mention if the [[array base]] begins at a number other than zero.
In addition, demonstrate how to initialize an array variable with data.
 
=={{header|ActionScript}}==
// ActionScript arrays are zero-based
//
// creates an empty array
var arr1:Array = new Array();
// creates an array with 3 numerical values
var arr2:Array = new Array(1,2,3);
//
// or just use the shorthand
var u:Array = [];
var v:Array = [1,2,3];
 
=={{header|Ada}}==
'''Compiler:''' [[GCC]] 4.1.2
 
Ada array indices may begin at any value, not just 0 or 1
type Arr is array (Integer range <>) of Integer;
Uninitialized : Arr (1 .. 10);
Initialized_1 : Arr (1 .. 20) := (others => 1);
Initialized_2 : Arr := (1 .. 30 => 2);
Const : constant Arr := (1 .. 10 => 1, 11 .. 20 => 2, 21 | 22 => 3);
Centered : Arr (-50..50) := (0 => 1, Others => 0);
Ada arrays may be indexed by enumerated types, which are discrete non-numeric types
type Days is (Mon, Tue, Wed, Thu, Fri, Sat, Sun);
type Activities is (Work, Fish);
type Daily_Activities is array(Days) of Activities;
This_Week : Daily_Activities := (Mon..Fri => Work, Others => Fish);
 
=={{header|ALGOL 68}}==
As with all [[ALGOL 68]] declarations the programmer has the choice of using the full declaration syntax, or using [[syntactic sugar]] - c.f. "sugared" variables below.
 
Example of array of 10 integer types:
REF []INT numbers = HEAP [1:10] INT;
HEAP [1:10]INT sugared hnumbers; # from global memory #
LOC [1:10]INT sugared lnumbers1; # from the stack #
[10]INT sugared lnumbers2; # from the stack - LOC scope is implied #
Note that the array can be taken from the heap, or stack.
 
Example of array of 3 string types:
[]STRING cwords = ( "these", "are", "arrays" ); # array is a constant and read-only (=) #
[3]STRING vwords := ( "these", "are", "arrays" ); # array is a variable and modifiable (:=) #
You can also declare the size of the array and initialize the values at the same time:
REF []INT more numbers = LOC [3]INT := ( 21, 14 ,63 );
[]INT sugared more cnumbers = ( 21, 14 ,63 );
[3]INT sugared more vnumbers := ( 21, 14 ,63 );
For Multi-Dimensional arrays you declare them the same except for a comma in the type declaration.
The following creates a 3x2 int matrix
REF [][]INT number matrix = LOC [3][2] INT;
[3,2]INT sugared number matrix1; # an matrix of integers #
[3][2]INT sugared number matrix2; # an array of arrays of integers #
As with the previous examples you can also initialize the values of the array, the only
difference being each row in the matrix must be enclosed in its own braces.
[][]STRING string matrix = ( ("I","swam"), ("in","the"), ("freezing","water") );
or
REF [][] STRING funny matrix = LOC [2][2]STRING := ( ("clowns", "are") , ("not", "funny") );
[2][2] STRING sugared funny matrix := ( ("clowns", "are") , ("not", "funny") );
Further, the arrays can start at any number:
[-10:10] INT balanced; # for example -10 #
If the array is expected to change size in future, then the programmer can also declare it FLEX.
FLEX [-10:10] INT flex balanced;
This next piece of code creates an array of references to integers. The value of
each integer "pointed at" is the square of it's index in the array.
[-10:10] REF INT array of pointers to ints;
FOR index FROM LWB array of pointers to ints TO UPB array of pointers to ints DO
array of pointers to ints[index] := HEAP INT := i*i # allocate global memory #
OD
 
=={{header|AppleScript}}==
AppleScript arrays are called lists:
set empty to {}
set ints to {1, 2, 3}
 
Lists can contain any objects including other lists:
set any to {1, "foo", 2.57, missing value, ints}
'''Bold text'''
 
=={{header|BASIC}}==
'''Interpeter:''' [[QuickBasic]] 4.5, PB 7.1
 
REM Force index to start at 1..n
OPTION BASE 1
 
REM Force index to start at 0..n
OPTION BASE 0
 
REM Specify that the array is dynamic and not static
'$DYNAMIC
DIM SHARED myArray(-10 TO 10, 10 TO 30) AS STRING
REDIM SHARED myArray(20, 20) AS STRING
myArray(1,1) = "Item1"
myArray(1,2) = "Item2"
 
=={{header|C}}==
'''Compiler:''' [[gcc]], [[MSVC]], [[BCC]], [[Watcom]]
 
Dynamic
#include <stdlib.h> /* for malloc */
#include <string.h> /* for memset */
int n = 10 * sizeof(int);
int *myArray = (int*)malloc(n);
if(myArray != NULL)
{
memset(myArray, 0, n);
myArray[0] = 1;
myArray[1] = 2;
free(myArray);
myArray = NULL;
}
 
Static
 
int myArray2[10] = { 1, 2, 0}; /* 3..9 := 0 */
 
=={{header|C++}}==
'''Compiler:''' [[g++]], [[Visual C++]], [[BCC]], [[Watcom]]
 
 
Using dynamically-allocated memory:
const int n = 10;
int* myArray = new int[n];
if(myArray != NULL)
{
myArray[0] = 1;
myArray[1] = 2;
delete[] myArray;
myArray = NULL;
}
 
Using fixed memory:
int myArray2[10] = { 1, 2, 0}; /* 3..9 := 0 */
 
{{libheader|STL}}
// STL
std::vector<int> myArray3(10);
myArray3.push_back(1);
myArray3.push_back(2);
 
{{libheader|Qt}}
// Qt
QVector<int> myArray4(10);
myArray4.push_back(1);
myArray4.push_back(2);
 
{{libheader|MFC}}
// MFC
CArray<int,int> myArray5(10);
myArray5.Add(1);
myArray5.Add(2);
 
=={{header|C sharp|C#}}==
Example of array of 10 int types:
 
int[] numbers = new int[10];
 
Example of array of 3 string types:
 
string[] words = { "these", "are", "arrays" };
 
You can also declare the size of the array and initialize the values at the same time:
 
int[] more_numbers = new int[3]{ 21, 14 ,63 };
 
 
For Multi-Dimensional arrays you declare them the same except for a comma in the type declaration.
 
The following creates a 3x2 int matrix
int[,] number_matrix = new int[3,2];
 
As with the previous examples you can also initialize the values of the array, the only difference being each row in the matrix must be enclosed in its own braces.
 
string[,] string_matrix = { {"I","swam"}, {"in","the"}, {"freezing","water"} };
 
or
 
string[,] funny_matrix = new string[2,2]{ {"clowns", "are"} , {"not", "funny"} };
 
=={{header|Clean}}==
Array denotations are overloaded in Clean, therefore we explicitly specify the types. There are lazy, strict, and unboxed array.
===Lazy array===
Create a lazy array of strings using an array denotation.
array :: {String}
array = {"Hello", "World"}
Create a lazy array of floating point values by sharing a single element.
array :: {Real}
array = createArray 10 3.1415
Create a lazy array of integers using an array (and also a list) comprehension.
array :: {Int}
array = {x \\ x <- [1 .. 10]}
===Strict array===
Create a strict array of integers.
array :: {!Int}
array = {x \\ x <- [1 .. 10]}
===Unboxed array===
Create an unboxed array of characters, also known as <tt>String</tt>.
array :: {#Char}
array = {x \\ x <- ['a' .. 'z']}
 
=={{header|ColdFusion}}==
Creates a one-dimensional Array
<cfset arr1 = ArrayNew(1)>
Creates a two-dimensional Array in CFScript
<cfscript>
arr2 = ArrayNew(2);
</cfscript>
''ColdFusion Arrays are '''NOT''' zero-based, they begin at index '''1'''''
 
=={{header|Common Lisp}}==
Creates a one-dimensional array of length 10. The initial contents are undefined.
(make-array 10)
Creates a two-dimensional array with dimensions 10x20.
(make-array '(10 20))
<tt>make-array</tt> may be called with a number of optional arguments.
(make-array 4 :element-type 'integer :initial-contents '(1 2 3 4) :adjustable t)
 
=={{header|D}}==
'''Compiler:''' [[DMD]],[[GDC]]
 
// dynamic array
int[] numbers = new int[5];
// static array
int[5] = [0,1,2,3,4];
 
=={{header|E}}==
[] # immutable, empty
[1,9,17] # immutable, 3 elements
[].diverge() # mutable, empty
[].diverge(int) # mutable, integers only
 
=={{header|Forth}}==
Forth has a variety of ways to allocate arrays of data, though it has no built-in array handling words, favoring pointer manipulation.
 
Static array of 200 cells, uninitialized:
 
create MyArray 200 cells allot
here MyArray - cell / constant MyArraySize
 
Static array containing the numbers 1 to 5
 
create MyArray 1 , 2 , 3 , 4 , 5 ,
here MyArray - cell / constant MyArraySize
 
Dynamic array allocation:
0 value MyArray
200 cells allocate throw to MyArray
 
Dynamic array free:
MyArray free throw
0 to MyArray
 
=={{header|Fortran}}==
Default case:
 
integer a(10)
 
this will have ten elements. Counting starts at 1. If a zero-based array is needed, declare like this:
 
integer a(0:9)
 
this mechanism can be extended to any numerical indices, and allowed number of dimensions (and of course to other data types than integers). For example
 
real*8 (25:29,12)
 
will be an two-dimensional, 5x12-array of 8-byte floats, where the first dimension can be addressed numerically as 25, 26, 27, 28 or 29 (and the second dimension as 1 .. 12).
 
 
=={{header|IDL}}==
IDL doesn't really distinguish between scalars and arrays - the same operations that can create the one can ''usually'' create the other as well.
 
a = 3
help,a
A INT = 3
print,a^2
9
 
a = [3,5,8,7]
help,a
A INT = Array[4]
print,a^2
9 25 64 49
 
=={{header|J}}==
"Creating an array" is topic seldom discussed in J as ''every'' verb takes array argument(s) and returns an array result (that is, ''everything'' creates an array). For example:
 
a=: 3 4 $ 3 1 4 1 5 9 2 6 5 3 5 8 NB. make a 3-by-4 table
a NB. display a
3 1 4 1
5 9 2 6
5 3 5 8
b=: 10 20 30 NB. make a 3-element list
a + b NB. add corresponding items of a and b
13 11 14 11
25 29 22 26
35 33 35 38
] c=: 3 4 $ 'eleemosynary' NB. make a 3-by-4 character table and display it
elee
mosy
nary
|."1 c NB. reverse each item of c
eele
ysom
yran
 
Both the <tt>a+b</tt>and the <tt>|."1 c</tt> expressions create arrays.
 
=={{header|Java}}==
For example for an array of 10 int values:
int[] intArray = new int[10];
 
Creating an array of Strings:
 
String[] s = {"hello" , "World" };
 
=={{header|JavaScript}}==
var myArray = new Array();
var myArray1 = new Array(5); // gotcha: preallocated array with five empty elements, not [ 5 ].
var myArray2 = new Array("Item1","Item2");
var myArray3 = ["Item1", "Item2"];
 
=={{header|LSE64}}==
10 myArray :array
 
=={{header|MAXScript}}==
'''Interpreter:''' [[3D Studio Max]] 8
myArray = #()
myArray2 = #("Item1", "Item2")
 
=={{header|mIRC Scripting Language}}==
'''Interpeter:''' mIRC Script Editor<br>
'''Depends on:''' [[mArray Snippet]]
alias creatmearray { .echo -a $array_create(MyArray, 5, 10) }
 
=={{header|OCaml}}==
Using an array literal:
 
let array = [| 1; 2; 3; 4; 5 |];;
 
To create an array of five elements with the value 0:
 
let num_items = 5 and initial_value = 0;;
let array = Array.make num_items initial_value
 
To create an array with contents defined by passing each index to a callback (in this example, the array is set to the squares of the numbers 0 through 4):
 
let callback index = index * index;;
let array = Array.init 5 callback
 
 
=={{header|Perl}}==
'''Interpreter:''' [[Perl]] 5
 
my @empty;
my @empty_too = ();
 
my @populated = ('This', 'That', 'And', 'The', 'Other');
print $populated[2];
# And
my $aref = ['This', 'That', 'And', 'The', 'Other'];
print aref->[2];
# And
 
# having to quote like that really sucks, and that's why we got syntactic sugar
my @wakey_wakey = qw(coffee sugar cream);
push @wakey_wakey, 'spoon';
# add spoon to right-hand side
my $cutlery = pop @wakey_wakey;
# remove spoon
unshift @wakey_wakey, 'cup';
# add cup to left-hand side
my $container = shift @wakey_wakey;
# remove cup
 
my @multi_dimensional = (
[0, 1, 2, 3],
[qw(a b c d e f g)],
[qw(! $ %
 
=={{header|Pop11}}==
Pop11 distinguishes between vectors and arrays. Vectors are one dimensional and the lowest index is 1. There is special shorthand syntax to create vectors:
 
;;; General creation of vectors, create initialized vector.
lvars v1 = consvector(1, 'a', "b", 3);
;;; Shorthand notation
lvars v2 = {1 'a' b};
;;; Create vector filled with word undef (to signal that elements
;;; are uninitialized)
lvars v3 = initv(3)
 
Pop11 arrays may have arbitrary lower and upper bounds:
 
;;; Create array with first index ranging from 2 to 5 and second
;;; index from -1 to 1, initialized with 0
vars a1 = newarray([2 5 -1 1], 0);
 
=={{header|Python}}==
List are mutable arrays. You can put anything into a list, including other lists.
 
empty = []
numbers = [1, 2, 3, 4, 5]
zeros = [0] * 10
anything = [1, 'foo', 2.57, None, zeros]
digits = range(10) # 0, 1 ... 9
evens = range(0,10,2) # 0, 2, 4 ... 8
evens = [x for x in range(10) if not x % 2] # same using list comprehension
words = 'perl style'.split()
 
Tuples are immutable arrays. Note hat tuples are defined by the "," - the parenthesis are optional:
 
empty = ()
numbers = (1, 2, 3, 4, 5)
zeros = (0,) * 10
anything = (1, 'foo', 2.57, None, zeros)
 
Both lists and tuples can be created from other iterateables:
 
<pre>
>>> list('abc')
['a', 'b', 'c']
>>> tuple('abc')
('a', 'b', 'c')
>>> list({'a': 1, 'b': 2, 'c': 3})
['a', 'c', 'b']
>>> open('file', 'w').write('1\n2\n3\n')
>>> list(open('file'))
['1\n', '2\n', '3\n']
</pre>
 
=={{header|Raven}}==
[ 1 2 3.14 'a' 'b' 'c' ] as a_list
a_list print
 
list (6 items)
0 => 1
1 => 2
2 => 3.14
3 => "a"
4 => "b"
5 => "c"
 
=={{header|Ruby}}==
I've used the same examples as the Python-example above.
.
empty = []
#or:
empty = Array.new
numbers = [1, 2, 3, 4, 5]
zeros = [0] * 10
anything = [1, 'foo', 2.57, zeros]
 
=={{header|Scheme}}==
Lists are more often used in Scheme than vectors.
 
Using an array literal:
 
#(1 2 3 4 5)
 
To create an array of five elements:
 
(make-vector 5)
 
To create an array of five elements with the value 0:
 
(make-vector 5 0)
 
=={{header|Toka}}==
Toka allows creation of an array using is-array. Access to the elements is done using get-element, put-element, get-char-element, and put-char-element functions. You can not initialize the values automatically using the core array functions.
 
100 cells is-array foo
100 chars is-array bar
Thundergnat
10,327

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/6061...6178"