Add all the A tasks

Task/Array-concatenation/0DESCRIPTION

@@ -0,0 +1 @@
+Show how to concatenate two arrays in your language. If this is as simple as <code><var>array1</var> + <var>array2</var></code>, so be it.

Task/Array-concatenation/1META.yaml

@@ -0,0 +1,2 @@
+---
+note: Data Structures

Task/Array-concatenation/ACL2/array-concatenation.acl2

@@ -0,0 +1 @@
+(append xs ys)

Task/Array-concatenation/ALGOL-68/array-concatenation.alg

@@ -0,0 +1,30 @@
+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))

Task/Array-concatenation/APL/array-concatenation.apl

@@ -0,0 +1,2 @@
+    1 2 3 , 4 5 6
+1 2 3 4 5 6

Task/Array-concatenation/ActionScript/array-concatenation.as

@@ -0,0 +1,3 @@
+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]

Task/Array-concatenation/Ada/array-concatenation.ada

@@ -0,0 +1,3 @@
+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)

Task/Array-concatenation/AutoHotkey/array-concatenation-1.ahk

@@ -0,0 +1,18 @@
+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) "]"
+}

Task/Array-concatenation/AutoHotkey/array-concatenation-2.ahk

@@ -0,0 +1,37 @@
+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
+}

Task/Array-concatenation/AutoIt/array-concatenation.autoit

@@ -0,0 +1,18 @@
+_ArrayConcatenate($avArray, $avArray2)
+Func _ArrayConcatenate(ByRef $avArrayTarget, Const ByRef $avArraySource, $iStart = 0)
+	If Not IsArray($avArrayTarget) Then Return SetError(1, 0, 0)
+	If Not IsArray($avArraySource) Then Return SetError(2, 0, 0)
+	If UBound($avArrayTarget, 0) <> 1 Then
+		If UBound($avArraySource, 0) <> 1 Then Return SetError(5, 0, 0)
+		Return SetError(3, 0, 0)
+	EndIf
+	If UBound($avArraySource, 0) <> 1 Then Return SetError(4, 0, 0)
+
+	Local $iUBoundTarget = UBound($avArrayTarget) - $iStart, $iUBoundSource = UBound($avArraySource)
+	ReDim $avArrayTarget[$iUBoundTarget + $iUBoundSource]
+	For $i = $iStart To $iUBoundSource - 1
+		$avArrayTarget[$iUBoundTarget + $i] = $avArraySource[$i]
+	Next
+
+	Return $iUBoundTarget + $iUBoundSource
+EndFunc   ;==>_ArrayConcatenate

Task/Array-concatenation/Babel/array-concatenation.pb

@@ -0,0 +1 @@
+main : { [1 2 3] [4 5 6] cat }

Task/Array-concatenation/C/array-concatenation.c

@@ -0,0 +1,32 @@
+#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;
+}

Task/Array-concatenation/Clojure/array-concatenation.clj

@@ -0,0 +1 @@
+(concat [1 2 3] [4 5 6])

Task/Array-concatenation/CoffeeScript/array-concatenation.coffee

@@ -0,0 +1,4 @@
+# like in JavaScript
+a = [1, 2, 3]
+b = [4, 5, 6]
+c = a.concat b

Task/Array-concatenation/Erlang/array-concatenation.erl

@@ -0,0 +1,5 @@
+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>

Task/Array-concatenation/Forth/array-concatenation.fth

@@ -0,0 +1,13 @@
+: $!+   ( 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 -                           ........

Task/Array-concatenation/Fortran/array-concatenation.f

@@ -0,0 +1,14 @@
+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

Task/Array-concatenation/Go/array-concatenation-1.go

@@ -0,0 +1,35 @@
+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} // these are technically slices, not arrays
+    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...) // append will allocate as needed
+    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 have to do a little extra work.  The best
+    // technique is almost always to create slices on the arrays and then
+    // use the copy function.
+    l := [...]int{1, 2, 3}
+    m := [...]int{7, 12, 60} // arrays have constant size set at compile time
+    var n [len(l) + len(m)]int
+    copy(n[:], l[:]) // [:] creates a slice that references the entire array
+    copy(n[len(l):], m[:])
+    fmt.Println(n)
+
+}

Task/Array-concatenation/Go/array-concatenation-2.go

@@ -0,0 +1,57 @@
+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)
+}

Task/Array-concatenation/Haskell/array-concatenation.hs

@@ -0,0 +1 @@
+(++) :: [a] -> [a] -> [a]

Task/Array-concatenation/Java/array-concatenation-1.java

@@ -0,0 +1,9 @@
+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;
+}

Task/Array-concatenation/Java/array-concatenation-2.java

@@ -0,0 +1,4 @@
+Collection list1, list2, list1And2;
+//...list1 and list2 are instantiated...
+list1And2 = new ArrayList(list1); //or any other Collection you want
+list1And2.addAll(list2);

Task/Array-concatenation/JavaScript/array-concatenation.js

@@ -0,0 +1,4 @@
+var
+ a = [1,2,3],
+ b = [4,5,6],
+ c = a.concat(b);  // [1,2,3,4,5,6]

Task/Array-concatenation/Lua/array-concatenation.lua

@@ -0,0 +1,4 @@
+a = {1,2,3}
+b = {4,5,6}
+table.foreach(b,function(i,v)table.insert(a,v)end)
+for i,v in next,a do io.write (v..' ') end

Task/Array-concatenation/PHP/array-concatenation.php

@@ -0,0 +1,3 @@
+$arr1 = array(1, 2, 3);
+$arr2 = array(4, 5, 6);
+$arr3 = array_merge($arr1, $arr2);

Task/Array-concatenation/Perl/array-concatenation-1.pl

@@ -0,0 +1,3 @@
+my @arr1 = (1, 2, 3);
+my @arr2 = (4, 5, 6);
+my @arr3 = (@arr1, @arr2);

Task/Array-concatenation/Perl/array-concatenation-2.pl

@@ -0,0 +1,4 @@
+my @arr1 = (1, 2, 3);
+my @arr2 = (4, 5, 6);
+push @arr1, @arr2;
+print "@arr1\n"; # prints "1 2 3 4 5 6"

Task/Array-concatenation/PicoLisp/array-concatenation-1.l

@@ -0,0 +1,6 @@
+: (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!

Task/Array-concatenation/PicoLisp/array-concatenation-2.l

@@ -0,0 +1,8 @@
+: (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

Task/Array-concatenation/Prolog/array-concatenation.pro

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

Task/Array-concatenation/Python/array-concatenation-1.py

@@ -0,0 +1,7 @@
+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]

Task/Array-concatenation/Python/array-concatenation-2.py

@@ -0,0 +1,4 @@
+arr5 = [4, 5, 6]
+arr6 = [7, 8, 9]
+arr6 += arr5
+assert arr6 == [7, 8, 9, 4, 5, 6]

Task/Array-concatenation/R/array-concatenation.r

@@ -0,0 +1,3 @@
+a1 <- c(1, 2, 3)
+a2 <- c(3, 4, 5)
+a3 <- c(a1, a2)

Task/Array-concatenation/REXX/array-concatenation-1.rexx

@@ -0,0 +1,3 @@
+a.1 =  10
+a.2 =  22.7
+a.7 = -12

Task/Array-concatenation/REXX/array-concatenation-2.rexx

@@ -0,0 +1,9 @@
+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

Task/Array-concatenation/REXX/array-concatenation-3.rexx

@@ -0,0 +1,22 @@
+/*REXX program to demonstrates how to perform array concatenation.*/
+
+p.=                                    /*(below) 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.=                                    /*(below) a list of Fibonacci #s.*/
+f.0=0;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                   /*assign C array with some primes*/
+             end   /*j*/
+n=j-1
+             do k=0  while f.k\=='';   n=n+1
+             c.n=f.k                   /*assign C array with fib numbers*/
+             end   /*k*/
+say 'elements=' n
+say
+             do m=1  for n
+             say 'c.'m"="c.m           /*show a "merged"  C  array nums.*/
+             end   /*m*/
+                                       /*stick a fork in it, we're done.*/

Task/Array-concatenation/Racket/array-concatenation.rkt

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

Task/Array-concatenation/Ruby/array-concatenation.rb

@@ -0,0 +1,5 @@
+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]

Task/Array-concatenation/Scala/array-concatenation.scala

@@ -0,0 +1,8 @@
+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)

Task/Array-concatenation/Scheme/array-concatenation.ss

@@ -0,0 +1,5 @@
+; 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)

Task/Array-concatenation/Smalltalk/array-concatenation.st

@@ -0,0 +1,5 @@
+|a b c|
+a := #(1 2 3 4 5).
+b := #(6 7 8 9 10).
+c := a,b.
+c displayNl.

Task/Array-concatenation/Tcl/array-concatenation.tcl

@@ -0,0 +1,3 @@
+set a {1 2 3}
+set b {4 5 6}
+set ab [concat $a $b];   # 1 2 3 4 5 6