Add tasks for all the new languages

Task/Sorting-algorithms-Merge-sort/Crystal/sorting-algorithms-merge-sort.crystal

@@ -0,0 +1,18 @@
+def merge_sort(a : Array(Int32)) : Array(Int32)
+  return a if a.size <= 1
+  m = a.size / 2
+  lt = merge_sort(a[0 ... m])
+  rt = merge_sort(a[m .. -1])
+  return merge(lt, rt)
+end
+
+def merge(lt : Array(Int32), rt : Array(Int32)) : Array(Int32)
+  result = Array(Int32).new
+  until lt.empty? || rt.empty?
+    result << (lt.first < rt.first ? lt.shift : rt.shift)
+  end
+  return result + lt + rt
+end
+
+a = [7, 6, 5, 9, 8, 4, 3, 1, 2, 0]
+puts merge_sort(a) # => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Task/Sorting-algorithms-Merge-sort/ERRE/sorting-algorithms-merge-sort.erre

@@ -0,0 +1,92 @@
+PROGRAM MERGESORT_DEMO
+
+! Example of merge sort usage.
+
+CONST SIZE%=100,S1%=50
+
+DIM DTA%[SIZE%],FH%[S1%],STACK%[20,2]
+
+
+PROCEDURE MERGE(START%,MIDDLE%,ENDS%)
+
+LOCAL FHSIZE%
+
+  FHSIZE%=MIDDLE%-START%+1
+
+  FOR I%=0 TO FHSIZE%-1 DO
+     FH%[I%]=DTA%[START%+I%]
+  END FOR
+
+  I%=0
+  J%=MIDDLE%+1
+  K%=START%
+
+  REPEAT
+    IF FH%[I%]<=DTA%[J%] THEN
+        DTA%[K%]=FH%[I%]
+        I%=I%+1
+        K%=K%+1
+      ELSE
+        DTA%[K%]=DTA%[J%]
+        J%=J%+1
+        K%=K%+1
+    END IF
+  UNTIL I%=FHSIZE% OR J%>ENDS%
+
+  WHILE I%<FHSIZE% DO
+     DTA%[K%]=FH%[I%]
+     I%=I%+1
+     K%=K%+1
+  END WHILE
+
+END PROCEDURE
+
+PROCEDURE MERGE_SORT(LEV->LEV)
+
+! *****************************************************************
+! This procedure Merge Sorts the chunk of DTA% bounded by
+! Start% & Ends%.
+! *****************************************************************
+
+   LOCAL MIDDLE%
+
+   IF ENDS%=START% THEN LEV=LEV-1 EXIT PROCEDURE END IF
+
+   IF ENDS%-START%=1 THEN
+      IF DTA%[ENDS%]<DTA%[START%] THEN
+         SWAP(DTA%[START%],DTA%[ENDS%])
+      END IF
+      LEV=LEV-1
+      EXIT PROCEDURE
+   END IF
+
+   MIDDLE%=START%+(ENDS%-START%)/2
+
+   STACK%[LEV,0]=START%  STACK%[LEV,1]=ENDS%  STACK%[LEV,2]=MIDDLE%
+   START%=START%  ENDS%=MIDDLE%
+   MERGE_SORT(LEV+1->LEV)
+   START%=STACK%[LEV,0]  ENDS%=STACK%[LEV,1]  MIDDLE%=STACK%[LEV,2]
+
+   STACK%[LEV,0]=START%  STACK%[LEV,1]=ENDS%  STACK%[LEV,2]=MIDDLE%
+   START%=MIDDLE%+1  ENDS%=ENDS%
+   MERGE_SORT(LEV+1->LEV)
+   START%=STACK%[LEV,0]  ENDS%=STACK%[LEV,1]  MIDDLE%=STACK%[LEV,2]
+
+   MERGE(START%,MIDDLE%,ENDS%)
+
+   LEV=LEV-1
+END PROCEDURE
+
+BEGIN
+  FOR I%=1 TO SIZE% DO
+     DTA%[I%]=RND(1)*10000
+  END FOR
+
+  START%=1  ENDS%=SIZE%
+  MERGE_SORT(0->LEV)
+
+  FOR I%=1 TO SIZE% DO
+     WRITE("#####";DTA%[I%];)
+  END FOR
+  PRINT
+END PROGRAM

Task/Sorting-algorithms-Merge-sort/FunL/sorting-algorithms-merge-sort.funl

@@ -0,0 +1,15 @@
+def
+  sort( [] )          =  []
+  sort( [x] )         =  [x]
+  sort( xs )          =
+    val (l, r) = xs.splitAt( xs.length()\2 )
+    merge( sort(l), sort(r) )
+
+  merge( [], xs )     =  xs
+  merge( xs, [] )     =  xs
+  merge( x:xs, y:ys )
+    | x <= y          =  x : merge( xs, y:ys )
+    | otherwise       =  y : merge( x:xs, ys )
+
+println( sort([94, 37, 16, 56, 72, 48, 17, 27, 58, 67]) )
+println( sort(['Sofía', 'Alysha', 'Sophia', 'Maya', 'Emma', 'Olivia', 'Emily']) )

Task/Sorting-algorithms-Merge-sort/Nim/sorting-algorithms-merge-sort.nim

@@ -0,0 +1,52 @@
+proc merge[T](a, b: var openarray[T], left, middle, right) =
+  let
+    leftLen = middle - left
+    rightLen = right - middle
+  var
+    l = 0
+    r = leftLen
+
+  for i in left .. <middle:
+    b[l] = a[i]
+    inc l
+  for i in middle .. < right:
+    b[r] = a[i]
+    inc r
+
+  l = 0
+  r = leftLen
+  var i = left
+
+  while l < leftLen and r < leftLen + rightLen:
+    if b[l] < b[r]:
+      a[i] = b[l]
+      inc l
+    else:
+      a[i] = b[r]
+      inc r
+    inc i
+
+  while l < leftLen:
+    a[i] = b[l]
+    inc l
+    inc i
+  while r < leftLen + rightLen:
+    a[i] = b[r]
+    inc r
+    inc i
+
+proc mergeSort[T](a, b: var openarray[T], left, right) =
+  if right - left <= 1: return
+
+  let middle = (left + right) div 2
+  mergeSort(a, b, left, middle)
+  mergeSort(a, b, middle, right)
+  merge(a, b, left, middle, right)
+
+proc mergeSort[T](a: var openarray[T]) =
+  var b = newSeq[T](a.len)
+  mergeSort(a, b, 0, a.len)
+
+var a = @[4, 65, 2, -31, 0, 99, 2, 83, 782]
+mergeSort a
+echo a

Task/Sorting-algorithms-Merge-sort/Phix/sorting-algorithms-merge-sort.phix

@@ -0,0 +1,34 @@
+function merge(sequence left, sequence right)
+sequence result = {}
+    while length(left)>0 and length(right)>0 do
+        if left[1]<=right[1] then
+            result = append(result, left[1])
+            left = left[2..$]
+        else
+            result = append(result, right[1])
+            right = right[2..$]
+        end if
+    end while
+    return result & left & right
+end function
+
+function mergesort(sequence m)
+sequence left, right
+integer middle
+    if length(m)<=1 then
+        return m
+    end if
+    middle = floor(length(m)/2)
+    left = mergesort(m[1..middle])
+    right = mergesort(m[middle+1..$])
+    if left[$]<=right[1] then
+        return left & right
+    elsif right[$]<=left[1] then
+        return right & left
+    end if
+    return merge(left, right)
+end function
+
+constant s = shuffle(tagset(10))
+? s
+? mergesort(s)

Task/Sorting-algorithms-Merge-sort/Sidef/sorting-algorithms-merge-sort.sidef

@@ -0,0 +1,29 @@
+func merge(left, right) {
+    var result = [];
+    while (!left.is_empty && !right.is_empty) {
+        result.append([right,left][left.first <= right.first].shift);
+    };
+    result + left + right;
+}
+ 
+func mergesort(array) {
+    var len = array.len;
+    len < 2 && return array;
+ 
+    var mid   = (len/2 -> int);
+    var left  = array.ft(0, mid-1);
+    var right = array.ft(mid);
+ 
+    left  = __FUNC__(left);
+    right = __FUNC__(right);
+ 
+    merge(left, right);
+}
+ 
+# Numeric sort
+var nums = (0..7 -> shuffle);
+say mergesort(nums);
+ 
+# String sort
+var strings = ('a'..'e' -> shuffle);
+say mergesort(strings);

Task/Sorting-algorithms-Merge-sort/Swift/sorting-algorithms-merge-sort.swift

@@ -0,0 +1,45 @@
+func mergeSort<T:Comparable>(inout list:[T]) {
+    if list.count <= 1 {
+        return
+    }
+
+    func merge(var left:[T], var right:[T]) -> [T] {
+        var result = [T]()
+
+        while left.count != 0 && right.count != 0 {
+            if left[0] <= right[0] {
+                result.append(left.removeAtIndex(0))
+            } else {
+                result.append(right.removeAtIndex(0))
+            }
+        }
+
+        while left.count != 0 {
+            result.append(left.removeAtIndex(0))
+        }
+
+        while right.count != 0 {
+            result.append(right.removeAtIndex(0))
+        }
+
+        return result
+    }
+
+    var left = [T]()
+    var right = [T]()
+
+    let mid = list.count / 2
+
+    for i in 0..<mid {
+        left.append(list[i])
+    }
+
+    for i in mid..<list.count {
+        right.append(list[i])
+    }
+
+    mergeSort(&left)
+    mergeSort(&right)
+
+    list = merge(left, right)
+}

Task/Sorting-algorithms-Merge-sort/jq/sorting-algorithms-merge-sort-1.jq

@@ -0,0 +1,22 @@
+# Input: [x,y] -- the two arrays to be merged
+# If x and y are sorted as by "sort", then the result will also be sorted:
+def merge:
+  def m:  # state: [x, y, array]  (array being the answer)
+    .[0] as $x
+    | .[1] as $y
+    | if   0 == ($x|length) then .[2] + $y
+      elif 0 == ($y|length) then .[2] + $x
+      else
+        (if $x[0] <= $y[0] then [$x[1:], $y,     .[2] + [$x[0] ]]
+         else                   [$x,     $y[1:], .[2] + [$y[0] ]]
+         end) | m
+      end;
+   [.[0], .[1], []] | m;
+
+def merge_sort:
+  if length <= 1 then .
+  else
+    (length/2 |floor) as $len
+    | . as $in
+    | [ ($in[0:$len] | merge_sort), ($in[$len:] | merge_sort) ] | merge
+  end;

Task/Sorting-algorithms-Merge-sort/jq/sorting-algorithms-merge-sort-2.jq

@@ -0,0 +1,4 @@
+( [1, 3, 8, 9, 0, 0, 8, 7, 1, 6],
+  [170, 45, 75, 90, 2, 24, 802, 66],
+  [170, 45, 75, 90, 2, 24, -802, -66] )
+| (merge_sort == sort)