Array concatenation
You are encouraged to solve this task according to the task description, using any language you may know.
Show how to concatenate two arrays in your language. If this is as simple as array1 + array2
, so be it.
ACL2
This is for lists, not arrays; ACL2's array support is limited. <lang Lisp>(append xs ys)</lang>
ActionScript
<lang ActionScript>var array1:Array = new Array(1, 2, 3); var array2:Array = new Array(4, 5, 6); var array3:Array = array1.concat(array2); //[1, 2, 3, 4, 5, 6]</lang>
Ada
In Ada arrays are concatenated using the operation &. It works with any one dimensioned array: <lang Ada>type T is array (Positive range <>) of Integer; X : T := (1, 2, 3); Y : T := X & (4, 5, 6); -- Concatenate X and (4, 5, 6)</lang>
ALGOL 68
Includes operators for appending and prefixing an array to an existing flexible array: <lang Algol68>MODE ARGTYPE = INT; MODE ARGLIST = FLEX[0]ARGTYPE;
OP + = (ARGLIST a, b)ARGLIST: (
[LWB a:UPB a - LWB a + 1 + UPB b - LWB b + 1 ]ARGTYPE out; ( out[LWB a:UPB a]:=a, out[UPB a+1:]:=b ); out
);
- Append #
OP +:= = (REF ARGLIST lhs, ARGLIST rhs)ARGLIST: lhs := lhs + rhs; OP PLUSAB = (REF ARGLIST lhs, ARGLIST rhs)ARGLIST: lhs := lhs + rhs;
- Prefix #
OP +=: = (ARGLIST lhs, REF ARGLIST rhs)ARGLIST: rhs := lhs + rhs; OP PLUSTO = (ARGLIST lhs, REF ARGLIST rhs)ARGLIST: rhs := lhs + rhs;
ARGLIST a := (1,2),
b := (3,4,5);
print(("a + b",a + b, new line));
VOID(a +:= b); print(("a +:= b", a, new line));
VOID(a +=: b); print(("a +=: b", b, new line))</lang>
a + b +1 +2 +3 +4 +5 a +:= b +1 +2 +3 +4 +5 a +=: b +1 +2 +3 +4 +5 +3 +4 +5
AutoHotkey
True Arrays
<lang AHK>List1 := [1, 2, 3] List2 := [4, 5, 6] cList := Arr_concatenate(List1, List2) MsgBox % Arr_disp(cList) ; [1, 2, 3, 4, 5, 6]
Arr_concatenate(p*) {
res := Object() For each, obj in p For each, value in obj res.Insert(value) return res
}
Arr_disp(arr) {
for each, value in arr res .= ", " value return "[" SubStr(res, 3) "]"
}</lang>
Legacy versions
AutoHotkey_Basic does not have real Arrays, but the user can implement them quite easily. For example: <lang AutoHotkey>List1 = 1,2,3 List2 = 4,5,6
List2Array(List1 , "Array1_") List2Array(List2 , "Array2_")
ConcatArrays("Array1_", "Array2_", "MyArray") MsgBox, % Array2List("MyArray")
- ---------------------------------------------------------------------------
ConcatArrays(A1, A2, A3) { ; concatenates the arrays A1 and A2 to A3
- ---------------------------------------------------------------------------
local i := 0 %A3%0 := %A1%0 + %A2%0 Loop, % %A1%0 i++, %A3%%i% := %A1%%A_Index% Loop, % %A2%0 i++, %A3%%i% := %A2%%A_Index%
}
- ---------------------------------------------------------------------------
List2Array(List, Array) { ; creates an array from a comma separated list
- ---------------------------------------------------------------------------
global StringSplit, %Array%, List, `,
}
- ---------------------------------------------------------------------------
Array2List(Array) { ; returns a comma separated list from an array
- ---------------------------------------------------------------------------
Loop, % %Array%0 List .= (A_Index = 1 ? "" : ",") %Array%%A_Index% Return, List
}</lang> Message box shows:
1,2,3,4,5,6
Babel
<lang babel>main : { [1 2 3] [4 5 6] cat }</lang>
BBC BASIC
<lang bbcbasic> DIM a(3), b(4)
a() = 1, 2, 3, 4 b() = 5, 6, 7, 8, 9 PROCconcat(a(), b(), c()) FOR i% = 0 TO DIM(c(),1) PRINT c(i%) NEXT END DEF PROCconcat(a(), b(), RETURN c()) LOCAL s%, na%, nb% s% = ^a(1) - ^a(0) : REM Size of each array element na% = DIM(a(),1)+1 : REM Number of elements in a() nb% = DIM(b(),1)+1 : REM Number of elements in b() DIM c(na%+nb%-1) SYS "RtlMoveMemory", ^c(0), ^a(0), s%*na% SYS "RtlMoveMemory", ^c(na%), ^b(0), s%*nb% ENDPROC</lang>
C
A way to concatenate two C arrays when you know their size (and usually so it is) <lang c>#include <stdlib.h>
- include <stdio.h>
- include <string.h>
- define ARRAY_CONCAT(TYPE, A, An, B, Bn) \
(TYPE *)array_concat((const void *)(A), (An), (const void *)(B), (Bn), sizeof(TYPE));
void *array_concat(const void *a, size_t an,
const void *b, size_t bn, size_t s)
{
char *p = malloc(s * (an + bn)); memcpy(p, a, an*s); memcpy(p + an*s, b, bn*s); return p;
}
// testing const int a[] = { 1, 2, 3, 4, 5 }; const int b[] = { 6, 7, 8, 9, 0 };
int main(void) {
unsigned int i;
int *c = ARRAY_CONCAT(int, a, 5, b, 5);
for(i = 0; i < 10; i++) printf("%d\n", c[i]);
free(c); return EXIT_SUCCCESS;
}</lang>
C++
<lang cpp>#include <vector>
- include <iostream>
int main() {
std::vector<int> a(3), b(4); a[0] = 11; a[1] = 12; a[2] = 13; b[0] = 21; b[1] = 22; b[2] = 23; b[3] = 24;
a.insert(a.end(), b.begin(), b.end());
for (int i = 0; i < a.size(); ++i) std::cout << "a[" << i << "] = " << a[i] << "\n";
}</lang>
C#
<lang csharp>using System;
namespace RosettaCode {
class Program { static void Main(string[] args) { int[] a = { 1, 2, 3 }; int[] b = { 4, 5, 6 };
int[] c = new int[a.Length + b.Length]; a.CopyTo(c, 0); b.CopyTo(c, a.Length);
foreach(int n in c) { Console.WriteLine(n.ToString()); } } }
}</lang>
Alternatively, using LINQ extension methods:
<lang csharp>using System.Linq;
class Program {
static void Main(string[] args) { int[] a = { 1, 2, 3 }; int[] b = { 4, 5, 6 };
int[] c = a.Concat(b).ToArray(); }
}</lang>
Clojure
<lang lisp>(concat [1 2 3] [4 5 6])</lang> The inputs can be any collection, including Java arrays, and returns a lazy sequence of the elements.
CoffeeScript
<lang coffeescript>
- like in JavaScript
a = [1, 2, 3] b = [4, 5, 6] c = a.concat b </lang>
Common Lisp
concatenate
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.
<lang lisp>(concatenate 'vector #(0 1 2 3) #(4 5 6 7))
=> #(0 1 2 3 4 5 6 7)</lang>
D
<lang d>import std.stdio: writeln;
void main() {
int[] a = [1, 2]; int[] b = [4, 5, 6]; writeln(a, " ~ ", b, " = ", a ~ b);
}</lang> Output:
[1, 2] ~ [4, 5, 6] = [1, 2, 4, 5, 6]
Delphi
<lang delphi>type
TReturnArray = array of integer; //you need to define a type to be able to return it
function ConcatArray(a1,a2:array of integer):TReturnArray; var
i,r:integer;
begin
{ Low(array) is not necessarily 0 } SetLength(result,High(a1)-Low(a1)+High(a2)-Low(a2)+2); //BAD idea to set a length you won't release, just to show the idea! r:=0; //index on the result may be different to indexes on the sources for i := Low(a1) to High(a1) do begin result[r] := a1[i]; Inc(r); end; for i := Low(a2) to High(a2) do begin result[r] := a2[i]; Inc(r); end;
end;
procedure TForm1.Button1Click(Sender: TObject); var
a1,a2:array of integer; r1:array of integer; i:integer;
begin
SetLength(a1,4); SetLength(a2,3); for i := Low(a1) to High(a1) do a1[i] := i; for i := Low(a2) to High(a2) do a2[i] := i; TReturnArray(r1) := ConcatArray(a1,a2); for i := Low(r1) to High(r1) do showMessage(IntToStr(r1[i])); Finalize(r1); //IMPORTANT! ShowMessage(IntToStr(High(r1)));
end;</lang>
E
<lang e>? [1,2] + [3,4]
- value: [1, 2, 3, 4]</lang>
Efene
using the ++ operator and the lists.append function
<lang efene> @public run = fn () {
A = [1, 2, 3, 4] B = [5, 6, 7, 8]
C = A ++ B D = lists.append([A, B])
io.format("~p~n", [C]) io.format("~p~n", [D])
}</lang>
Elena
<lang elena>#define arrays'* = std'routines'arrays'*.
- symbol Program =>
[
#var a := (1,2,3). #var b := (4,5). #var c := a~arrays'eops + b.
]. </lang>
Emacs Lisp
- See Scheme
Erlang
In erlang, you can use the ++ operator or lists:append, which is implemented via ++.
On the shell, <lang erlang> 1> [1, 2, 3] ++ [4, 5, 6]. [1,2,3,4,5,6] 2> lists:append([1, 2, 3], [4, 5, 6]). [1,2,3,4,5,6] 3> </lang>
Euphoria
<lang Euphoria>sequence s1,s2,s3 s1 = {1,2,3} s2 = {4,5,6} s3 = s1 & s2 ? s3</lang>
Output:
{1,2,3,4,5,6}
F#
Array concatenation. <lang fsharp>let a = [|1; 2; 3|] let b = [|4; 5; 6;|] let c = Array.append a b</lang> List concatenation (@ and List.append are equivalent). <lang fsharp>let x = [1; 2; 3] let y = [4; 5; 6] let z1 = x @ y let z2 = List.append x y</lang>
Factor
<lang factor>append</lang>
Example: <lang factor>( scratchpad ) USE: sequences ( scratchpad ) { 1 2 } { 3 4 } append . { 1 2 3 4 }</lang>
Fantom
In fansh:
<lang fantom> > a := [1,2,3] > b := [4,5,6] > a.addAll(b) > a [1,2,3,4,5,6] </lang>
Note 'addAll' is destructive. Write 'a.dup.addAll(b)' to create a fresh list.
Forth
<lang Forth>: $!+ ( a u a' -- a'+u )
2dup + >r swap move r> ;
- cat ( a2 u2 a1 u1 -- a3 u1+u2 )
align here dup >r $!+ $!+ r> tuck - dup allot ;
\ TEST create a1 1 , 2 , 3 , create a2 4 , 5 , a2 2 cells a1 3 cells cat dump
8018425F0: 01 00 00 00 00 00 00 00 - 02 00 00 00 00 00 00 00 ................ 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 - ........ </lang>
Fortran
<lang fortran>program Concat_Arrays implicit none
integer, dimension(3) :: a = [ 1, 2, 3 ] integer, dimension(3) :: b = [ 4, 5, 6 ] integer, dimension(:), allocatable :: c allocate(c(size(a)+size(b))) c(1:size(a)) = a c(size(a)+1:size(a)+size(b)) = b
write(*,*) c
end program Concat_Arrays</lang>
GAP
<lang gap># Concatenate arrays Concatenation([1, 2, 3], [4, 5, 6], [7, 8, 9]);
- [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
- Append to a variable
a := [1, 2, 3]; Append(a, [4, 5, 6); Append(a, [7, 8, 9]); a;
- [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]</lang>
Go
<lang go>package main
import "fmt"
func main() {
// Example 1: Idiomatic in Go is use of the append function. // Elements must be of identical type. a := []int{1, 2, 3} b := []int{7, 12, 60} c := append(a, b...) fmt.Println(c)
// Example 2: Polymorphism. // interface{} is a type too, one that can reference values of any type. // This allows a sort of polymorphic list. i := []interface{}{1, 2, 3} j := []interface{}{"Crosby", "Stills", "Nash", "Young"} k := append(i, j...) fmt.Println(k)
// Example 3: Arrays, not slices. // A word like "array" on RC often means "whatever array means in your // language." In Go, the common role of "array" is usually filled by // Go slices, as in examples 1 and 2. If by "array" you really mean // "Go array," then you must move elements one by one. l := [...]int{1, 2, 3} m := [...]int{7, 12, 60} var n [len(l) + len(m)]int for i, x := range l { n[i] = x } for i, x := range m { n[i+len(l)] = x } fmt.Println(n)
}</lang> Output:
[1 2 3 7 12 60] [1 2 3 Crosby Stills Nash Young] [1 2 3 7 12 60]
Array concatenation needs can vary. Here is another set of examples that illustrate different techniques. <lang go>package main
import (
"reflect" "fmt"
)
// Generic version // Easier to make the generic version accept any number of arguments, // and loop trough them. Otherwise there will be lots of code duplication. func ArrayConcat(arrays ...interface{}) interface{} {
if len(arrays) == 0 { panic("Need at least one arguemnt") } var vals = make([]*reflect.SliceValue, len(arrays)) var arrtype *reflect.SliceType var totalsize int for i,a := range arrays { v := reflect.NewValue(a) switch t := v.Type().(type) { case *reflect.SliceType: if arrtype == nil { arrtype = t } else if t != arrtype { panic("Unequal types") } vals[i] = v.(*reflect.SliceValue) totalsize += vals[i].Len() default: panic("not a slice") } } ret := reflect.MakeSlice(arrtype,totalsize,totalsize) targ := ret for _,v := range vals { reflect.Copy(targ, v) targ = targ.Slice(v.Len(),targ.Len()) } return ret.Interface()
}
// Type specific version func ArrayConcatInts(a, b []int) []int {
ret := make([]int, len(a) + len(b)) copy(ret, a) copy(ret[len(a):], b) return ret
}
func main() {
test1_a, test1_b := []int{1,2,3}, []int{4,5,6} test1_c := ArrayConcatInts(test1_a, test1_b) fmt.Println(test1_a, " + ", test1_b, " = ", test1_c)
test2_a, test2_b := []string{"a","b","c"}, []string{"d","e","f"} test2_c := ArrayConcat(test2_a, test2_b).([]string) fmt.Println(test2_a, " + ", test2_b, " = ", test2_c)
}</lang> Output:
[1 2 3] + [4 5 6] = [1 2 3 4 5 6] [a b c] + [d e f] = [a b c d e f]
Gosu
<lang gosu> var listA = { 1, 2, 3 } var listB = { 4, 5, 6 }
var listC = listA.concat( listB )
print( listC ) // prints [1, 2, 3, 4, 5, 6] </lang>
Groovy
Solution: <lang groovy>def list = [1, 2, 3] + ["Crosby", "Stills", "Nash", "Young"]</lang>
Test: <lang groovy>println list</lang>
Output:
[1, 2, 3, Crosby, Stills, Nash, Young]
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 ++: <lang haskell>(++) :: [a] -> [a] -> [a]</lang>
Append two lists, i.e.:
[x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn] [x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]
If the first list is not finite, the result is the first list.
HicEst
<lang HicEst>REAL :: a(7), b(3), c(10)
c = a DO i = 1, LEN(b)
c(i + LEN(a)) = b(i)
ENDDO</lang>
Icon and Unicon
Both languages have list concatenation built in. Lists are fully dynamic arrays which can be truncated or extended at either end. <lang icon> procedure main()
L1 := [1, 2, 3, 4] L2 := [11, 12, 13, 14] L3 := L1 ||| L2
sep := "" every writes(sep, !L3) do sep := ", " write()
end </lang>
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: <lang IDL>
> a = [1,2,3] > b = [4,5,6] > help,a A INT = Array[3] > help,b B INT = Array[3] > print,a 1 2 3 > print,b 4 5 6
</lang> Then they can be concatenated "at the ends": <lang IDL>
> help,[a,b] <Expression> INT = Array[6] > print,[a,b] 1 2 3 4 5 6
</lang> or "at the sides": <lang IDL>
> help,[[a],[b]] <Expression> INT = Array[3, 2] > print,[[a],[b]] 1 2 3 4 5 6
</lang> Note that this requires that the arrays have the same size at the side at which they are concatenated: <lang IDL>
> b = transpose(b) > help,b B INT = Array[1, 3] > print,b 4 5 6 > print,[a,b] Unable to concatenate variables because the dimensions do not agree: B. Execution halted at: $MAIN$ > print,[[a],[b]] Unable to concatenate variables because the dimensions do not agree: B. Execution halted at: $MAIN$
</lang> 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".
Inform 7
<lang inform7>let A be {1, 2, 3}; let B be {4, 5, 6}; add B to A;</lang>
Ioke
<lang ioke>iik> [1,2,3] + [3,2,1] [1,2,3] + [3,2,1] +> [1, 2, 3, 3, 2, 1]</lang>
J
Solution: ,
Example: <lang j> array1 =: 1 2 3
array2 =: 4 5 6 array1 , array2
1 2 3 4 5 6</lang>
Of course, in J, array concatenation works (consistently) on arrays of any rank or dimension.
The verb ,
concatenates by treating the argument array with the largest number of dimensions as a list. Other primary verbs concatenate along other axes.
<lang j> ]ab=: 3 3 $ 'aaabbbccc' aaa bbb ccc
]wx=: 3 3 $ 'wxyz'
wxy zwx yzw
ab , wx
aaa bbb ccc wxy zwx yzw
ab ,. wx
aaawxy bbbzwx cccyzw
ab ,: wx
aaa bbb ccc
wxy zwx yzw
$ ab , wx NB. applies to first (highest) axis
6 3
$ ab ,. wx NB. applies to last (atomic) axis
3 6
$ ab ,: wx NB. applies to new (higher) axis
2 3 3</lang>
Java
From [1]: <lang java5>public static Object[] objArrayConcat(Object[] o1, Object[] o2) {
Object[] ret = new Object[o1.length + o2.length];
System.arraycopy(o1, 0, ret, 0, o1.length); System.arraycopy(o2, 0, ret, o1.length, o2.length); return ret;
}</lang>
Or with Collection
s simply call addAll
:
<lang java5>Collection list1, list2, list1And2;
//...list1 and list2 are instantiated...
list1And2 = new ArrayList(list1); //or any other Collection you want
list1And2.addAll(list2);</lang>
JavaScript
The Array.concat()
method returns a new array comprised of this array joined with other array(s) and/or value(s).
<lang javascript>var
a = [1,2,3], b = [4,5,6], c = a.concat(b); // [1,2,3,4,5,6]</lang>
K
<lang K>
a: 1 2 3 b: 4 5 6 a,b
1 2 3 4 5 6</lang>
Concatenations on larger dimensions also use ",", often combined with other operations.
<lang K>
ab:3 3#"abcdefghi"
("abc"
"def" "ghi")
dd:3 3#"012345678"
("012"
"345" "678")
ab,dd
("abc"
"def" "ghi" "012" "345" "678")
+ab,dd / flip (transpose) join
("adg036"
"beh147" "cfi258")
ab,'dd / eachpair join
("abc012"
"def345" "ghi678")
+(+ab),dd
("abc036"
"def147" "ghi258")</lang>
LabVIEW
Use the Build Array function.
This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.
Liberty BASIC
<lang lb> x=10
y=20 dim array1(x) dim array2(y)
[concatenate]
dim array3(x + y) for i = 1 to x array3(i) = array1(i) next for i = 1 to y array3(i + x) = array2(i) next
[print]
for i = 1 to x + y print array3(i) next</lang>
Logo
COMBINE is used to combine lists or words. SENTENCE is used to combine lists and words into a single list. <lang logo> 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} </lang>
Lua
<lang lua>a = {1,2,3} b = {4,5,6} table.foreach(b,function(i,v)table.insert(a,i)end) for i,v in next,a do io.write (v..' ') end</lang>
Mathematica
<lang Mathematica>Join[{1,2,3}, {4,5,6}]
-> {1, 2, 3, 4, 5, 6}</lang>
MATLAB
Two arrays are concatenated by placing the two arrays between a pair of square brackets. A space between the two array names will concatenate them horizontally, and a semi-colon between array names will concatenate vertically. <lang MATLAB>>> a = [1 2 3]
a =
1 2 3
>> b = [4 5 6]
b =
4 5 6
>> concat = [a b]
concat =
1 2 3 4 5 6
>> concat = [a;b]
concat =
1 2 3 4 5 6</lang>
For multi-dimensional arrays, there is also the function cat(): <lang MATLAB>>> c = randn([3,4,5]); >> d = randn([3,4,7]); >> e = cat(3,c,d); >> size(e)
ans =
3 4 12
</lang>
Maxima
<lang>u: [1, 2, 3, 4]$ v: [5, 6, 7, 8, 9, 10]$ append(u, v); /* [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] */
/* There are also functions for matrices */
a: matrix([6, 1, 8],
[7, 5, 3], [2, 9, 4])$
addcol(a, ident(3)); /* matrix([6, 1, 8, 1, 0, 0],
[7, 5, 3, 0, 1, 0], [2, 9, 4, 0, 0, 1]) */
addrow(a, ident(3)); /* matrix([6, 1, 8],
[7, 5, 3], [2, 9, 4], [1, 0, 0], [0, 1, 0], [0, 0, 1]) */</lang>
Mercury
<lang Mercury>A `append` B = C</lang>
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?
Nemerle
<lang Nemerle>using System.Console; using Nemerle.Collections;
module ArrayCat {
Main() : void { def arr1 = array[1, 2, 3]; def arr2 = array[4, 5, 6]; def arr12 = arr1.Append(arr2); // <---- foreach (i in arr12) Write($"$i "); }
}</lang>
NewLISP
<lang NewLISP>; file: arraycon.lsp
- url
- http://rosettacode.org/wiki/Array_concatenation
- author
- oofoe 2012-01-28
(println "Append lists: " (append '(3 a 5 3) (sequence 1 9)))
(println "Multi append: "
(append '(this is) '(a test) '(of the emergency) (sequence 3 1)))
(println "Append arrays: "
(append '((x 56) (b 99)) '((z 34) (c 23) (r 88))))
(exit)</lang>
Sample output:
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))
Objeck
<lang objeck> bundle Default {
class Arithmetic { function : Main(args : String[]) ~ Nil { array1 := [3, 5, 7]; array2 := [2, 4, 6]; array3 := Copy(array1, array2); each(i : array3) { array3[i]->PrintLine(); }; } function : native : Copy(array1 : Int[], array2 : Int[]) ~ Int[] { max := array1->Size() + array2->Size(); array3 := Int->New[max]; i := 0; for(i := i; i < array1->Size(); i += 1;) { array3[i] := array1[i]; }; j := 0; for(i := i; i < max; i += 1;) { array3[i] := array2[j]; j += 1; }; return array3; } }
} </lang>
Objective-C
with immutable arrays: <lang objc>NSArray *arr1 = [NSArray arrayWithObjects:[NSNumber numberWithInt:1],
[NSNumber numberWithInt:2], [NSNumber numberWithInt:3], nil];
NSArray *arr2 = [NSArray arrayWithObjects:[NSNumber numberWithInt:4],
[NSNumber numberWithInt:5], [NSNumber numberWithInt:6], nil];
NSArray *arr3 = [arr1 arrayByAddingObjectsFromArray:arr2];</lang>
or adding onto a mutable array: <lang objc>NSArray *arr1 = [NSArray arrayWithObjects:[NSNumber numberWithInt:1],
[NSNumber numberWithInt:2], [NSNumber numberWithInt:3], nil];
NSArray *arr2 = [NSArray arrayWithObjects:[NSNumber numberWithInt:4],
[NSNumber numberWithInt:5], [NSNumber numberWithInt:6], nil];
NSMutableArray *arr3 = [NSMutableArray arrayWithArray:arr1]; [arr3 addObjectsFromArray:arr2];</lang>
OCaml
It is more natural in OCaml to use lists instead of arrays: <lang ocaml># let list1 = [1; 2; 3];; val list1 : int list = [1; 2; 3]
- let list2 = [4; 5; 6];;
val list2 : int list = [4; 5; 6]
- let list1and2 = list1 @ list2;;
val list1and2 : int list = [1; 2; 3; 4; 5; 6]</lang>
If you want to use arrays: <lang ocaml># let array1 = [|1; 2; 3|];; 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;;
val array1and2 : int array = [|1; 2; 3; 4; 5; 6|]</lang>
ooRexx
<lang ooRexx> a = .array~of(1,2,3) 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 say "Array a now has " a~items " </lang>
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. <lang c>#include <order/interpreter.h>
ORDER_PP( 8tuple_append(8tuple(1, 2, 3), 8tuple(4, 5, 6), 8pair(7, 8)) ) // -> (1,2,3,4,5,6,7,8)
ORDER_PP( 8seq_append(8seq(1, 2, 3), 8seq(4, 5, 6), 8seq(7, 8)) ) // -> (1)(2)(3)(4)(5)(6)(7)(8)</lang>
OxygenBasic
<lang oxygenbasic> 'CREATE DYNAMIC ARRAY SPACES USING STRINGS
string sa=nuls 5* sizeof float string sb=sa
'MAP ARRAY VARIABLES ONTO STRINGS
float a at *sa float b at *sb
'ASSIGN SOME VALUES
a<=10,20,30,40,50 b<=60,70,80,90,00
'ADD ARRAY B TO A BY STRING CONCATENATION
sa+=sb
'TEST
print a[7] 'result 70 </lang>
Oz
List are concatenated with List.append
(shortcut: Append
). Tuples are concatened with Tuple.append
. Arrays do exist in Oz, but are rarely used.
<lang oz>%% concatenating 2 lists
{Append [a b] [c d]} = [a b c d]
%% concatenating 2 tuples {Tuple.append t(1 2 3) u(4 5 6)} = u(1 2 3 4 5 6)</lang>
PARI/GP
<lang parigp>concat(u,v)</lang>
Pascal
- See Delphi
Perl
In Perl, arrays placed into list context are flattened: <lang perl>my @arr1 = (1, 2, 3); my @arr2 = (4, 5, 6); my @arr3 = (@arr1, @arr2);</lang>
The push
function appends elements onto an existing array:
<lang perl>my @arr1 = (1, 2, 3);
my @arr2 = (4, 5, 6);
push @arr1, @arr2;
print "@arr1\n"; # prints "1 2 3 4 5 6"</lang>
Perl 6
<lang perl6># the comma ',' can be used to concatenate arrays: sub concatenateArrays(@a, @b) { @a, @b }
my @a1 = (1,2,3); my @a2 = (2,3,4); concatenateArrays(@a1,@a2).join(", ").say;</lang>
PHP
<lang php>$arr1 = array(1, 2, 3); $arr2 = array(4, 5, 6); $arr3 = array_merge($arr1, $arr2);</lang>
PicoLisp
PicoLisp has no built-in array data type. Lists are used instead.
There are destructive concatenations: <lang PicoLisp>: (setq A (1 2 3) B '(a b c)) -> (a b c)
- (conc A B) # Concatenate lists in 'A' and 'B'
-> (1 2 3 a b c)
- A
-> (1 2 3 a b c) # Side effect: List in 'A' is modified!</lang> and non-destructive concatenations: <lang PicoLisp>: (setq A (1 2 3) B '(a b c)) -> (a b c)
- (append A B) # Append lists in 'A' and 'B'
-> (1 2 3 a b c)
- A
-> (1 2 3)
- B
-> (a b c) # Arguments are not modified</lang>
PL/I
<lang PL/I> declare A(5) fixed initial (1, 2, 3, 4, 5); declare B(7) fixed initial (6, 7, 8, 9, 10, 11, 12); declare C(*) fixed controlled;
allocate C(hbound(A,1)+hbound(B,1));
do i = 1 to hbound(A,1); C(i) = A(i); end; do i = 1 to hbound(B,1); C(i+hbound(A,1)) = B(i); end;
put (C); </lang>
An alternative, that can be used to advantage for matrices as well as vectors, follows. This example illustrates extending a matrix diagonally. Although fixed array bounds are used in the declarations, the bounds can be dynamic. Matrix B is extended by placing matrix C on its diagonal: <lang>
declare a(5,6) fixed; declare b(3,4) fixed defined a(1sub, 2sub); declare c(2,2) fixed defined a(1sub+hbound(b,1), 2sub+hbound(b,2)); declare (i, j, k) fixed;
a = 0; put skip list ('Please type elements for a 3 x 4 matrix:'); get list (b); put skip list ('Please type elements for a 2 x 2 matrix:'); get list (c); put skip edit (c) ( skip, (hbound(c,2)) f(5,0) );
put skip list ('Composite matrix:'); put skip edit (a) ( skip, (hbound(a,2)) f(5,0) );
</lang> Output: <lang> Please type elements for a 3 x 4 matrix:
Please type elements for a 2 x 2 matrix:
13 14 15 16
Composite matrix:
1 2 3 4 0 0 5 6 7 8 0 0 9 10 11 12 0 0 0 0 0 0 13 14 0 0 0 0 15 16
</lang>
PostScript
<lang postscript> [1 2 3 4] [5 6 7 8] concat </lang>
PowerShell
<lang powershell>$a = 1,2,3 $b = 4,5,6
$c = $a + $b Write-Host $c</lang>
Prolog
<lang prolog> ?- append([1,2,3],[4,5,6],R). R = [1, 2, 3, 4, 5, 6]. </lang>
PureBasic
<lang PureBasic>Procedure displayArray(Array a(1), msg.s)
Protected i Print(msg + " [") For i = 0 To ArraySize(a()) Print(Str(a(i))) If i <> ArraySize(a()) Print(", ") EndIf Next PrintN("]")
EndProcedure
Procedure randomElements(Array a(1), lo, hi)
Protected i For i = 0 To ArraySize(a()) a(i) = random(hi - lo) + lo Next
EndProcedure
Procedure arrayConcat(Array a(1), Array b(1), Array c(1))
Protected i, newSize = ArraySize(a()) + ArraySize(b()) + 1 Dim c(newSize) For i = 0 To ArraySize(a()) c(i) = a(i) Next For i = 0 To ArraySize(b()) c(i + ArraySize(a()) + 1) = b(i) Next
EndProcedure
If OpenConsole()
Dim a(random(3) + 1) Dim b(random(3) + 1) Dim c(0) ;array will be resized by arrayConcat() randomElements(a(), -5, 5) randomElements(b(), -5, 5) displayArray(a(), "a:") displayArray(b(), "b:") arrayConcat(a(), b(), c()) displayArray(c(), "concat of a[] + b[]:") Print(#CRLF$ + #CRLF$ + "Press ENTER to exit") Input() CloseConsole()
EndIf</lang> Sample output:
a: [5, 2, -4, -1, -2] b: [0, -4, -1] concat of a[] + b[]: [5, 2, -4, -1, -2, 0, -4, -1]
Python
The +
operator concatenates two lists and returns a new list. The list.extend
method appends elements of another list to the receiver.
<lang python>arr1 = [1, 2, 3]
arr2 = [4, 5, 6]
arr3 = [7, 8, 9]
arr4 = arr1 + arr2
assert arr4 == [1, 2, 3, 4, 5, 6]
arr4.extend(arr3)
assert arr4 == [1, 2, 3, 4, 5, 6, 7, 8, 9]</lang>
Note: list.extend is normally accomplished using the += operator like this: <lang python>arr5 = [4, 5, 6] arr6 = [7, 8, 9] arr6 += arr5 assert arr6 == [7, 8, 9, 4, 5, 6]</lang>
R
<lang R> a1 <- c(1, 2, 3) a2 <- c(3, 4, 5) a3 <- c(a1, a2) </lang>
REBOL
<lang REBOL> a1: [1 2 3] a2: [4 5 6] a3: [7 8 9]
append a1 a2 ; -> [1 2 3 4 5 6]
append/only a1 a3 ; -> [1 2 3 4 5 6 [7 8 9]] </lang>
Retro
<lang Retro>needs array'
^array'new{ 1 2 3 } ^array'new{ 4 5 6 } ^array'append</lang>
REXX
REXX doesn't have arrays as such, but it has something that looks, feels, and tastes like arrays: stemmed variables.
Simply, a stemmed array is a variable with an appended dot (.) followed
by a constant (such as an integer). There is no way to preallocate a
stemmed variable, REXX just assigns them as they are created.
As such, there isn't an easy way to keep track of the number of "elements" in a REXX "array".
Consider:
<lang rexx>a.1 = 10
a.2 = 22.7
a.7 = -12</lang>
where now we have three "elements", and they are disjointed.
There are ways to handle this in REXX however.
When assigning stemmed arrays, it is common to assign "element" zero to
the number of values, assuming that the stemmed variables are
sequential.
example:
<lang rexx>fact.0=8
fact.1= 1
fact.2= 2
fact.3= 6
fact.4= 24
fact.5= 120
fact.6= 720
fact.7= 5040
fact.8=40320</lang>
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.
<lang rexx>p.= /*a short list of primes.*/
p.1=2; p.2=3; p.3=5; p.4=7; p.5=11; p.6=13; p.7=17; p.8=19; p.9=23
p.10=27; p.11=31; p.12=37
f.= /*a short list of Fibonacci numbers.*/ f.1=1;f.2=1;f.3=2;f.4=3;f.5=5;f.6=8;f.7=13;f.8=21;f.9=34;f.10=55
do j=1 while p.j\== c.j=p.j end /*j*/
n=j-1
do k=1 while f.k\==; n=n+1 c.n=f.k end /*k*/
say 'n'=n
do m=1 for n say 'c.'m"="c.m end /*m*/</lang>
output
elements=22 c.1=2 c.2=3 c.3=5 c.4=7 c.5=11 c.6=13 c.7=17 c.8=19 c.9=23 c.10=27 c.11=31 c.12=37 c.13=1 c.14=1 c.15=2 c.16=3 c.17=5 c.18=8 c.19=13 c.20=21 c.21=34 c.22=55
RLaB
In RLaB the matrices can be appended (column-wise) or stacked (row-wise). Consider few examples: <lang RLaB> >> x = [1, 2, 3] >> y = [4, 5, 6] // appending matrix 'y' on the right from matrix 'x' is possible if the two matrices have // the same number of rows: >> z1 = [x, y] matrix columns 1 thru 6
1 2 3 4 5 6
// stacking matrix 'y' below the matrix 'x' is possible if the two matrices have // the same number of columns: >> z2 = [x; y]
1 2 3 4 5 6
>> </lang>
Ruby
The Array#+
method concatenates two arrays and returns a new array. The Array#concat
method appends elements of another array to the receiver.
<lang ruby>arr1 = [1, 2, 3]
arr2 = [4, 5, 6]
arr3 = [7, 8, 9]
arr4 = arr1 + arr2 # => [1, 2, 3, 4, 5, 6]
arr4.concat(arr3) # => [1, 2, 3, 4, 5, 6, 7, 8, 9]</lang>
Scala
<lang Scala>val arr1 = Array( 1, 2, 3 ) val arr2 = Array( 4, 5, 6 ) val arr3 = Array( 7, 8, 9 )
arr1 ++ arr2 ++ arr3 //or: Array concat ( arr1, arr2, arr3 ) // res0: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)</lang>
Scheme
<lang scheme>; in r5rs, there is append for lists, but we'll need to define vector-append (define (vector-append . arg) (list->vector (apply append (map vector->list arg))))
(vector-append #(1 2 3 4) #(5 6 7) #(8 9 10))
- #(1 2 3 4 5 6 7 8 9 10)</lang>
Note : vector-append is also defined in SRFI-43.
Seed7
<lang seed7>$ include "seed7_05.s7i";
var array integer: a is [] (1, 2, 3, 4); var array integer: b is [] (5, 6, 7, 8); var array integer: c is [] (9, 10);
const proc: main is func
local var integer: number is 0; begin c := a & b; for number range c do write(number <& " "); end for; writeln; end func;</lang>
Output:
1 2 3 4 5 6 7 8
Slate
The binary operation of concatenation is made with the ; (semi-colon) from the type Sequence. It is also available for appending Sequences to WriteStreams.
<lang slate> {1. 2. 3. 4. 5} ; {6. 7. 8. 9. 10} </lang>
Smalltalk
Concatenation (appending) is made with the method , (comma), present in classes SequenceableCollection, ArrayedCollection and their subclasses (e.g. Array, String, OrderedCollection ...)
<lang smalltalk>|a b c| a := #(1 2 3 4 5). b := #(6 7 8 9 10). c := a,b. c displayNl.</lang>
SNOBOL4
<lang SNOBOL4>* # Concatenate 2 arrays (vectors)
define('cat(a1,a2)i,j') :(cat_end)
cat cat = array(prototype(a1) + prototype(a2)) cat1 i = i + 1; cat = a1 :s(cat1) cat2 j = j + 1; cat = a2<j> :s(cat2)f(return) cat_end
- # Fill arrays
str1 = '1 2 3 4 5'; arr1 = array(5)
loop i = i + 1; str1 len(p) span('0123456789') . arr1 @p :s(loop)
str2 = '6 7 8 9 10'; arr2 = array(5)
loop2 j = j + 1; str2 len(q) span('0123456789') . arr2<j> @q :s(loop2)
- # Test and display
arr3 = cat(arr1,arr2)
loop3 k = k + 1; str3 = str3 arr3<k> ' ' :s(loop3)
output = str1 output = str2 output = str3
end</lang>
Output:
1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10
Standard ML
<lang 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] *) </lang>
Tcl
<lang tcl>set a {1 2 3} set b {4 5 6} set ab [concat $a $b]; # 1 2 3 4 5 6</lang> 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.
TI-89 BASIC
If a and b are lists, augment(a, b)
concatenates them in the usual fashion. If a and b are matrices, then augment(a, b)
produces a matrix whose columns are the columns of a followed by the columns of b, i.e. an augmented matrix.
■ augment({1,2}, {3,4}) {1,2,3,4} ■ augment([[1][2]], [[3][4]]) [[1,3][2,4]]
That last example as displayed in pretty-printing mode:
Concatenation in the other direction may of course be done by transposition:
■ augment([[x][y]], [[z][w]]) [[x][y][z][w]]
Trith
<lang trith>[1 2 3] [4 5 6] concat</lang>
UNIX Shell
Using proper built-in Bash arrays:
<lang bash>array1=( 1 2 3 4 5 ) array2=( 6 7 8 9 10 ) botharrays=( ${array1[@]} ${array2[@]} )</lang>
Whitespace-delimited strings work in much the same way:
<lang bash>array1='1 2 3 4 5' array2='6 7 8 9 10'
- Concatenated to a Bash array ...
botharrays_a=( $array1 $array2 )
- Concatenated to a string ...
botharrays_s="$array1 $array2"</lang>
Vala
<lang vala>int[] array_concat(int[]a,int[]b){ int[] c = new int[a.length + b.length]; Memory.copy(c, a, a.length * sizeof(int)); Memory.copy(&c[a.length], b, b.length * sizeof(int)); return c; } void main(){ int[] a = {1,2,3,4,5}; int[] b = {6,7,8}; int[] c = array_concat(a,b); foreach(int i in c){ stdout.printf("%d\n",i); } }</lang>
VBScript
<lang vb>Function ArrayConcat(arr1, arr2)
ReDim ret(UBound(arr1) + UBound(arr2) + 1) For i = 0 To UBound(arr1) ret(i) = arr1(i) Next offset = Ubound(arr1) + 1 For i = 0 To UBound(arr2) ret(i + offset) = arr2(i) Next ArrayConcat = ret
End Function
arr1 = array(10,20,30) arr2 = array(40,50,60) WScript.Echo "arr1 = array(" & Join(arr1,", ") & ")" WScript.Echo "arr2 = array(" & Join(arr2,", ") & ")" arr3 = ArrayConcat(arr1, arr2) WScript.Echo "arr1 + arr2 = array(" & Join(arr3,", ") & ")"</lang>
Output:
arr1 = array(10, 20, 30) arr2 = array(40, 50, 60) arr1 + arr2 = array(10, 20, 30, 40, 50, 60)
Visual Basic .NET
<lang vbnet>
Dim iArray1() As Integer = {1, 2, 3} Dim iArray2() As Integer = {4, 5, 6} Dim iArray3() As Integer = Nothing
iArray3 = iArray1.Concat(iArray2).ToArray
</lang>
Yorick
<lang yorick>a = [1,2,3]; b = [4,5,6]; ab = grow(a, b);</lang>
Zsh
Concatenating arrays. <lang zsh>a=(1 2 3) b=(a b c)
c=($a $b)</lang> Pushing a single element into an array. <lang zsh>a+=4</lang> Pushing another array into an array. <lang zsh>a+=($b)</lang>
- Programming Tasks
- Data Structures
- ACL2
- ActionScript
- Ada
- ALGOL 68
- AutoHotkey
- Babel
- BBC BASIC
- C
- C++
- C sharp
- Clojure
- CoffeeScript
- Common Lisp
- D
- Delphi
- E
- Efene
- Elena
- Emacs Lisp
- Erlang
- Euphoria
- F Sharp
- Factor
- Fantom
- Forth
- Fortran
- GAP
- Go
- Gosu
- Groovy
- Haskell
- HicEst
- Icon
- Unicon
- IDL
- Inform 7
- Ioke
- J
- Java
- JavaScript
- K
- LabVIEW
- Liberty BASIC
- Logo
- Lua
- Mathematica
- MATLAB
- Maxima
- Mercury
- Nemerle
- NewLISP
- Objeck
- Objective-C
- OCaml
- OoRexx
- Order
- OxygenBasic
- Oz
- PARI/GP
- Pascal
- Perl
- Perl 6
- PHP
- PicoLisp
- PL/I
- PostScript
- Initlib
- PowerShell
- Prolog
- PureBasic
- Python
- R
- REBOL
- Retro
- REXX
- RLaB
- Ruby
- Scala
- Scheme
- Seed7
- Slate
- Smalltalk
- SNOBOL4
- Standard ML
- Tcl
- TI-89 BASIC
- Trith
- UNIX Shell
- Vala
- VBScript
- Visual Basic .NET
- Yorick
- Zsh