Array concatenation: Difference between revisions
m
→{{header|Binary Lambda Calculus}}
(41 intermediate revisions by 30 users not shown) | |||
Line 1:
[[Category:Simple]]
{{task|Data Structures}}
;Task:
Line 10:
=={{header|11l}}==
<
V arr2 = [4, 5, 6]
print(arr1 [+] arr2)</
{{out}}
<pre>
Line 21:
In order for this to work, you'll either need to use <code>malloc()</code> or know a memory location of "free space" at compile time. This example shall use the latter.
<
;concatenate Array1 + Array2
Line 43:
DC.W 1,2,3,4,5
Array2:
DC.W 6,7,8,9,10</
=={{header|8th}}==
<syntaxhighlight lang="forth">
[1,2,3] [4,5,6] a:+ .
</syntaxhighlight>
{{out}}
<pre>
Line 56:
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program concAreaString.s */
Line 158:
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
=={{header|ABAP}}==
The concept of arrays does not exist in ABAP, instead internal tables are used. This works in ABAP version 7.40 and above.
<syntaxhighlight lang="abap">
report z_array_concatenation.
Line 174:
write <line>.
endloop.
</syntaxhighlight>
{{out}}
Line 184:
=={{header|ACL2}}==
This is for lists, not arrays; ACL2's array support is limited.
<syntaxhighlight lang
=={{header|Action!}}==
<
BYTE i
Line 237:
Test(a2,a1,6,4)
Test(a3,a2,5,4)
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Array_concatenation.png Screenshot from Atari 8-bit computer]
Line 249:
=={{header|ActionScript}}==
<
var array2:Array = new Array(4, 5, 6);
var array3:Array = array1.concat(array2); //[1, 2, 3, 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);
Y : T := X & (4, 5, 6); -- Concatenate X and (4, 5, 6)</
=={{header|Aime}}==
<
{
list o;
Line 282:
0;
}</
{{Out}}
<pre> 1 2 3 4 5 6 7 8</pre>
Line 293:
<!-- {{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;
Line 322:
VOID(a +=: b);
print(("a +=: b", b, new line))</
<pre>
a + b +1 +2 +3 +4 +5
Line 331:
=={{header|ALGOL W}}==
Algol W does not allow procedures to return arrays and has no mechanism for procedures to find the bounds of their parameters, so the caller must supply an array to concatenate into and the bounds of the arrays.
<
integer array a ( 1 :: 5 );
integer array b ( 2 :: 4 );
Line 366:
for cPos := 1 until 8 do writeon( i_w := 1, s_w := 1, c( cPos ) )
end.</
{{out}}
<pre>
Line 373:
=={{header|Amazing Hopper}}==
<syntaxhighlight lang="amazing hopper">
#include <hbasic.h>
Begin
Line 382:
Concat (a1, a2) and Print ( a2, Newl )
End
</syntaxhighlight>
{{out}}
<pre>
Line 389:
=={{header|AntLang}}==
<
b: <"Hello"; 42>
c: a,b</
=={{header|Apex}}==
<
List<String> listB = new List<String> { 'banana' };
listA.addAll(listB);
System.debug(listA); // Prints (apple, banana)</
=={{header|APL}}==
<
1 2 3 , 4 5 6
1 2 3 4 5 6
</syntaxhighlight>
=={{header|AppleScript}}==
<syntaxhighlight lang="applescript">
set listA to {1, 2, 3}
set listB to {4, 5, 6}
return listA & listB
</syntaxhighlight>
{{out}}
Line 422:
{{trans|JavaScript}}
<
concat([["alpha", "beta", "gamma"], ¬
Line 440:
end concat
</syntaxhighlight>
{{Out}}
Line 448:
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
/* program concAreaString.s */
Line 620:
.Ls_magic_number_10: .word 0x66666667
</syntaxhighlight>
=={{header|Arturo}}==
<
arr2: ["four" "five" "six"]
print arr1 ++ arr2</
{{out}}
Line 636:
The following may seem frightening. However, it probably compiles down to two calls to __builtin_memcpy. All the complexity is to make sure those calls are done ''correctly''.
<
(* In a way, the task is misleading: in a language such as ATS, one
Line 757:
free lst (* The list is linear and must be freed. *)
end
end</
{{out}}
Line 772:
=== True Arrays ===
{{works with|AutoHotkey_L}}
<
List2 := [4, 5, 6]
cList := Arr_concatenate(List1, List2)
Line 789:
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
Line 828:
List .= (A_Index = 1 ? "" : ",") %Array%%A_Index%
Return, List
}</
Message box shows:
<pre>1,2,3,4,5,6</pre>
Line 838:
<syntaxhighlight lang="autoit">
_ArrayConcatenate($avArray, $avArray2)
Func _ArrayConcatenate(ByRef $avArrayTarget, Const ByRef $avArraySource, $iStart = 0)
Line 857:
Return $iUBoundTarget + $iUBoundSource
EndFunc ;==>_ArrayConcatenate
</syntaxhighlight>
=={{header|Avail}}==
<
=={{header|AWK}}==
<
BEGIN {
split("cul-de-sac",a,"-")
Line 881:
c[++nc]=b[i]
}
}</
=={{header|Babel}}==
<
{{Out}}
Line 890:
=={{header|bash}}==
<
y=(5 6)
sum=( "${x[@]}" "${y[@]}" )
Line 898:
3 4
5
6</
=={{header|BASIC}}==
==={{header|Applesoft BASIC}}===
{{works with|Chipmunk Basic}}
<syntaxhighlight lang="gwbasic"> 10 LET X = 4:Y = 5
20 DIM A(X - 1),B(Y - 1),C(X + Y - 1)
30 FOR I = 1 TO X:A(I - 1) = I: NEXT
40 FOR I = 1 TO Y:B(I - 1) = I * 10: NEXT
50 FOR I = 1 TO X:C(I - 1) = A(I - 1): NEXT
60 FOR I = 1 TO Y:C(X + I - 1) = B(I - 1): NEXT
70 FOR I = 1 TO X + Y: PRINT MID$ (" ",1,I > 1)C(I - 1);: NEXT</syntaxhighlight>
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
The [[#GW-BASIC|GW-BASIC]] solution works without any changes.
==={{header|GW-BASIC}}===
{{works with|PC-BASIC|any}}
{{works with|BASICA}}
{{works with|Chipmunk Basic}}
{{works with|QBasic}}
{{works with|MSX BASIC}}
<syntaxhighlight lang="qbasic">100 U1 = 3: U2 = 4
110 DIM A$(3)
120 DATA "The","quick","brown","fox"
130 FOR I = 0 TO U1 : READ A$(I) : NEXT I
140 DIM B$(4)
150 DATA "jumped","over","the","lazy","dog"
160 FOR I = 0 TO U2 : READ B$(I) : NEXT I
170 'SU2 ConcatArrays
180 X = U1 + 1
190 Y = U2 + 1
200 Z = X + Y
210 DIM C$(Z-1)
220 FOR I = 0 TO X-1
230 C$(I) = A$(I)
240 NEXT I
250 FOR I = 0 TO Y-1
260 C$(U1+I+1) = B$(I)
270 NEXT I
280 '
290 FOR I = 0 TO Z-1
300 PRINT C$(I); " ";
310 NEXT I
320 END</syntaxhighlight>
==={{header|Minimal BASIC}}===
{{trans|Applesoft BASIC}}
{{works with|GW-BASIC}}
{{works with|Chipmunk Basic}}
{{works with|QBasic}}
{{works with|Quite BASIC}}
{{works with|MSX BASIC}}
<syntaxhighlight lang="qbasic">10 LET X = 4
20 LET Y = 5
30 DIM A(3)
40 DIM B(4)
50 DIM C(8)
60 FOR I = 1 TO X
70 LET A(I-1) = I
80 NEXT I
90 FOR I = 1 TO Y
100 LET B(I-1) = I*10
110 NEXT I
120 FOR I = 1 TO X
130 LET C(I-1) = A(I-1)
140 NEXT I
150 FOR I = 1 TO Y
160 LET C(X+I-1) = B(I-1)
170 NEXT I
180 FOR I = 1 TO X+Y
190 PRINT C(I-1);
200 NEXT I
210 END</syntaxhighlight>
==={{header|MSX Basic}}===
{{works with|MSX BASIC|any}}
The [[#GW-BASIC|GW-BASIC]] solution works without any changes.
==={{header|Quite BASIC}}===
{{trans|GW-BASIC}}
<syntaxhighlight lang="qbasic">100 LET U1 = 3
105 LET U2 = 4
110 ARRAY A$
120 DATA "The","quick","brown","fox"
130 FOR I = 0 TO U1 : READ A$(I) : NEXT I
140 ARRAY B$
150 DATA "jumped","over","the","lazy","dog"
160 FOR I = 0 TO U2 : READ B$(I) : NEXT I
170 rem Sub ConcatArrays
180 LET X = U1 + 1
190 LET Y = U2 + 1
200 LET Z = X + Y
210 ARRAY C
220 FOR I = 0 TO X-1
230 LET C$(I) = A$(I)
240 NEXT I
250 FOR I = 0 TO Y-1
260 LET C$(U1 + I + 1) = B$(I)
270 NEXT I
280 rem
290 FOR I = 0 TO Z-1
300 PRINT C$(I);" ";
310 NEXT I
320 END</syntaxhighlight>
==={{header|BaCon}}===
<
DECLARE b[] = { 6, 7, 8, 9, 10 }
Line 911 ⟶ 1,014:
c[x] = a[x]
c[x+5] = b[x]
NEXT</
==={{header|BBC BASIC}}===
{{works with|BBC BASIC for Windows}}
<
a() = 1, 2, 3, 4
b() = 5, 6, 7, 8, 9
Line 933 ⟶ 1,036:
SYS "RtlMoveMemory", ^c(0), ^a(0), s%*na%
SYS "RtlMoveMemory", ^c(na%), ^b(0), s%*nb%
ENDPROC</
==={{header|Commodore BASIC}}===
(Based on ZX Spectrum BASIC version)
<
20 DIM A(X) : DIM B(Y) : DIM C(X+Y)
30 FOR I=1 TO X
Line 953 ⟶ 1,056:
150 FOR I=1 TO X+Y
160 : PRINT C(I);
170 NEXT</
==={{header|Run BASIC}}===
{{works with|Just BASIC}}
{{works with|Liberty BASIC}}
The [[#Liberty BASIC|Liberty BASIC]] solution works without any changes.
=={{header|BASIC256}}==
<
global c
Line 992 ⟶ 1,099:
return nt
end function</
{{out}}
<pre>1, 2, 3, 4, 5, 6, 7, 8, 9, 10</pre>
=={{header|Binary Lambda Calculus}}==
BLC uses lists instead of arrays. List concatenation is (see also https://github.com/tromp/AIT/blob/master/lists/cat.lam)
<pre>00011001000110100000000000010110111100101111001111110111110110</pre>
=={{header|BQN}}==
<syntaxhighlight lang
=={{header|Bracmat}}==
Line 1,022 ⟶ 1,134:
=={{header|Burlesque}}==
<
blsq ) {1 2 3}{4 5 6}_+
{1 2 3 4 5 6}
</syntaxhighlight>
=={{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>
Line 1,060 ⟶ 1,172:
free(c);
return EXIT_SUCCCESS;
}</
=={{header|C sharp|C#}}==
<
namespace RosettaCode
Line 1,084 ⟶ 1,196:
}
}
}</
Alternatively, using LINQ extension methods:
{{works with|C sharp|C#|3}}
<
class Program
Line 1,100 ⟶ 1,212:
int[] c = a.Concat(b).ToArray();
}
}</
=={{header|C++}}==
<
#include <iostream>
Line 1,116 ⟶ 1,228:
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>
Line 1,133 ⟶ 1,245:
std::cout << std::endl;
return 0;
}</
This is another solution with function level templates and pointers.
<
using namespace std;
Line 1,186 ⟶ 1,298:
return 0;
}</
=={{header|Ceylon}}==
<
value a = Array {1, 2, 3};
value b = Array {4, 5, 6};
value c = concatenate(a, b);
print(c);
}</
=={{header|Clojure}}==
<
The inputs can be any collection, including Java arrays, and returns a lazy sequence of the elements.
A vector is the closest Clojure thing to an array. If a vector is wanted, then use
<
=={{header|COBOL}}==
{{works with|COBOL 2014}}
<syntaxhighlight lang="cobolfree">IDENTIFICATION DIVISION.
PROGRAM-ID. array-concat.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 table-one.
05 int-field PIC 999 OCCURS 0 TO 5 TIMES DEPENDING ON t1.
01 table-two.
05 int-field PIC 9(4) OCCURS 0 TO 10 TIMES DEPENDING ON t2.
77 tally USAGE IS INDEX.
77 t1 PIC 99.
77 t2 PIC 99.
77 show PIC Z(4) USAGE IS DISPLAY.
PROCEDURE DIVISION.
array-concat-main.
PERFORM
PERFORM concatenate-tables
PERFORM
GOBACK.
initialize-tables.
MOVE 4 TO t1
PERFORM VARYING tally FROM 1 BY 1 UNTIL tally > t1
COMPUTE int-field OF table-one(tally) = tally * 3
END-PERFORM
MOVE 3 TO t2
PERFORM VARYING tally FROM 1 BY 1 UNTIL tally > t2
COMPUTE int-field OF table-two(tally) = tally * 6
END-PERFORM.
concatenate-tables.
PERFORM VARYING tally FROM 1 BY 1 UNTIL tally > t1
ADD 1 TO t2
MOVE int-field OF table-one(tally)
TO int-field OF table-two(t2)
END-PERFORM.
display-result.
PERFORM VARYING tally FROM 1 BY 1 UNTIL tally = t2
MOVE int-field OF table-two(tally) TO show
DISPLAY FUNCTION TRIM(show) ", " WITH NO ADVANCING
END-PERFORM
MOVE int-field OF table-two(tally) TO show
DISPLAY FUNCTION TRIM(show).
END PROGRAM array-concat.</syntaxhighlight>
{{out}}
<pre>
6, 12, 18, 3, 6, 9, 12
</pre>
=={{header|CoffeeScript}}==
<
# like in JavaScript
a = [1, 2, 3]
b = [4, 5, 6]
c = a.concat b
</syntaxhighlight>
=={{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.
<
=> #(0 1 2 3 4 5 6 7)</
===Alternate solution===
I use [https://franz.com/downloads/clp/survey Allegro CL 10.1]
<
(setf arr1 (make-array '(3) :initial-contents '(1 2 3)))
(setf arr2 (make-array '(3) :initial-contents '(4 5 6)))
Line 1,295 ⟶ 1,398:
(write arr5)
(terpri)
</syntaxhighlight>
Output:
<pre>
Line 1,304 ⟶ 1,407:
=={{header|Component Pascal}}==
BlackBox Component Builder
<
MODULE ArrayConcat;
IMPORT StdLog;
Line 1,360 ⟶ 1,463:
END ArrayConcat.
</syntaxhighlight>
Execute: ^Q ArrayConcat.Do <br/>
{{out}}
Line 1,371 ⟶ 1,474:
=={{header|Crystal}}==
<
arr2 = ["foo", "bar", "baz"]
arr1 + arr2 #=> [1, 2, 3, "foo", "bar", "baz"]</
=={{header|D}}==
<
void main() {
Line 1,383 ⟶ 1,486:
writeln(a, " ~ ", b, " = ", a ~ b);
}</
{{out}}
<pre>[1, 2] ~ [4, 5, 6] = [1, 2, 4, 5, 6]</pre>
Line 1,389 ⟶ 1,492:
=={{header|Delphi}}==
2022/07/13
<
// This example works on stuff as old as Delphi 5 (maybe older)
// Modern Delphi / Object Pascal has both
Line 1,443 ⟶ 1,546:
Writeln( #13#10, Join(names, #13#10 ) );
end.
</syntaxhighlight>
Output:
Korra Asami Bolin Mako
Line 1,461 ⟶ 1,564:
It has running commentary about memory management that isn’t exactly correct.<br>
Delphi handles dynamic array memory very well.
<
TReturnArray = array of integer; //you need to define a type to be able to return it
Line 1,498 ⟶ 1,601:
Finalize(r1); //IMPORTANT!
ShowMessage(IntToStr(High(r1)));
end;</
=={{header|Diego}}==
<
add_ary(a)_values(1,2,3);
Line 1,509 ⟶ 1,612:
me_msg()_calc([a]+[b]); // alternative
reset_namespace[];</
=={{header|Dyalect}}==
<
var ys = [4,5,6]
var alls = Array.Concat(xs, ys)
print(alls)</
{{out}}
Line 1,524 ⟶ 1,627:
=={{header|E}}==
<
# value: [1, 2, 3, 4]</
=={{header|EasyLang}}==
<syntaxhighlight lang="text">a[] = [ 1 2 3 ]
b[] = [ 4 5 6 ]
c[] = a[]
c[] &=
.
print c[]</
=={{header|EchoLisp}}==
The native operators are '''append''' for lists, and '''vector-append''' for vectors (1-dim arrays).
<
;;;; VECTORS
(vector-append (make-vector 6 42) (make-vector 4 666))
Line 1,555 ⟶ 1,657:
</syntaxhighlight>
=={{header|ECL}}==
<syntaxhighlight lang="text">
A := [1, 2, 3, 4];
B := [5, 6, 7, 8];
C := A + B;</
=={{header|Ecstasy}}==
It is as simple as <code><var>array1</var> + <var>array2</var></code>:
<syntaxhighlight lang="java">String[] fruits = ["apples", "oranges"];
String[] grains = ["wheat", "corn"];
String[] all = fruits + grains;</syntaxhighlight>
=={{header|Efene}}==
Line 1,569 ⟶ 1,677:
using the ++ operator and the lists.append function
<
@public
run = fn () {
Line 1,580 ⟶ 1,688:
io.format("~p~n", [C])
io.format("~p~n", [D])
}</
=={{header|EGL}}==
{{works with|EDT}}
<syntaxhighlight lang="egl">
program ArrayConcatenation
function main()
Line 1,598 ⟶ 1,706:
end
end
</syntaxhighlight>
=={{header|Ela}}==
<
ys = [4,5,6]
xs ++ ys</
{{out}}<pre>[1,2,3,4,5,6]</pre>
=={{header|Elena}}==
ELENA 5.0 :
<
public program()
Line 1,618 ⟶ 1,726:
"(",a.asEnumerable(),") + (",b.asEnumerable(),
") = (",(a + b).asEnumerable(),")").readChar();
}</
{{out}}
<pre>
Line 1,625 ⟶ 1,733:
=={{header|Elixir}}==
<
[1, 2, 3, 4, 5, 6]
iex(2)> Enum.concat([[1, [2], 3], [4], [5, 6]])
[1, [2], 3, 4, 5, 6]
iex(3)> Enum.concat([1..3, [4,5,6], 7..9])
[1, 2, 3, 4, 5, 6, 7, 8, 9]</
=={{header|Elm}}==
<
import Html.App exposing (beginnerProgram)
import Array exposing (Array, append, initialize)
Line 1,651 ⟶ 1,759:
}
-- Array.fromList [0,1,2,3,4,5]</
=={{header|Emacs Lisp}}==
The ''vconcat'' function returns a new array containing all the elements of it's arguments.
<
=> [1 2 3 4 5 6 7 8 9]</
=={{header|EMal}}==
<syntaxhighlight lang="emal">
^|EMal has the concept of list expansion,
|you can expand a list to function arguments
|by prefixing it with the unary plus.
|^
List a = int[1,2,3]
List b = int[4,5,6]
List c = int[+a, +b]
writeLine(c)
</syntaxhighlight>
{{out}}
<pre>
[1,2,3,4,5,6]
</pre>
=={{header|Erlang}}==
Line 1,664 ⟶ 1,788:
On the shell,
<
1> [1, 2, 3] ++ [4, 5, 6].
[1,2,3,4,5,6]
Line 1,670 ⟶ 1,794:
[1,2,3,4,5,6]
3>
</syntaxhighlight>
=={{header|ERRE}}==
<syntaxhighlight lang="text">
PROGRAM ARRAY_CONCAT
Line 1,705 ⟶ 1,829:
END PROGRAM
</syntaxhighlight>
=={{header|Euphoria}}==
<
s1 = {1,2,3}
s2 = {4,5,6}
s3 = s1 & s2
? s3</
{{out}}
Line 1,719 ⟶ 1,843:
=={{header|F Sharp|F#}}==
Array concatenation.
<
let b = [|4; 5; 6;|]
let c = Array.append a b</
List concatenation (@ and List.append are equivalent).
<
let y = [4; 5; 6]
let z1 = x @ y
let z2 = List.append x y</
=={{header|Factor}}==
<syntaxhighlight lang
'''Example''':
<
( scratchpad ) { 1 2 } { 3 4 } append .
{ 1 2 3 4 }</
=={{header|Fantom}}==
Line 1,740 ⟶ 1,864:
In fansh:
<
> a := [1,2,3]
> b := [4,5,6]
Line 1,746 ⟶ 1,870:
> a
[1,2,3,4,5,6]
</syntaxhighlight>
Note 'addAll' is destructive. Write 'a.dup.addAll(b)' to create a fresh list.
Line 1,752 ⟶ 1,876:
=={{header|FBSL}}==
Array concatenation:
<
DIM aint[] ={1, 2, 3}, astr[] ={"one", "two", "three"}, asng[] ={!1, !2, !3}
Line 1,760 ⟶ 1,884:
NEXT
PAUSE</
{{out}}
<pre>1 2 3 one two three 1.000000 2.000000 3.000000
Line 1,766 ⟶ 1,890:
=={{header|Forth}}==
<
2dup + >r swap move r> ;
: cat ( a2 u2 a1 u1 -- a3 u1+u2 )
Line 1,779 ⟶ 1,903:
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 - ........
</syntaxhighlight>
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<
implicit none
Line 1,799 ⟶ 1,923:
d = [a, b] ! (/a, b/)
print*, d
end program Concat_Arrays</
=={{header|Free Pascal}}==
Since FPC (Free Pascal compiler) version 3.2.0., the dynamic array concatenation operator <code>+</code> is available, provided <code>{$modeSwitch arrayOperators+}</code> (which is enabled by default in <code>{$mode Delphi}</code>).
<
Alternatively, one could use <code>concat()</code> which is independent of above modeswitch and mode. Neither option requires the use of any libraries.:
<
A more complete example:
<syntaxhighlight lang="pascal">
Program arrayConcat;
{$mode delphi}
type
TDynArr = array of integer;
var
i: integer;
arr1, arr2, arrSum : TDynArr;
begin
arr1 := [1, 2, 3];
arr2 := [4, 5, 6];
arrSum := arr1 + arr2;
for i in arrSum do
write(i, ' ');
writeln;
end.
</syntaxhighlight>
{{out}}
<pre>
1 2 3 4 5 6
</pre>
=={{header|FreeBASIC}}==
<
' FB 1.05.0 Win64
Line 1,836 ⟶ 1,988:
Print "Press any key to quit the program"
Sleep
</syntaxhighlight>
{{out}}
Line 1,844 ⟶ 1,996:
=={{header|Frink}}==
<
a = [1,2]
b = [3,4]
a.pushAll[b]
</syntaxhighlight>
=={{header|FunL}}==
<
arr2 = array( [4, 5, 6] )
arr3 = array( [7, 8, 9] )
println( arr1 + arr2 + arr3 )</
{{out}}
Line 1,867 ⟶ 2,019:
Array concatenation is done with the built-in function <code>concat</code>, which can take any number of arguments:
<syntaxhighlight lang="futhark">
concat as bs cd
</syntaxhighlight>
=={{header|FutureBasic}}==
<
CFArrayRef array = @[@"Alpha",@"Bravo",@"Charlie"]
print array
Line 1,885 ⟶ 2,037:
fn DoIt
HandleEvents</
Output:
<pre>
Line 1,905 ⟶ 2,057:
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=314bea6fba7f177a1cfaec8a7a8b5ccb Click this link to run this code]'''
<
Dim sString1 As String[] = ["The", "quick", "brown", "fox"]
Dim sString2 As String[] = ["jumped", "over", "the", "lazy", "dog"]
Line 1,913 ⟶ 2,065:
Print sString1.Join(" ")
End</
Output:
<pre>
Line 1,920 ⟶ 2,072:
=={{header|GAP}}==
<
Concatenation([1, 2, 3], [4, 5, 6], [7, 8, 9]);
# [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
Line 1,929 ⟶ 2,081:
Append(a, [7, 8, 9]);
a;
# [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]</
=={{header|Genie}}==
<
/*
Array concatenation, in Genie
Line 1,959 ⟶ 2,111:
stdout.printf("y: "); int_show_array(y)
stdout.printf("z: "); int_show_array(z)
print "%d elements in new array", z.length</
{{out}}
Line 1,971 ⟶ 2,123:
=={{header|GLSL}}==
This macro concatenates two arrays to form a new array. The first parameter is the type of the array:
<
#define array_concat(T,a1,a2,returned) \
T[a1.length()+a2.length()] returned; \
Line 1,982 ⟶ 2,134:
} \
}
</syntaxhighlight>
The macro can be used like this:
<
array_concat(float,float[](1.,2.,3.),float[](4.,5.,6.),returned);
int i = returned.length();
</syntaxhighlight>
=={{header|Go}}==
<
import "fmt"
Line 2,024 ⟶ 2,176:
fmt.Println(n)
}</
{{out}}
<pre>
Line 2,032 ⟶ 2,184:
</pre>
Array concatenation needs can vary. Here is another set of examples that illustrate different techniques.
<
import (
Line 2,088 ⟶ 2,240:
test2_c := ArrayConcat(test2_a, test2_b).([]string)
fmt.Println(test2_a, " + ", test2_b, " = ", test2_c)
}</
{{out}}
<pre>
Line 2,097 ⟶ 2,249:
=={{header|Gosu}}==
<
var listA = { 1, 2, 3 }
var listB = { 4, 5, 6 }
Line 2,104 ⟶ 2,256:
print( listC ) // prints [1, 2, 3, 4, 5, 6]
</syntaxhighlight>
=={{header|Groovy}}==
Solution:
<
Test:
<syntaxhighlight lang
{{out}}
Line 2,118 ⟶ 2,270:
=={{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]
Line 2,125 ⟶ 2,277:
This operator could be defined from the scratch using explicit recursion:
<
[] ++ x = x
(h:t) ++ y = h : (t ++ y)
</syntaxhighlight>
or folding
<
x ++ y = foldr (:) y x
</syntaxhighlight>
=={{header|HicEst}}==
<
c = a
DO i = 1, LEN(b)
c(i + LEN(a)) = b(i)
ENDDO</
=={{header|Hy}}==
<
=> a
[1, 2, 3]
Line 2,157 ⟶ 2,309:
=> (+ [1 2] [3 4] [5 6]) ; can accept multiple arguments
[1, 2, 3, 4, 5, 6]</
=={{header|i}}==
<
a $= [1, 2, 3]
b $= [4, 5, 6]
print(a + b)
}</
=={{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]
Line 2,180 ⟶ 2,332:
write()
end
</syntaxhighlight>
=={{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:
<syntaxhighlight lang="idl">
> a = [1,2,3]
> b = [4,5,6]
Line 2,196 ⟶ 2,348:
> print,b
4 5 6
</syntaxhighlight>
Then they can be concatenated "at the ends":
<syntaxhighlight lang="idl">
> help,[a,b]
<Expression> INT = Array[6]
> print,[a,b]
1 2 3 4 5 6
</syntaxhighlight>
or "at the sides":
<syntaxhighlight lang="idl">
> help,[[a],[b]]
<Expression> INT = Array[3, 2]
Line 2,211 ⟶ 2,363:
1 2 3
4 5 6
</syntaxhighlight>
Note that this requires that the arrays have the same size at the side at which they are concatenated:
<syntaxhighlight lang="idl">
> b = transpose(b)
> help,b
Line 2,227 ⟶ 2,379:
Unable to concatenate variables because the dimensions do not agree: B.
Execution halted at: $MAIN$
</syntaxhighlight>
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".
Line 2,239 ⟶ 2,391:
=={{header|Inform 7}}==
<
let B be {4, 5, 6};
add B to A;</
=={{header|Insitux}}==
<syntaxhighlight lang="insitux">(into [1 2 3] [4 5 6])</syntaxhighlight>
<syntaxhighlight lang="insitux">(.. vec [1 2 3] [4 5 6])</syntaxhighlight>
=={{header|Ioke}}==
<
[1,2,3] + [3,2,1]
+> [1, 2, 3, 3, 2, 1]</
=={{header|J}}==
Line 2,252 ⟶ 2,409:
'''Example''':
<
array2 =: 4 5 6
array1 , array2
1 2 3 4 5 6</
Of course, in J, array concatenation works (consistently) on arrays of any rank or dimension.
Line 2,261 ⟶ 2,418:
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
Line 2,293 ⟶ 2,450:
3 6
$ ab ,: wx NB. applies to new (higher) axis
2 3 3</
=={{header|
<syntaxhighlight lang="jakt">
fn main() {
let a = ["Apple", "Banana"]
let b = ["Cherry", "Durian"]
mut c: [String] = []
c.push_values(&a)
c.push_values(&b)
println("{}", c)
}
</syntaxhighlight>
{{out}}
<pre>
["Apple", "Banana", "Cherry", "Durian"]
</pre>
=={{header|Java}}==
In Java, arrays are immutable, so you'll have to create a new array, and copy the contents of the two arrays into it.<br />
Luckily, Java offers the ''System.arraycopy'' method, which will save you the effort of creating the for-loops.<br />
<syntaxhighlight lang="java">
int[] concat(int[] arrayA, int[] arrayB) {
int[] array = new int[arrayA.length + arrayB.length];
System.arraycopy(arrayA, 0, array, 0, arrayA.length);
System.arraycopy(arrayB, 0, array, arrayA.length, arrayB.length);
return array;
}
</syntaxhighlight>
If you wanted to use for-loops, possibly to mutate the data as it's concatenated, you can use the following.
<syntaxhighlight lang="java">
int[] concat(int[] arrayA, int[] arrayB) {
int[] array = new int[arrayA.length + arrayB.length];
for (int index = 0; index < arrayA.length; index++)
array[index] = arrayA[index];
for (int index = 0; index < arrayB.length; index++)
array[index + arrayA.length] = arrayB[index];
return array;
}
</syntaxhighlight>
A less idiomatic approach would be to use a ''List'', which is a mutable array, similar to a "vector" in other languages.<br />
I have used both arrays and ''List''s extensively and have not noticed any sort of performance degradation, they appear to work equally as fast.<br />
It's worth noting that the Java Collections Framework, which contains the ''List'' class, is built specifically for Objects and not necessarily primitive data-types. Despite this, it's still worth using for primitives, although the conversion to and from arrays is somewhat abstruse.
<syntaxhighlight lang="java">
int[] concat(int[] arrayA, int[] arrayB) {
List<Integer> list = new ArrayList<>();
for (int value : arrayA) list.add(value);
for (int value : arrayB) list.add(value);
int[] array = new int[list.size()];
for (int index = 0; index < list.size(); index++)
array[index] = list.get(index);
return array;
}
</syntaxhighlight>
=={{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).
<
b = [4,5,6],
c = a.concat(b); //=> [1,2,3,4,5,6]</
Line 2,317 ⟶ 2,518:
See, for a function with an analogous type signature, '''concat''' in the Haskell Prelude.
<
'use strict';
Line 2,332 ⟶ 2,533:
);
})();</
{{Out}}
<pre>["alpha", "beta", "gamma", "delta", "epsilon", "zeta", "eta", "theta", "iota"]</pre>
=={{header|Joy}}==
<syntaxhighlight lang="joy">[1 2 3] [4 5 6] concat.</syntaxhighlight>
=={{header|jq}}==
Line 2,344 ⟶ 2,548:
To concatenate the component arrays of an array, A, the <tt>add</tt> filter can be used: <tt>A|add</tt>
jq also supports streams, which are somewhat array-like, so it may be worth mentioning that the concatenation of two or more streams can be accomplished using "," instead of "+". <
[range(1;3), 3, null] # => [1,2,3,null]
</syntaxhighlight>
=={{header|Julia}}==
<
b = [4,5,6]
ab = [a;b]
Line 2,358 ⟶ 2,562:
ab = hcat(a,b) #ab -> 3x2 matrix
# the append!(a,b) method is mutating, appending `b` to `a`
append!(a,b) # a now equals [1,2,3,4,5,6]</
=={{header|K}}==
<syntaxhighlight lang="k">
a: 1 2 3
b: 4 5 6
a,b
1 2 3 4 5 6</
Concatenations on larger dimensions also use ",", often combined with other operations.
<syntaxhighlight lang="k">
ab:3 3#"abcdefghi"
("abc"
Line 2,401 ⟶ 2,605:
("abc036"
"def147"
"ghi258")</
=={{header|Klingphix}}==
<
( 1.0 "Hello" 3 2 / 4 2.1 power ) ( 5 6 7 8 ) chain print
" " input</
{{out}}
<pre>(1, "Hello", 1.5, 18.379173679952562, 5, 6, 7, 8)</pre>
=={{header|Klong}}==
<syntaxhighlight lang="k">
[1 2 3],[4 5 6] :" join "
[1 2 3 4 5 6]
Line 2,422 ⟶ 2,626:
[1 2],:/[[3 4] [5 6] [7 8]] :" join each-right "
[[3 4 1 2] [5 6 1 2] [7 8 1 2]]
</syntaxhighlight>
=={{header|Kotlin}}==
<syntaxhighlight lang="kotlin">fun main() {
val a = intArrayOf(1, 2, 3)
val
val c = a + b
println(c.contentToString())
}</syntaxhighlight>
=={{header|LabVIEW}}==
Line 2,451 ⟶ 2,641:
=={{header|Lambdatalk}}==
<
{def A {A.new 1 2 3 4 5 6}} -> [1,2,3,4,5,6]
{def B {A.new 7 8 9}} -> [7,8,9]
{A.concat {A} {B}} -> [1,2,3,4,5,6,7,8,9]
</syntaxhighlight>
=={{header|Lang}}==
<syntaxhighlight lang="lang">
&a $= [1, 2, 3]
&b $= [4, 5, 6]
&c $= &a ||| &b
fn.println(&c)
</syntaxhighlight>
=={{header|Lang5}}==
<
=={{header|langur}}==
<
val .b = [7, 8, 9]
val .c = .a ~ .b
writeln .c</
{{out}}
Line 2,470 ⟶ 2,668:
=={{header|Lasso}}==
<syntaxhighlight lang="lasso">
local(arr1 = array(1, 2, 3))
local(arr2 = array(4, 5, 6))
Line 2,482 ⟶ 2,680:
arr2 = array(4, 5, 6)
arr3 = array(4, 5, 6)
arr3 = array(1, 2, 3, 4, 5, 6)</
=={{header|LDPL}}==
{{libheader|ldpl-std}}
<syntaxhighlight lang="ldpl">include "std-list.ldpl"
data:
arr1 is number list
arr2 is number list
procedure:
push 1 to arr1
push 2 to arr1
push 3 to arr2
push 4 to arr2
append list arr2 to list arr1
display list arr1
</syntaxhighlight>
{{out}}
<pre>
[1, 2, 3, 4]
</pre>
=={{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)
</syntaxhighlight>
=={{header|Liberty BASIC}}==
{{works with|Just BASIC}}
{{works with|Run BASIC}}
<syntaxhighlight lang="lb"> x=10
y=20
dim array1(x)
Line 2,510 ⟶ 2,731:
for i = 1 to x + y
print array3(i)
next</
=={{header|LIL}}==
LIL uses lists instead of arrays. The builtin '''append''' command could be used as '''append a $b'''. That would add the entire list in variable '''b''' as one item to list '''a'''. Below '''quote''' is used to flatten the lists into a single new list of all items.
<
Array concatenation in LIL
##
Line 2,523 ⟶ 2,744:
print $c
print "[index $c 0] [index $c 3]"</
{{out}}
Line 2,531 ⟶ 2,752:
=={{header|Limbo}}==
<
include "sys.m";
Line 2,553 ⟶ 2,774:
for (i := 0; i < len c; i++)
sys->print("%d\n", c[i]);
}</
=={{header|Lingo}}==
<
b = [3,4,5]
Line 2,564 ⟶ 2,785:
put a
-- [1, 2, 3, 4, 5]</
=={{header|Little}}==
<
int a[] = {0, 1, 2, 3, 4};
int b[] = {5, 6, 7, 8, 9};
int c[] = {(expand)a, (expand)b};
puts(c);
}</
=={{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}
</syntaxhighlight>
=={{header|Lua}}==
<
b = {4, 5, 6}
Line 2,591 ⟶ 2,812:
end
print(table.concat(a, ", "))</
{{out}}
<pre>
Line 2,598 ⟶ 2,819:
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
a=(1,2,3,4,5)
b=Cons(a, (6,7,8),a)
Print b
1 2 3 4 5 6 7 8 1 2 3 4 5
</syntaxhighlight>
Adding 2 dimension arrays
<syntaxhighlight lang="m2000 interpreter">
Dim Base 0, A(2,2)=1, B(1,2)=6
A()=Cons(A(), B(), A(), B())
Line 2,618 ⟶ 2,839:
Print
}
</syntaxhighlight>
{{out}}
<pre>
Line 2,626 ⟶ 2,847:
1 1
1 1
6 6
</pre >
Adding 2 dimension arrays using OLE clause
<syntaxhighlight lang="m2000 interpreter">
Dim OLE Base 0, A(2,2)=1, B(1,2)=6
A()=Cons(A(), B(), A(), B())
\\ Restore the dimensions (without erasing items)
Dim A(Dimension(A(),1)/2, 2)
For I=0 to Dimension(A(),1)-1 {
For j=0 to Dimension(A(),2)-1 {
Print A(i, j),
}
Print
}
</syntaxhighlight>
{{out}}
<pre>
1 1
1 1
1 1
1 1
6 6
6 6
</pre >
Line 2,631 ⟶ 2,876:
=={{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.
<syntaxhighlight lang="maple">
> A := Array( [ 1, 2, 3 ] );
A := [1, 2, 3]
Line 2,657 ⟶ 2,902:
[ ]
[1 2 3]
</syntaxhighlight>
Of course, the order of the arguments is important.
<syntaxhighlight lang="maple">
> ArrayTools:-Concatenate( 1, A, M );
[1 2 3]
Line 2,666 ⟶ 2,911:
[ ]
[d e f]
</syntaxhighlight>
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.
<syntaxhighlight lang="maple">
> L1 := [ 1, 2, 3 ];
L1 := [1, 2, 3]
Line 2,680 ⟶ 2,925:
> [ L1[], L2[] ]; # equivalent, just different syntax
[1, 2, 3, a, b, c]
</syntaxhighlight>
=={{header|Mathcad}}==
Line 2,696 ⟶ 2,941:
augment concatenates arrays column-wise. The two (or more) arrays must have the same number of rows, and the resulting array column count is equal to the total number of columns in the augmented arrays.
<syntaxhighlight lang="mathcad">
create a pair of arbitrary array:
a:=matrix(2,2,max) b:=a+3
Line 2,712 ⟶ 2,957:
|1 1 3 4|
</syntaxhighlight>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
-> {1, 2, 3, 4, 5, 6}</
=={{header|MATLAB}} / {{header|Octave}}==
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.
<
>> b = [4 5 6];
>> c = [a b]
Line 2,729 ⟶ 2,974:
c =
1 2 3
4 5 6</
For concatenation along higher dimensions, use cat():
<
>> b = randn([3 4 7]);
>> c = cat(3,a,b);
>> size(c)
ans =
3 4 12</
=={{header|Maxima}}==
<syntaxhighlight lang="text">u: [1, 2, 3, 4]$
v: [5, 6, 7, 8, 9, 10]$
append(u, v);
Line 2,762 ⟶ 3,007:
[1, 0, 0],
[0, 1, 0],
[0, 0, 1]) */</
=={{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?
Line 2,772 ⟶ 3,017:
=={{header|min}}==
{{works with|min|0.19.3}}
<
{{out}}
<pre>
Line 2,779 ⟶ 3,024:
=={{header|MiniScript}}==
<syntaxhighlight lang="miniscript">
arrOne = [1, 2, 3]
arrTwo = [4, 5, 6]
print arrOne + arrTwo
</syntaxhighlight>
=={{header|Nanoquery}}==
Assuming a and b are array or list objects, they may concatenated using the '+' operator.
<syntaxhighlight lang
The '*' operator may also be used to create a specific number of copies of a list or array.
<pre>% a = list()
Line 2,797 ⟶ 3,042:
=={{header|Neko}}==
<syntaxhighlight lang="actionscript">/*
Array concatenation, in Neko
*/
Line 2,806 ⟶ 3,051:
/* $array(a1, a2) creates an array of two arrays, $aconcat merges to one */
var ac = $aconcat($array(a1, a2))
$print(ac, "\n")</
{{out}}
Line 2,814 ⟶ 3,059:
=={{header|Nemerle}}==
<
using Nemerle.Collections;
Line 2,825 ⟶ 3,070:
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.
<
options replace format comments java crossref nobinary
Line 2,856 ⟶ 3,101:
loop m_ = 0 to merged.length - 1
say m_ merged[m_]
end m_</
{{out}}
<pre>
Line 2,873 ⟶ 3,118:
=={{header|NewLISP}}==
<
; url: http://rosettacode.org/wiki/Array_concatenation
; author: oofoe 2012-01-28
Line 2,888 ⟶ 3,133:
(append '((x 56) (b 99)) '((z 34) (c 23) (r 88))))
(exit)</
{{out}}
Line 2,899 ⟶ 3,144:
Examples tested to work with Q'Nial7
<
+-+-+-+
|1|2|3|
Line 2,906 ⟶ 3,151:
+-+-+-+
|4|5|6|
+-+-+-+</
Table of lists:
<
+-------+-------+
Line 2,916 ⟶ 3,161:
||1|2|3|||4|5|6||
|+-+-+-+|+-+-+-+|
+-------+-------+</
Simple concatenation of two arrays/lists:
<
+-+-+-+-+-+-+
|1|2|3|4|5|6|
+-+-+-+-+-+-+</
Convert list of lists to table:
<
+-+-+-+
|1|2|3|
+-+-+-+
|4|5|6|
+-+-+-+</
Interchange levels of a list of lists:
<
+-----+-----+-----+
|+-+-+|+-+-+|+-+-+|
||1|4|||2|5|||3|6||
|+-+-+|+-+-+|+-+-+|
+-----+-----+-----+</
=={{header|Nim}}==
Dynamic sized Sequences can simply be concatenated:
<
x = @[1,2,3,4,5,6]
y = @[7,8,9,10,11]
z = x & y</
Static sized Arrays:
<
a = [1,2,3,4,5,6]
b = [7,8,9,10,11]
Line 2,956 ⟶ 3,201:
c[0..5] = a
c[6..10] = b</
=={{header|Nu}}==
<syntaxhighlight lang="nu">
let a = [1 2 3]
let b = [4 5 6]
[$a $b] | flatten
</syntaxhighlight>
{{out}}
<pre>
╭───┬───╮
│ 0 │ 1 │
│ 1 │ 2 │
│ 2 │ 3 │
│ 3 │ 4 │
│ 4 │ 5 │
│ 5 │ 6 │
╰───┴───╯
</pre>
=={{header|Oberon-2}}==
<
MODULE ArrayConcat;
IMPORT
Line 3,010 ⟶ 3,273:
END ArrayConcat.
</syntaxhighlight>
{{out}}
<pre>
Line 3,017 ⟶ 3,280:
=={{header|Objeck}}==
<
bundle Default {
class Arithmetic {
Line 3,049 ⟶ 3,312:
}
}
</syntaxhighlight>
=={{header|Objective-C}}==
with immutable arrays:
<
NSArray *arr2 = @[@4, @5, @6];
NSArray *arr3 = [arr1 arrayByAddingObjectsFromArray:arr2];</
or adding onto a mutable array:
<
NSArray *arr2 = @[@4, @5, @6];
NSMutableArray *arr3 = [NSMutableArray arrayWithArray:arr1];
[arr3 addObjectsFromArray:arr2];</
=={{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;;
val list1and2 : int list = [1; 2; 3; 4; 5; 6]</
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;;
val array1and2 : int array = [|1; 2; 3; 4; 5; 6|]</
=={{header|Odin}}==
<syntaxhighlight lang="odin">package main
import "core:fmt"
import "core:slice"
main :: proc() {
x: [3]int = {1, 2, 3}
y: [3]int = {4, 5, 6}
xy: [len(x) + len(y)]int
copy(xy[:], x[:])
copy(xy[len(x):], y[:])
fmt.println(xy)
}</syntaxhighlight>
===Using slices===
<syntaxhighlight lang="odin">package main
import "core:fmt"
import "core:slice"
main :: proc() {
x: [3]int = {1, 2, 3}
y: [3]int = {4, 5, 6}
xy := slice.concatenate([][]int{x[:], y[:]})
defer delete(xy)
fmt.println(xy)
}</syntaxhighlight>
=={{header|Oforth}}==
<
[1, 2, 3 ] [ 4, 5, 6, 7 ] + </
=={{header|Onyx}}==
<
# them, concatenates them, and pushes the result back
# on the stack. This works with arrays of integers,
Line 3,100 ⟶ 3,395:
[1 true `a'] [2 false `b'] [`3rd array'] 3 ncat
# leaves [1 true `a' 2 false `b' `3rd array'] on the stack</
=={{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
say "Array a now has " a~items "items"</
{{out}}
<pre>Array a has 3 items
Line 3,116 ⟶ 3,411:
=={{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)) )
Line 3,122 ⟶ 3,417:
ORDER_PP( 8seq_append(8seq(1, 2, 3), 8seq(4, 5, 6), 8seq(7, 8)) )
// -> (1)(2)(3)(4)(5)(6)(7)(8)</
=={{header|OxygenBasic}}==
<
'CREATE DYNAMIC ARRAY SPACES USING STRINGS
Line 3,148 ⟶ 3,443:
print a[7] 'result 70
</syntaxhighlight>
=={{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
{Tuple.append t(1 2 3) u(4 5 6)} = u(1 2 3 4 5 6)</
=={{header|PARI/GP}}==
<syntaxhighlight lang
=={{header|Pascal}}==
Line 3,166 ⟶ 3,461:
=={{header|Perl}}==
In Perl, arrays placed into list context are flattened:
<
my @arr2 = (4, 5, 6);
my @arr3 = (@arr1, @arr2);</
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;
print "@arr1\n"; # prints "1 2 3 4 5 6"</
=={{header|Phix}}==
{{libheader|Phix/basics}}
<!--<
<span style="color: #004080;">sequence</span> <span style="color: #000000;">s1</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{<span style="color: #000000;">1<span style="color: #0000FF;">,<span style="color: #000000;">2<span style="color: #0000FF;">,<span style="color: #000000;">3<span style="color: #0000FF;">}<span style="color: #0000FF;">,</span> <span style="color: #000000;">s2</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{<span style="color: #000000;">4<span style="color: #0000FF;">,<span style="color: #000000;">5<span style="color: #0000FF;">,<span style="color: #000000;">6<span style="color: #0000FF;">}</span>
<span style="color: #0000FF;">?</span> <span style="color: #000000;">s1</span> <span style="color: #0000FF;">&</span> <span style="color: #000000;">s2
<!--</
{{out}}
<pre>
Line 3,188 ⟶ 3,483:
=={{header|Phixmonti}}==
<
With syntactic sugar
<
( 1.0 "Hello" 3 2 / 4 2.1 power ) ( 5 6 7 8 ) chain print</
=={{header|PHP}}==
<
$arr2 = array(4, 5, 6);
$arr3 = array_merge($arr1, $arr2);</
=={{header|Picat}}==
Line 3,204 ⟶ 3,499:
and back again with to_array/1.
<
L1 = {1,2,3,4,5}, % define an array with {}
L2 = {6,7,8,9},
Line 3,215 ⟶ 3,510:
append(L1.to_list,L2.to_list,L3),
println(L3.to_array),
nl.</
{{out}}
Line 3,226 ⟶ 3,521:
There are destructive concatenations:
<
-> (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!</
and non-destructive concatenations:
<
-> (a b c)
: (append A B) # Append lists in 'A' and 'B'
Line 3,240 ⟶ 3,535:
-> (1 2 3)
: B
-> (a b c) # Arguments are not modified</
=={{header|Pike}}==
<
array arr1 = ({1, 2, 3});
array arr2 = ({4, 5, 6});
array arr3 = arr1 + arr2;
}</
=={{header|PL/I}}==
Trivial example requires no computational statement.
Note that the arrays are not in static storage:
<syntaxhighlight lang="pl/i">
declare x(12) fixed;
declare b(5) fixed defined x;
declare c(7) fixed defined x(1sub+5);
</syntaxhighlight>
A more general example using dynamic bounds.
Again, no computation statement is required.
<syntaxhighlight lang="text">
declare x(m+n) fixed;
declare b(m) fixed defined x;
declare c(n) fixed defined x(1sub+hbound(b,1));
</syntaxhighlight>
An alternative, that can be used to advantage for matrices
Line 3,270 ⟶ 3,565:
are used in the declarations, the bounds can be dynamic.
Matrix B is extended by placing matrix C on its diagonal:
<syntaxhighlight lang="text">
declare a(5,6) fixed;
declare b(3,4) fixed defined a(1sub, 2sub);
Line 3,285 ⟶ 3,580:
put skip list ('Composite matrix:');
put skip edit (a) ( skip, (hbound(a,2)) f(5,0) );
</syntaxhighlight>
{{out}}
<syntaxhighlight lang="text">
Please type elements for a 3 x 4 matrix:
Line 3,302 ⟶ 3,597:
0 0 0 0 15 16
</syntaxhighlight>
=={{header|Plain English}}==
Plain English has these functions for concatenating two sets of things:
<syntaxhighlight lang="text">
To append some things to some other things:
Put the things' first into a thing.
If the thing is nil, exit.
Remove the thing from the things.
Append the thing to the other things.
Repeat.
To prepend some things to some other things:
Get a thing from the things (backwards).
If the thing is nil, exit.
Remove the thing from the things.
Prepend the thing to the other things.
Repeat.
</syntaxhighlight>
=={{header|Pony}}==
<
actor Main
new create(env:Env)=>
Line 3,320 ⟶ 3,633:
env.out.print(i.string())
end
</syntaxhighlight>
=={{header|PostScript}}==
{{libheader|initlib}}
<
[1 2 3 4] [5 6 7 8] concat
</syntaxhighlight>
=={{header|PowerShell}}==
<
$b = 4,5,6
$c = $a + $b
Write-Host $c</
=={{header|Processing}}==
<
int[] a = {1, 2, 3}, b = {4, 5, 6};
int[] c = concat(a, b);
</syntaxhighlight>
=={{header|Prolog}}==
<
?- append([1,2,3],[4,5,6],R).
R = [1, 2, 3, 4, 5, 6].
</syntaxhighlight>
=={{header|PureBasic}}==
<
Protected i
Print(msg + " [")
Line 3,395 ⟶ 3,708:
Input()
CloseConsole()
EndIf</
{{out}}
<pre>a: [5, 2, -4, -1, -2]
Line 3,404 ⟶ 3,717:
The <code>[http://docs.python.org/library/stdtypes.html#sequence-types-str-unicode-list-tuple-buffer-xrange +]</code> operator concatenates two lists and returns a new list.
The <code>[http://docs.python.org/library/stdtypes.html#mutable-sequence-types list.extend]</code> method appends elements of another list to the receiver.
<
arr2 = [4, 5, 6]
arr3 = [7, 8, 9]
Line 3,410 ⟶ 3,723:
assert arr4 == [1, 2, 3, 4, 5, 6]
arr4.extend(arr3)
assert arr4 == [1, 2, 3, 4, 5, 6, 7, 8, 9]</
Note: list.extend is normally accomplished using the += operator like this:
<
arr6 = [7, 8, 9]
arr6 += arr5
assert arr6 == [7, 8, 9, 4, 5, 6]</
=={{header|Q}}==
<
list2:4 5 6
list1,list2</
Line 3,427 ⟶ 3,740:
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
<
ta = UBOUND(a)
tb = UBOUND(b)
Line 3,455 ⟶ 3,768:
IF i < nt THEN PRINT ", ";
NEXT i
</syntaxhighlight>
=={{header|QB64}}==
<syntaxhighlight lang="qb64">
Dim As Integer First, Second
Line 3,505 ⟶ 3,818:
End Sub
</syntaxhighlight>
=={{header|Quackery}}==
Line 3,532 ⟶ 3,845:
=={{header|R}}==
<syntaxhighlight lang="r">
a1 <- c(1, 2, 3)
a2 <- c(3, 4, 5)
a3 <- c(a1, a2)
</syntaxhighlight>
=={{header|Racket}}==
<
(vector-append #(1 2 3 4) #(5 6 7) #(8 9 10))
</syntaxhighlight>
{{out}}
<pre>
Line 3,550 ⟶ 3,863:
(formerly Perl 6)
{{works with|Rakudo|2018.06}}
<syntaxhighlight lang="raku"
my @array2 = 4, 5, 6;
Line 3,567 ⟶ 3,880:
# of the second array to the first, use the .append method.
say @array1.append: @array2;</
{{Out}}
<pre>[1 2 3 4 5 6]
Line 3,574 ⟶ 3,887:
=={{header|RapidQ}}==
<syntaxhighlight lang="vb">
DEFINT A(1 to 4) = {1, 2, 3, 4}
DEFINT B(1 to 4) = {10, 20, 30, 40}
Line 3,581 ⟶ 3,894:
Redim A(1 to 8) as integer
MEMCPY(varptr(A(5)), varptr(B(1)), Sizeof(integer)*4)
</syntaxhighlight>
=={{header|Rapira}}==
<syntaxhighlight lang="rapira">arr1 := <* 1, 2, 3 *>
arr2 := <* 4, 5, 6 *>
output: arr1 + arr2</syntaxhighlight>
=={{header|REBOL}}==
<syntaxhighlight lang="rebol">
a1: [1 2 3]
a2: [4 5 6]
Line 3,592 ⟶ 3,910:
append/only a1 a3 ; -> [1 2 3 4 5 6 [7 8 9]]
</syntaxhighlight>
=={{header|Red}}==
<
>> arr2: ["d" "e" "f"]
>> append arr1 arr2
Line 3,606 ⟶ 3,924:
== [22 33 44]
>> append/only arr1 arr4
== [1 2 3 "a" "b" "c" "d" "e" "f" [22 33 44]]</
=={{header|ReScript}}==
<
=={{header|Retro}}==
<
=={{header|REXX}}==
Line 3,625 ⟶ 3,943:
Consider:
<
a.2 = 22.7
a.7 = -12</
where now we have three "elements", and they are disjointed (another word for ''sparse'').
<br>There are ways to handle this in REXX however.
Line 3,633 ⟶ 3,951:
<br>assuming that the stemmed variables are sequential.
<br><br>'''example:'''
<
fact.1= 1
fact.2= 2
Line 3,641 ⟶ 3,959:
fact.6= 720
fact.7= 5040
fact.8=40320</
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.*/
Line 3,664 ⟶ 3,982:
say 'c.'m"="c.m /*show a "merged" C array nums.*/
end /*m*/
/*stick a fork in it, we're done.*/</
{{out}}
<pre>
Line 3,695 ⟶ 4,013:
=={{header|Ring}}==
<
arr1 = [1, 2, 3]
arr2 = [4, 5, 6]
Line 3,704 ⟶ 4,022:
arr5 = arr4 + arr3
see arr5
</syntaxhighlight>
=={{header|RLaB}}==
Line 3,710 ⟶ 4,028:
In RLaB the matrices can be appended (column-wise) or stacked (row-wise).
Consider few examples:
<syntaxhighlight lang="rlab">
>> x = [1, 2, 3]
>> y = [4, 5, 6]
Line 3,724 ⟶ 4,042:
4 5 6
>>
</syntaxhighlight>
=={{header|RPL}}==
In RPL, what is called arrays are actually vectors. Sets of numbers can be stored either in such data structures or in lists, depending on the planned use. Vectors are great for arithmetics, but lists are more versatile.
{{works with|Halcyon Calc|4.2.7}}
=== Vector concatenation===
≪ SWAP ARRY→ LIST→ DROP → n
≪ n 1 + ROLL ARRY→ LIST→ DROP
n + 1 →LIST →ARRY
≫ ≫ 'CONCAT' STO
[1 2 3] [4 5] CONCAT
{{out}}
<pre>
1: [1 2 3 4 5]
</pre>
A shorter version, without any local variable:
≪ SWAP ARRY→ 1 GET →LIST
SWAP ARRY→ 1 GET →LIST
+ LIST→ { } + →ARRY
≫ 'CONCAT' STO
=== List concatenation===
No need for a program to do that:
{1 2 3} {4 5} +
{{out}}
<pre>
1: {1 2 3 4 5}
</pre>
=={{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]
arr4.concat(arr3) # => [1, 2, 3, 4, 5, 6, 7, 8, 9]</
Or use flatten(1):
<
# concat multiple arrays:
[arr1,arr2,arr3].flatten(1)
# ignore nil:
[arr1,arr2,arr3].compact.flatten(1)
</syntaxhighlight>
=={{header|Rust}}==
<
let a_vec = vec![1, 2, 3, 4, 5];
let b_vec = vec![6; 5];
Line 3,758 ⟶ 4,105:
concat
}
</syntaxhighlight>
Or, with iterators:
<
x.iter().chain(y).cloned().collect()
}
</syntaxhighlight>
=={{header|S-lang}}==
<
variable b = [4, 5, 6], c;</
a+b is perfectly valid in S-Lang, but instead of the problem's desired effect,
Line 3,775 ⟶ 4,122:
But because arrays automatically 'flatten' when defined, concatenation is as
simple as:
<
Use of lists is more traditional; lists don't 'flatten', so we use either
list_concat() to create a new concatenated array:
<
b = {4, 5, 6};
c = list_concat(a, b);</
or list_join():
<syntaxhighlight lang
which adds the elements of b onto a.
=={{header|SASL}}==
In SASL, the concat operator ++ is built-in
<
=={{header|Scala}}==
<
val arr2 = Array( 4, 5, 6 )
val arr3 = Array( 7, 8, 9 )
Line 3,798 ⟶ 4,145:
//or:
Array concat ( arr1, arr2, arr3 )
// res0: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)</
=={{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))
; #(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].''
Line 3,812 ⟶ 4,159:
{{works with|Gauche Scheme}}
<syntaxhighlight lang="scheme">
(use gauche.array)
Line 3,838 ⟶ 4,185:
(print-matrix (array-concatenate a b))
(print-matrix (array-concatenate a b 1))
</syntaxhighlight>
{{out}}
Line 3,855 ⟶ 4,202:
=={{header|Seed7}}==
<
var array integer: a is [] (1, 2, 3, 4);
Line 3,870 ⟶ 4,217:
end for;
writeln;
end func;</
{{out}}
Line 3,876 ⟶ 4,223:
=={{header|SenseTalk}}==
<
put (4, 5, 6) into list2
put list1 &&& list2 into list3
put list3</
=={{header|SETL}}==
<
B := [3, 4, 5];
print(A + B); -- [1 2 3 3 4 5]</
=={{header|Sidef}}==
<
var arr2 = [4, 5, 6];
var arr3 = (arr1 + arr2); # => [1, 2, 3, 4, 5, 6]</
=={{header|Simula}}==
<
CLASS REAL_ARRAY(N); INTEGER N;
Line 3,986 ⟶ 4,333:
X.CONCAT(NEW REAL_ARRAY(4)
.linearFill(-1, -3)).out(SYSOUT);
END.</
{{out}}
<pre> 3.00 10.00 17.00 0.00 5.00 10.00 15.00
Line 3,995 ⟶ 4,342:
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}
</syntaxhighlight>
=={{header|Slope}}==
<syntaxhighlight lang="slope">(list-join [1 2 3] [4 5 6])</syntaxhighlight>
=={{header|SmallBASIC}}==
<syntaxhighlight lang="SmallBASIC">
A = [1,2,3]
B = [4,5,6]
for i in B do A << i
print A
</syntaxhighlight>
=={{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.
c displayNl.</
=={{header|SNOBOL4}}==
Line 4,014 ⟶ 4,375:
{{works with|CSnobol}}
<
define('cat(a1,a2)i,j') :(cat_end)
cat cat = array(prototype(a1) + prototype(a2))
Line 4,033 ⟶ 4,394:
output = str2
output = str3
end</
{{out}}
Line 4,039 ⟶ 4,400:
6 7 8 9 10
1 2 3 4 5 6 7 8 9 10</pre>
=={{header|SparForte}}==
As a structured script.
<syntaxhighlight lang="ada">#!/usr/local/bin/spar
pragma annotate( summary, "arraycat" )
@( description, "Show how to concatenate two arrays in your language." )
@( category, "tutorials" )
@( author, "Ken O. Burtch" )
@( see_also, "http://rosettacode.org/wiki/Array_concatenation" );
pragma license( unrestricted );
pragma software_model( nonstandard );
pragma restriction( no_external_commands );
procedure arraycat is
type arrayOf3 is array(1..3) of integer;
a1 : constant arrayOf3 := (1, 2, 3);
a2 : constant arrayOf3 := (4, 5, 6);
type arrayOf6 is array(1..6) of integer;
a3 : arrayOf6;
p : natural := arrays.first(a3);
begin
-- In SparForte, & only works on strings and there's no indefinite ranges
-- or array slicing. We have to do this the hard way, one element at a
-- time.
for i in arrays.first(a1)..arrays.last(a1) loop
a3(p) := a1(i);
p := @+1;
end loop;
for i in arrays.first(a2)..arrays.last(a2) loop
a3(p) := a2(i);
p := @+1;
end loop;
-- show the array
for i in arrays.first(a3)..arrays.last(a3) loop
put( a3(i) );
end loop;
new_line;
end arraycat;</syntaxhighlight>
=={{header|Standard ML}}==
<syntaxhighlight 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] *)
</syntaxhighlight>
=={{header|Stata}}==
===Macro language===
<
. matrix list a
Line 4,086 ⟶ 4,486:
r1 1 0 0
r2 0 1 0
r3 0 0 1</
=== Mata ===
<
: a=2,9,4\7,5,3\6,1,8
Line 4,112 ⟶ 4,512:
+-------------+
: end</
=={{header|Swift}}==
<
let array2 = [4,5,6]
let array3 = array1 + array2</
=={{header|Tailspin}}==
<
def a: [1, 2, 3];
def b: [4, 5, 6];
[$a..., $b...] -> !OUT::write
</syntaxhighlight>
{{out}}
<pre>
Line 4,131 ⟶ 4,531:
=={{header|Tcl}}==
<
set b {4 5 6}
set ab [concat $a $b]; # 1 2 3 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.
Line 4,166 ⟶ 4,566:
=={{header|Trith}}==
<
=={{header|UNIX Shell}}==
Line 4,174 ⟶ 4,574:
{{works with|bash}}
<
array2=( 6 7 8 9 10 )
botharrays=( ${array1[@]} ${array2[@]} )</
Whitespace-delimited strings work in much the same way:
Line 4,182 ⟶ 4,582:
{{works with|bash}}
<
array2='6 7 8 9 10'
Line 4,189 ⟶ 4,589:
# Concatenated to a string ...
botharrays_s="$array1 $array2"</
=={{header|Ursa}}==
<
# a contains the numbers 1-10, b contains 11-20
decl int<> a b
Line 4,207 ⟶ 4,607:
# output a to the console
out a endl console</
=={{header|Vala}}==
<
int[] c = new int[a.length + b.length];
Memory.copy(c, a, a.length * sizeof(int));
Line 4,223 ⟶ 4,623:
stdout.printf("%d\n",i);
}
}</
=={{header|VBA}}==
<syntaxhighlight lang="vb">
Option Explicit
Line 4,253 ⟶ 4,653:
Concat_Array = TmpA1
End Function
</syntaxhighlight>
{{out}}
<pre>With Array 1 : 1, 2, 3, 4, 5, 24/11/2017, azerty
Line 4,261 ⟶ 4,661:
=={{header|VBScript}}==
<
ReDim ret(UBound(arr1) + UBound(arr2) + 1)
For i = 0 To UBound(arr1)
Line 4,278 ⟶ 4,678:
WScript.Echo "arr2 = array(" & Join(arr2,", ") & ")"
arr3 = ArrayConcat(arr1, arr2)
WScript.Echo "arr1 + arr2 = array(" & Join(arr3,", ") & ")"</
{{out}}
Line 4,288 ⟶ 4,688:
=={{header|Visual Basic .NET}}==
<
Dim iArray1() As Integer = {1, 2, 3}
Dim iArray2() As Integer = {4, 5, 6}
Line 4,294 ⟶ 4,694:
iArray3 = iArray1.Concat(iArray2).ToArray
</syntaxhighlight>
=={{header|V (Vlang)}}==
V (Vlang) uses a '''<<''' operator for array concatenation. Destination array needs to be mutable.
<
// Tectonics: v run array-concatenation.v
module main
Line 4,310 ⟶ 4,710:
arr1 << arr2
println(arr1)
}</
{{out}}<pre>$ v run array-concatenation.v
Line 4,319 ⟶ 4,719:
Wart doesn't have arrays yet, just lists.
<
b <- '(4 5 6)
a+b
# => (1 2 3 4 5 6)</
=={{header|Wren}}==
<
var arr2 = [4,5,6]
System.print(arr1 + arr2)</
{{Out}}
<pre>[1, 2, 3, 4, 5, 6]</pre>
=={{header|XPL0}}==
{{trans|C}}
A way to concatenate two XPL0 arrays when you know their size (and usually it is so).
Works on Raspberry Pi. MAlloc works differently in other versions.
<syntaxhighlight lang "XPL0">func Array_concat(A, AN, B, BN, S);
int A, AN, B, BN, S;
int P;
[
P:= MAlloc(S * (AN + BN));
CopyMem(P, A, AN*S);
CopyMem(P + AN*S, B, BN*S);
return P;
];
\ testing
int A, B, C, I, SizeOf;
[
A:= [ 1, 2, 3, 4, 5 ];
B:= [ 6, 7, 8, 9, 0 ];
SizeOf:= @B - @A;
C:= Array_concat(A, 5, B, 5, SizeOf);
for I:= 0 to 10-1 do
[IntOut(0, C(I)); ChOut(0, ^ )];
Release(C);
]</syntaxhighlight>
{{out}}
<pre>
1 2 3 4 5 6 7 8 9 0 </pre>
=={{header|Yabasic}}==
<
local ta, tb, nt, i
Line 4,367 ⟶ 4,800:
if i < nt print ", ";
next i
print</
=={{header|Yacas}}==
<
Out> {1, 2, 3, 4, 5, 6}</
=={{header|Yorick}}==
<
b = [4,5,6];
ab = grow(a, b);</
=={{header|Z80 Assembly}}==
Line 4,383 ⟶ 4,816:
Credit to Keith of [https://www.chibiakumas.com ChibiAkumas] for creating it.
<
ld hl,TestArray1 ; pointer to first array
Line 4,413 ⟶ 4,846:
; in the reverse order.
TestArray1:
byte $aa,$bb,$cc,$dd,$ee,$ff</
{{out}}
Line 4,419 ⟶ 4,852:
801D:
AA BB CC DD EE FF 23 45 67 89
</pre>
=={{header|Zig}}==
There are no hidden memory allocations in Zig.
<syntaxhighlight lang="zig">
const std = @import("std");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
var array1 = [_]u32{ 1, 2, 3, 4, 5 };
var array2 = [_]u32{ 6, 7, 8, 9, 10, 11, 12 };
const slice3 = try std.mem.concat(allocator, u32, &[_][]const u32{ &array1, &array2 });
defer allocator.free(slice3);
// Same result, alternative syntax
const slice4 = try std.mem.concat(allocator, u32, &[_][]const u32{ array1[0..], array2[0..] });
defer allocator.free(slice4);
std.debug.print(
"Array 1: {any}\nArray 2: {any}\nSlice 3: {any}\nSlice 4: {any}\n",
.{ array1, array2, slice3, slice4 },
);
}
</syntaxhighlight>
{{out}}
<pre>
Array 1: { 1, 2, 3, 4, 5 }
Array 2: { 6, 7, 8, 9, 10, 11, 12 }
Slice 3: { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }
Slice 4: { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }
</pre>
=={{header|zkl}}==
Lists (both mutable and read only), no built in support for numeric vectors/arrays/matrices
<
T(1,2).extend(4,5,6) //-->L(1,2,4,5,6)</
=={{header|zonnon}}==
<syntaxhighlight lang="text">
module Main;
import
Line 4,502 ⟶ 4,970:
WriteAry(Concat2(x,y));
end Main.
</syntaxhighlight>
{{out}}
<pre>
Line 4,511 ⟶ 4,979:
=={{header|Zsh}}==
Concatenating arrays.
<
b=(a b c)
c=($a $b)</
Pushing a single element into an array.
<
Pushing another array into an array.
<
=={{header|ZX Spectrum Basic}}==
{{trans|Liberty BASIC}}
<
20 LET y=20
30 DIM a(x)
Line 4,536 ⟶ 5,004:
130 PRINT c(i);", ";
140 NEXT i
</syntaxhighlight>
|