Array concatenation: Difference between revisions

 

=={{header|ACL2}}==

This is for lists, not arrays; ACL2's array support is limited.

 

=={{header|ActionScript}}==

var array2:Array = new Array(4, 5, 6);

=={{header|Ada}}==

In [[Ada]] arrays are concatenated using the operation &. It works with any one dimensioned array:

X : T := (1, 2, 3);

 

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

<!-- {{not tested with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8.8d.fc9.i386]}} -->

Includes operators for ''appending'' and ''prefixing'' an array to an existing flexible array:

MODE ARGLIST = FLEX[0]ARGTYPE;

 

 

VOID(a +=: b);

<pre>

a + b +1 +2 +3 +4 +5

a +=: b +1 +2 +3 +4 +5 +3 +4 +5

</pre>

=={{header|APL}}==

1 2 3 , 4 5 6

1 2 3 4 5 6

 

=={{header|AutoHotkey}}==

=== True Arrays ===

{{works with|AutoHotkey_L}}

List2 := [4, 5, 6]

cList := Arr_concatenate(List1, List2)

res .= ", " value

return "[" SubStr(res, 3) "]"

=== Legacy versions ===

[[AutoHotkey_Basic]] does not have real Arrays, but the user can implement them quite easily. For example:

List2 = 4,5,6

 

List .= (A_Index = 1 ? "" : ",") %Array%%A_Index%

Return, List

Message box shows:

<pre>1,2,3,4,5,6</pre>

 

_ArrayConcatenate($avArray, $avArray2)

Func _ArrayConcatenate(ByRef $avArrayTarget, Const ByRef $avArraySource, $iStart = 0)

Return $iUBoundTarget + $iUBoundSource

EndFunc ;==>_ArrayConcatenate

 

=={{header|AWK}}==

BEGIN {

split("cul-de-sac",a,"-")

}

 

for (i in a) {

c[++nc]=a[i]

c[++nc]=b[i]

}

 

=={{header|Babel}}==

 

{{works with|BBC BASIC for Windows}}

a() = 1, 2, 3, 4

b() = 5, 6, 7, 8, 9

SYS "RtlMoveMemory", ^c(0), ^a(0), s%*na%

SYS "RtlMoveMemory", ^c(na%), ^b(0), s%*nb%

 

=={{header|Bracmat}}==

=={{header|Burlesque}}==

 

blsq ) {1 2 3}{4 5 6}_+

{1 2 3 4 5 6}

 

=={{header|C}}==

A way to concatenate two C arrays when you know their size (and usually so it is)

#include <stdio.h>

#include <string.h>

free(c);

return EXIT_SUCCCESS;

 

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

#include <iostream>

 

for (int i = 0; i < a.size(); ++i)

std::cout << "a[" << i << "] = " << a[i] << "\n";

 

{{works with|C++11}}

Similar to above but using initialization schematics.

 

#include <iostream>

 

std::cout << std::endl;

return 0;

 

 

 

 

 

 

 

 

 

=={{header|Clojure}}==

The inputs can be any collection, including Java arrays, and returns a lazy sequence of the elements.

 

 

=={{header|CoffeeScript}}==

# like in JavaScript

a = [1, 2, 3]

b = [4, 5, 6]

c = a.concat b

 

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

<code>[http://www.lispworks.com/documentation/HyperSpec/Body/f_concat.htm concatenate]</code> is a general function for concatenating any type of sequence. It takes the type of sequence to produce, followed by any number of sequences of any type.

 

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

BlackBox Component Builder

MODULE ArrayConcat;

IMPORT StdLog;

 

END ArrayConcat.

Execute: ^Q ArrayConcat.Do <br/>

<pre>

1> [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

 

</pre>

=={{header|D}}==

void main() {

writeln(a, " ~ ", b, " = ", a ~ b);

<pre>[1, 2] ~ [4, 5, 6] = [1, 2, 4, 5, 6]</pre>

 

=={{header|Delphi}}==

TReturnArray = array of integer; //you need to define a type to be able to return it

 

Finalize(r1); //IMPORTANT!

ShowMessage(IntToStr(High(r1)));

 

=={{header|E}}==

 

 

 

 

=={{header|ECL}}==

 

A := [1, 2, 3, 4];

B := [5, 6, 7, 8];

 

 

=={{header|Efene}}==

using the ++ operator and the lists.append function

 

@public

run = fn () {

io.format("~p~n", [C])

io.format("~p~n", [D])

 

=={{header|EGL}}==

{{works with|EDT}}

program ArrayConcatenation

function main()

end

end

 

=={{header|Elena}}==

 

 

 

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

 

=={{header|Erlang}}==

 

On the shell,

1> [1, 2, 3] ++ [4, 5, 6].

[1,2,3,4,5,6]

[1,2,3,4,5,6]

3>

 

=={{header|Euphoria}}==

s1 = {1,2,3}

s2 = {4,5,6}

s3 = s1 & s2

 

{1,2,3,4,5,6}

 

=={{header|F Sharp|F#}}==

Array concatenation.

let b = [|4; 5; 6;|]

List concatenation (@ and List.append are equivalent).

let y = [4; 5; 6]

let z1 = x @ y

 

=={{header|Factor}}==

 

'''Example''':

( scratchpad ) { 1 2 } { 3 4 } append .

 

=={{header|Fantom}}==

In fansh:

 

> a := [1,2,3]

> b := [4,5,6]

> a

[1,2,3,4,5,6]

 

Note 'addAll' is destructive. Write 'a.dup.addAll(b)' to create a fresh list.

 

=={{header|Forth}}==

2dup + >r swap move r> ;

: cat ( a2 u2 a1 u1 -- a3 u1+u2 )

801842600: 03 00 00 00 00 00 00 00 - 04 00 00 00 00 00 00 00 ................

801842610: 05 00 00 00 00 00 00 00 - ........

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

 

allocate(c(size(a)+size(b)))

 

 

 

=={{header|Frink}}==

a = [1,2]

b = [3,4]

a.pushAll[b]

 

=={{header|GAP}}==

Concatenation([1, 2, 3], [4, 5, 6], [7, 8, 9]);

# [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

Append(a, [7, 8, 9]);

a;

 

=={{header|Go}}==

 

import "fmt"

fmt.Println(n)

 

<pre>

[1 2 3 7 12 60]

</pre>

Array concatenation needs can vary. Here is another set of examples that illustrate different techniques.

 

import (

test2_c := ArrayConcat(test2_a, test2_b).([]string)

fmt.Println(test2_a, " + ", test2_b, " = ", test2_c)

<pre>

[1 2 3] + [4 5 6] = [1 2 3 4 5 6]

=={{header|Gosu}}==

 

var listA = { 1, 2, 3 }

var listB = { 4, 5, 6 }

 

print( listC ) // prints [1, 2, 3, 4, 5, 6]

 

=={{header|Groovy}}==

Solution:

 

Test:

 

<pre>[1, 2, 3, Crosby, Stills, Nash, Young]</pre>

 

=={{header|Haskell}}==

A list is in Haskell one of the most common composite data types (constructed from other types). In the documentation we read for the append operation ++:

Append two lists, i.e.:<pre>

[x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]

[x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]</pre>

If the first list is not finite, the result is the first list.

 

=={{header|HicEst}}==

 

c = a

DO i = 1, LEN(b)

c(i + LEN(a)) = b(i)

 

=={{header|Icon}} and {{header|Unicon}}==

Both languages have list concatenation built in. Lists are fully dynamic arrays which can be truncated or extended at either end.

procedure main()

L1 := [1, 2, 3, 4]

write()

end

 

=={{header|IDL}}==

 

Array concatenation can mean different things, depending on the number of dimensions of the arguments and the result. In the simplest case, with 1-dimensional arrays to begin with, there are two obvious ways to concatenate them. If my arrays are these:

> a = [1,2,3]

> b = [4,5,6]

> print,b

4 5 6

Then they can be concatenated "at the ends":

> help,[a,b]

<Expression> INT = Array[6]

> print,[a,b]

1 2 3 4 5 6

or "at the sides":

> help,[[a],[b]]

<Expression> INT = Array[3, 2]

1 2 3

4 5 6

Note that this requires that the arrays have the same size at the side at which they are concatenated:

> b = transpose(b)

> help,b

Unable to concatenate variables because the dimensions do not agree: B.

Execution halted at: $MAIN$

This can get a lot more complicated as a 3x4x5-element three-dimensional array can be concatenated with a 5x2x3-element array at exactly two "surfaces".

 

=={{header|Inform 7}}==

let B be {4, 5, 6};

 

=={{header|Ioke}}==

[1,2,3] + [3,2,1]

 

=={{header|J}}==

 

'''Example''':

array2 =: 4 5 6

array1 , array2

 

Of course, in J, array concatenation works (consistently) on arrays of any rank or dimension.

The verb <code>,</code> concatenates by treating the argument array with the largest number of dimensions as a list. Other primary verbs concatenate along other axes.

 

aaa

bbb

3 6

$ ab ,: wx NB. applies to new (higher) axis

 

 

 

 

=={{header|JavaScript}}==

The <code>Array.concat()</code> method returns a new array comprised of this array joined with other array(s) and/or value(s).

 

=={{header|Julia}}==

b = [4,5,6]

# the above bracket notation simply generates a call to vcat

ab = vcat(a,b)

ab = hcat(a,b) #ab -> 3x2 matrix

# the append!(a,b) method is mutating, appending `b` to `a`

 

=={{header|K}}==

a: 1 2 3

b: 4 5 6

a,b

 

Concatenations on larger dimensions also use ",", often combined with other operations.

 

ab:3 3#"abcdefghi"

("abc"

("abc036"

"def147"

 

 

 

 

=={{header|LabVIEW}}==

Use the Build Array function.<br/>{{VI snippet}}<br/>

[[File:LabVIEW_Array_concatenation.png]]

 

=={{header|Lang5}}==

 

=={{header|LFE}}==

> (++ '(1 2 3) '(4 5 6))

(1 2 3 4 5 6)

> (: lists append '(1 2 3) '(4 5 6))

(1 2 3 4 5 6)

 

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

y=20

dim array1(x)

for i = 1 to x + y

print array3(i)

 

 

 

 

 

 

=={{header|Logo}}==

COMBINE is used to combine lists or words. SENTENCE is used to combine lists and words into a single list.

to combine-arrays :a1 :a2

output listtoarray sentence arraytolist :a1 arraytolist :a2

end

show combine-arrays {1 2 3} {4 5 6} ; {1 2 3 4 5 6}

 

=={{header|Lua}}==

 

=={{header|Maple}}==

There is a built-in procedure for concatenating arrays (and similar objects such as matrices or vectors). Arrays can be concatenated along any given dimension, which is specified as the first argument.

> A := Array( [ 1, 2, 3 ] );

A := [1, 2, 3]

[ ]

[1 2 3]

Of course, the order of the arguments is important.

> ArrayTools:-Concatenate( 1, A, M );

[1 2 3]

[ ]

[d e f]

Lists, in Maple, might be considered to be a kind of "array" (in the sense that they look like arrays in memory), though they are actually immutable objects. However, they can be concatenated as follows.

> L1 := [ 1, 2, 3 ];

L1 := [1, 2, 3]

> [ L1[], L2[] ]; # equivalent, just different syntax

[1, 2, 3, a, b, c]

 

 

 

 

 

 

 

 

 

 

 

 

 

 

1 2 3

 

ans =

 

=={{header|Maxima}}==

v: [5, 6, 7, 8, 9, 10]$

append(u, v);

[1, 0, 0],

[0, 1, 0],

 

=={{header|Mercury}}==

 

 

It ''could'' be "as simple as array1 + array2", but the 'array' module names the operation 'append' rather than '+'. It's tempting to just say that Mercury supports ad-hoc polymorphism - it can infer that a bare '+' refers to 'float.+' or 'int.+' (or that the 'append' above is array.append, rather than list.append), by the types involved - but it also handles other ambiguities in the same way. For instance, Mercury (like Prolog and Erlang) treats the arity of a function as part of its name, where ''a(1, 2)'' and ''a(1)'' involve the distinct functions a/2 and a/1. But Mercury also (unlike Prolog and Erlang) supports [[currying]], where ''a(1)'' is a function that accepts a/2's second argument. So, is ''[a(X), a(Y), a(Z)]'' a list of whatever type a/1 evaluates to, or is it a list of curried a/2?

 

=={{header|Nemerle}}==

using Nemerle.Collections;

 

foreach (i in arr12) Write($"$i ");

}

 

=={{header|NetRexx}}==

NetRexx arrays are identical to [[Java|Java's]] so all the techniques described in the [[#Java|Java]] section apply to NetRexx too. This example uses the <tt>Collection</tt> classes to merge two arrays.

 

cymru = [ 'Ogof Ffynnon Ddu', 'Ogof Draenen' ]

loop m_ = 0 to merged.length - 1

say m_ merged[m_]

<pre>

----------------------------------------

 

=={{header|NewLISP}}==

; url: http://rosettacode.org/wiki/Array_concatenation

; author: oofoe 2012-01-28

(append '((x 56) (b 99)) '((z 34) (c 23) (r 88))))

 

 

<pre>Append lists: (3 a 5 3 1 2 3 4 5 6 7 8 9)

Multi append: (this is a test of the emergency 3 2 1)

Append arrays: ((x 56) (b 99) (z 34) (c 23) (r 88))

</pre>

 

=={{header|Objeck}}==

bundle Default {

class Arithmetic {

}

}

 

=={{header|Objective-C}}==

with immutable arrays:

 

or adding onto a mutable array:

NSMutableArray *arr3 = [NSMutableArray arrayWithArray:arr1];

 

=={{header|OCaml}}==

It is more natural in OCaml to use lists instead of arrays:

val list1 : int list = [1; 2; 3]

# let list2 = [4; 5; 6];;

val list2 : int list = [4; 5; 6]

# let list1and2 = list1 @ list2;;

 

If you want to use arrays:

val array1 : int array = [|1; 2; 3|]

# let array2 = [|4; 5; 6|];;

val array2 : int array = [|4; 5; 6|]

# let array1and2 = Array.append array1 array2;;

 

=={{header|ooRexx}}==

say "Array a has " a~items "items"

b = .array~of(4,5,6)

say "Array b has " b~items "items"

a~appendall(b) -- adds all items from b to a

 

=={{header|Order}}==

Order supports two main aggregate types: tuples and sequences (similar to lists in other languages). Most "interesting" operations are limited to sequences, but both support an append operation, and each can be converted to the other.

 

ORDER_PP( 8tuple_append(8tuple(1, 2, 3), 8tuple(4, 5, 6), 8pair(7, 8)) )

 

ORDER_PP( 8seq_append(8seq(1, 2, 3), 8seq(4, 5, 6), 8seq(7, 8)) )

 

=={{header|OxygenBasic}}==

'CREATE DYNAMIC ARRAY SPACES USING STRINGS

 

 

print a[7] 'result 70

=={{header|Oz}}==

List are concatenated with <code>List.append</code> (shortcut: <code>Append</code>). Tuples are concatened with <code>Tuple.append</code>. Arrays do exist in Oz, but are rarely used.

{Append [a b] [c d]} = [a b c d]

 

%% concatenating 2 tuples

 

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

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

In Perl, arrays placed into list context are flattened:

my @arr2 = (4, 5, 6);

 

The <code>[http://perldoc.perl.org/functions/push.html push]</code> function appends elements onto an existing array:

my @arr2 = (4, 5, 6);

push @arr1, @arr2;

 

 

 

=={{header|PHP}}==

 

$arr2 = array(4, 5, 6);

 

=={{header|PicoLisp}}==

 

There are destructive concatenations:

-> (a b c)

: (conc A B) # Concatenate lists in 'A' and 'B'

-> (1 2 3 a b c)

: A

and non-destructive concatenations:

-> (a b c)

: (append A B) # Append lists in 'A' and 'B'

-> (1 2 3)

: B

 

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

Trivial example requires no computational statement.

Note that the arrays are not in static storage:

declare x(12) fixed;

declare b(5) fixed defined x;

declare c(7) fixed defined x(1sub+5);

A more general example using dynamic bounds.

Again, no computation statement is required.

declare x(m+n) fixed;

declare b(m) fixed defined x;

declare c(n) fixed defined x(1sub+hbound(b,1));

 

An alternative, that can be used to advantage for matrices

are used in the declarations, the bounds can be dynamic.

Matrix B is extended by placing matrix C on its diagonal:

declare a(5,6) fixed;

declare b(3,4) fixed defined a(1sub, 2sub);

put skip list ('Composite matrix:');

put skip edit (a) ( skip, (hbound(a,2)) f(5,0) );

Please type elements for a 3 x 4 matrix:

 

0 0 0 0 15 16

 

 

=={{header|PostScript}}==

{{libheader|initlib}}

[1 2 3 4] [5 6 7 8] concat

 

=={{header|PowerShell}}==

$b = 4,5,6

 

$c = $a + $b

 

=={{header|Prolog}}==

?- append([1,2,3],[4,5,6],R).

R = [1, 2, 3, 4, 5, 6].

=={{header|PureBasic}}==

Protected i

Print(msg + " [")

Input()

CloseConsole()

<pre>a: [5, 2, -4, -1, -2]

b: [0, -4, -1]

 

=={{header|Python}}==

arr2 = [4, 5, 6]

arr3 = [7, 8, 9]

assert arr4 == [1, 2, 3, 4, 5, 6]

arr4.extend(arr3)

 

Note: list.extend is normally accomplished using the += operator like this:

arr6 = [7, 8, 9]

arr6 += arr5

 

=={{header|R}}==

 

a1 <- c(1, 2, 3)

a2 <- c(3, 4, 5)

a3 <- c(a1, a2)

 

=={{header|Racket}}==

(vector-append #(1 2 3 4) #(5 6 7) #(8 9 10))

<pre>

'#(1 2 3 4 5 6 7 8 9 10)

</pre>

 

=={{header|REBOL}}==

a1: [1 2 3]

a2: [4 5 6]

 

append/only a1 a3 ; -> [1 2 3 4 5 6 [7 8 9]]

 

 

 

=={{header|REXX}}==

a.2 = 22.7

where now we have three "elements", and they are disjointed (another word for ''sparse'').

<br>There are ways to handle this in REXX however.

<br>assuming that the stemmed variables are sequential.

<br><br>'''example:'''

fact.1= 1

fact.2= 2

fact.6= 720

fact.7= 5040

To concat two "arrays" in REXX, the following assumes that the stemmed variables are in order, with no gaps, and none have a "null" value.

 

p.= /*(below) a short list of primes.*/

say 'c.'m"="c.m /*show a "merged" C array nums.*/

end /*m*/

elements= 23

 

c.23=55

</pre>

 

=={{header|RLaB}}==

In RLaB the matrices can be appended (column-wise) or stacked (row-wise).

Consider few examples:

>> x = [1, 2, 3]

>> y = [4, 5, 6]

4 5 6

>>

 

=={{header|Ruby}}==

The <code>[http://www.ruby-doc.org/core/classes/Array.html#M002209 Array#+]</code> method concatenates two arrays and returns a new array. The <code>[http://www.ruby-doc.org/core/classes/Array.html#M002166 Array#concat]</code> method appends elements of another array to the receiver.

arr2 = [4, 5, 6]

arr3 = [7, 8, 9]

arr4 = arr1 + arr2 # => [1, 2, 3, 4, 5, 6]

 

=={{header|Scala}}==

val arr2 = Array( 4, 5, 6 )

val arr3 = Array( 7, 8, 9 )

//or:

Array concat ( arr1, arr2, arr3 )

 

=={{header|Scheme}}==

(define (vector-append . arg) (list->vector (apply append (map vector->list arg))))

 

(vector-append #(1 2 3 4) #(5 6 7) #(8 9 10))

 

''Note : vector-append is also defined in [http://srfi.schemers.org/srfi-43/srfi-43.html SRFI-43].''

 

=={{header|Seed7}}==

 

var array integer: a is [] (1, 2, 3, 4);

end for;

writeln;

 

<pre>1 2 3 4 5 6 7 8</pre>

 

=={{header|Slate}}==

The binary operation of concatenation is made with the <tt>;</tt> (semi-colon) from the type Sequence. It is also available for appending Sequences to WriteStreams.

 

{1. 2. 3. 4. 5} ; {6. 7. 8. 9. 10}

 

=={{header|Smalltalk}}==

Concatenation (appending) is made with the method <tt>,</tt> (comma), present in classes SequenceableCollection, ArrayedCollection and their subclasses (e.g. Array, String, OrderedCollection ...)

 

a := #(1 2 3 4 5).

b := #(6 7 8 9 10).

c := a,b.

 

=={{header|SNOBOL4}}==

{{works with|CSnobol}}

 

define('cat(a1,a2)i,j') :(cat_end)

cat cat = array(prototype(a1) + prototype(a2))

output = str2

output = str3

 

<pre>1 2 3 4 5

6 7 8 9 10

1 2 3 4 5 6 7 8 9 10</pre>

 

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

val l1 = [1,2,3,4];;

val l2 = [5,6,7,8];;

val l3 = l1 @ l2 (* [1,2,3,4,5,6,7,8] *)

 

=={{header|Tcl}}==

set b {4 5 6}

Note that in the Tcl language, “arrays” are hash maps of strings to variables, so the notion of concatenation doesn't really apply. What other languages (usually) call arrays are “lists” in Tcl.

 

 

=={{header|Trith}}==

 

=={{header|UNIX Shell}}==

{{works with|bash}}

 

array2=( 6 7 8 9 10 )

 

Whitespace-delimited strings work in much the same way:

{{works with|bash}}

 

array2='6 7 8 9 10'

 

 

# Concatenated to a string ...

 

=={{header|Vala}}==

int[] c = new int[a.length + b.length];

Memory.copy(c, a, a.length * sizeof(int));

stdout.printf("%d\n",i);

}