Array concatenation: Difference between revisions

=={{header|11l}}==

V arr2 = [4, 5, 6]

{{out}}

<pre>

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

DC.W 1,2,3,4,5

Array2:

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

[1,2,3] [4,5,6] a:+ .

{{out}}

<pre>

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program concAreaString.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

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

report z_array_concatenation.

write <line>.

endloop.

{{out}}

=={{header|ACL2}}==

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

=={{header|Action!}}==

BYTE i

Test(a2,a1,6,4)

Test(a3,a2,5,4)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Array_concatenation.png Screenshot from Atari 8-bit computer]

=={{header|ActionScript}}==

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

=={{header|Ada}}==

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

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

=={{header|Aime}}==

{

list o;

0;

{{Out}}

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

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

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

MODE ARGLIST = FLEX[0]ARGTYPE;

VOID(a +=: b);

<pre>

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

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

for cPos := 1 until 8 do writeon( i_w := 1, s_w := 1, c( cPos ) )

{{out}}

<pre>

=={{header|Amazing Hopper}}==

#include <hbasic.h>

Begin

Concat (a1, a2) and Print ( a2, Newl )

End

{{out}}

<pre>

=={{header|AntLang}}==

b: <"Hello"; 42>

=={{header|Apex}}==

List<String> listB = new List<String> { 'banana' };

listA.addAll(listB);

=={{header|APL}}==

1 2 3 , 4 5 6

1 2 3 4 5 6

=={{header|AppleScript}}==

set listA to {1, 2, 3}

set listB to {4, 5, 6}

return listA & listB

{{out}}

{{trans|JavaScript}}

concat([["alpha", "beta", "gamma"], ¬

end concat

{{Out}}

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program concAreaString.s */

.Ls_magic_number_10: .word 0x66666667

=={{header|Arturo}}==

arr2: ["four" "five" "six"]

{{out}}

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

free lst (* The list is linear and must be freed. *)

end

{{out}}

=== True Arrays ===

{{works with|AutoHotkey_L}}

List2 := [4, 5, 6]

cList := Arr_concatenate(List1, List2)

res .= ", " value

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

=== Legacy versions ===

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

List2 = 4,5,6

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

Return, List

Message box shows:

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

_ArrayConcatenate($avArray, $avArray2)

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

Return $iUBoundTarget + $iUBoundSource

EndFunc ;==>_ArrayConcatenate

=={{header|Avail}}==

=={{header|AWK}}==

BEGIN {

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

c[++nc]=b[i]

}

=={{header|Babel}}==

{{Out}}

=={{header|bash}}==

y=(5 6)

sum=( "${x[@]}" "${y[@]}" )

3 4

5

=={{header|BASIC}}==

==={{header|Applesoft BASIC}}===

20 DIM A(X - 1),B(Y - 1),C(X + Y - 1)

30 FOR I = 1 TO X:A(I - 1) = I: 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

==={{header|BaCon}}===

DECLARE b[] = { 6, 7, 8, 9, 10 }

c[x] = a[x]

c[x+5] = b[x]

==={{header|BBC BASIC}}===

{{works with|BBC BASIC for Windows}}

a() = 1, 2, 3, 4

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

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

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

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

150 FOR I=1 TO X+Y

160 : PRINT C(I);

=={{header|BASIC256}}==

global c

return nt

{{out}}

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

=={{header|BQN}}==

=={{header|Bracmat}}==

=={{header|Burlesque}}==

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

{1 2 3 4 5 6}

=={{header|C}}==

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

#include <stdio.h>

#include <string.h>

free(c);

return EXIT_SUCCCESS;

=={{header|C sharp|C#}}==

namespace RosettaCode

}

}

Alternatively, using LINQ extension methods:

{{works with|C sharp|C#|3}}

class Program

int[] c = a.Concat(b).ToArray();

}

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

#include <iostream>

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

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

{{works with|C++11}}

Similar to above but using initialization schematics.

#include <iostream>

std::cout << std::endl;

return 0;

This is another solution with function level templates and pointers.

using namespace std;

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

program-id. array-concat.

.

{{out}}

<pre>prompt$ cobc -xjd array-concatenation.cob

=={{header|CoffeeScript}}==

# like in JavaScript

a = [1, 2, 3]

b = [4, 5, 6]

c = a.concat b

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

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

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

(write arr5)

(terpri)

Output:

<pre>

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

BlackBox Component Builder

MODULE ArrayConcat;

IMPORT StdLog;

END ArrayConcat.

Execute: ^Q ArrayConcat.Do <br/>

{{out}}

=={{header|Crystal}}==

arr2 = ["foo", "bar", "baz"]

=={{header|D}}==

void main() {

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

{{out}}

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

=={{header|Delphi}}==

2022/07/13

// This example works on stuff as old as Delphi 5 (maybe older)

// Modern Delphi / Object Pascal has both

Writeln( #13#10, Join(names, #13#10 ) );

end.

Output:

Korra Asami Bolin Mako

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

Finalize(r1); //IMPORTANT!

ShowMessage(IntToStr(High(r1)));

=={{header|Diego}}==

add_ary(a)_values(1,2,3);

me_msg()_calc([a]+[b]); // alternative

=={{header|Dyalect}}==

var ys = [4,5,6]

var alls = Array.Concat(xs, ys)

{{out}}

=={{header|E}}==

=={{header|EasyLang}}==

i += 1

.

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

=={{header|ECL}}==

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

=={{header|Efene}}==

using the ++ operator and the lists.append function

@public

run = fn () {

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

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

=={{header|EGL}}==

{{works with|EDT}}

program ArrayConcatenation

function main()

end

end

=={{header|Ela}}==

ys = [4,5,6]

{{out}}<pre>[1,2,3,4,5,6]</pre>

=={{header|Elena}}==

ELENA 5.0 :

public program()

"(",a.asEnumerable(),") + (",b.asEnumerable(),

") = (",(a + b).asEnumerable(),")").readChar();

{{out}}

<pre>

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

=={{header|Elm}}==

import Html.App exposing (beginnerProgram)

import Array exposing (Array, append, initialize)

}

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

The ''vconcat'' function returns a new array containing all the elements of it's arguments.

=={{header|Erlang}}==

On the shell,

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

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

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

3>

=={{header|ERRE}}==

END PROGRAM

=={{header|Euphoria}}==

s1 = {1,2,3}

s2 = {4,5,6}

s3 = s1 & s2

{{out}}

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

Array concatenation.

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

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

let y = [4; 5; 6]

let z1 = x @ y

=={{header|Factor}}==

'''Example''':

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

=={{header|Fantom}}==

In fansh:

> a := [1,2,3]

> b := [4,5,6]

> a

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

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

=={{header|FBSL}}==

Array concatenation:

DIM aint[] ={1, 2, 3}, astr[] ={"one", "two", "three"}, asng[] ={!1, !2, !3}

NEXT

{{out}}

<pre>1 2 3 one two three 1.000000 2.000000 3.000000

=={{header|Forth}}==

2dup + >r swap move r> ;

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

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

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

=={{header|Fortran}}==

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

implicit none

d = [a, b] ! (/a, b/)

print*, d

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

Both options do not require any libraries.

=={{header|FreeBASIC}}==

' FB 1.05.0 Win64

Print "Press any key to quit the program"

Sleep

{{out}}

=={{header|Frink}}==

a = [1,2]

b = [3,4]

a.pushAll[b]

=={{header|FunL}}==

arr2 = array( [4, 5, 6] )

arr3 = array( [7, 8, 9] )

{{out}}

Array concatenation is done with the built-in function <code>concat</code>, which can take any number of arguments:

concat as bs cd

=={{header|FutureBasic}}==

CFArrayRef array = @[@"Alpha",@"Bravo",@"Charlie"]

print array

fn DoIt

Output:

<pre>

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

Print sString1.Join(" ")

Output:

<pre>

=={{header|GAP}}==

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

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

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

a;

=={{header|Genie}}==

/*

Array concatenation, in Genie

stdout.printf("y: "); int_show_array(y)

stdout.printf("z: "); int_show_array(z)

{{out}}

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

} \

}

The macro can be used like this:

array_concat(float,float[](1.,2.,3.),float[](4.,5.,6.),returned);

int i = returned.length();

=={{header|Go}}==

import "fmt"

fmt.Println(n)

{{out}}

<pre>

</pre>

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

import (

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

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

{{out}}

<pre>

=={{header|Gosu}}==

var listA = { 1, 2, 3 }

var listB = { 4, 5, 6 }

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

=={{header|Groovy}}==

Solution:

Test:

{{out}}

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

This operator could be defined from the scratch using explicit recursion:

[] ++ x = x

(h:t) ++ y = h : (t ++ y)

or folding

x ++ y = foldr (:) y x

=={{header|HicEst}}==

c = a

DO i = 1, LEN(b)

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

=={{header|Hy}}==

=> a

[1, 2, 3]

=> (+ [1 2] [3 4] [5 6]) ; can accept multiple arguments

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

write()

end

=={{header|IDL}}==

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

> a = [1,2,3]

> b = [4,5,6]

> print,b

4 5 6

Then they can be concatenated "at the ends":

> help,[a,b]

<Expression> INT = Array[6]

> print,[a,b]

1 2 3 4 5 6

or "at the sides":

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

<Expression> INT = Array[3, 2]

1 2 3

4 5 6

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

> b = transpose(b)

> help,b

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

Execution halted at: $MAIN$

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

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

let B be {4, 5, 6};

=={{header|Ioke}}==

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

=={{header|J}}==

'''Example''':

array2 =: 4 5 6

array1 , array2

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

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

aaa

bbb

3 6

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

=={{header|Java}}==

Object[] res = new Object[arr1.length + arr2.length];

return res;

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

See, for a function with an analogous type signature, '''concat''' in the Haskell Prelude.

'use strict';

);

{{Out}}

To concatenate the component arrays of an array, A, the <tt>add</tt> filter can be used: <tt>A|add</tt>

[range(1;3), 3, null] # => [1,2,3,null]

=={{header|Julia}}==

b = [4,5,6]

ab = [a;b]

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

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

=={{header|K}}==

a: 1 2 3

b: 4 5 6

a,b

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

ab:3 3#"abcdefghi"

("abc"

("abc036"

"def147"

=={{header|Klingphix}}==

( 1.0 "Hello" 3 2 / 4 2.1 power ) ( 5 6 7 8 ) chain print

{{out}}

<pre>(1, "Hello", 1.5, 18.379173679952562, 5, 6, 7, 8)</pre>

=={{header|Klong}}==

[1 2 3],[4 5 6] :" join "

[1 2 3 4 5 6]

[1 2],:/[[3 4] [5 6] [7 8]] :" join each-right "

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

=={{header|Kotlin}}==

There is no operator or standard library function for concatenating <code>Array</code> types. One option is to convert to <code>Collection</code>s, concatenate, and convert back:

val a: Array<Int> = arrayOf(1, 2, 3) // initialise a

val b: Array<Int> = arrayOf(4, 5, 6) // initialise b

val c: Array<Int> = (a.toList() + b.toList()).toTypedArray()

println(c)

Alternatively, we can write our own concatenation function:

return Array(a.size + b.size, { if (it in a.indices) a[it] else b[it - a.size] })

When working directly with <code>Collection</code>s, we can simply use the <code>+</code> operator:

val a: Collection<Int> = listOf(1, 2, 3) // initialise a

val b: Collection<Int> = listOf(4, 5, 6) // initialise b

val c: Collection<Int> = a + b

println(c)

=={{header|LabVIEW}}==

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

=={{header|Lang5}}==

=={{header|langur}}==

val .b = [7, 8, 9]

val .c = .a ~ .b

{{out}}

=={{header|Lasso}}==

local(arr1 = array(1, 2, 3))

local(arr2 = array(4, 5, 6))

arr2 = array(4, 5, 6)

arr3 = array(4, 5, 6)

=={{header|LFE}}==

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

(1 2 3 4 5 6)

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

(1 2 3 4 5 6)

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

y=20

dim array1(x)

for i = 1 to x + y

print array3(i)

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

##

print $c

{{out}}

=={{header|Limbo}}==