Add tasks for all the new languages

Task/Sorting-algorithms-Heapsort/EchoLisp/sorting-algorithms-heapsort.echolisp

@@ -0,0 +1,13 @@
+(lib 'heap)
+
+(define (heap-sort list)
+    (define heap (make-heap < )) ;; make a min heap
+    (list->heap list heap)
+    (while (not (heap-empty? heap))
+          (push 'stack (heap-pop heap)))
+    (stack->list 'stack))
+
+(define L (shuffle (iota 15)))
+    → (9 4 0 12 8 3 10 7 11 2 5 6 14 13 1)
+(heap-sort L)
+    → (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14)

Task/Sorting-algorithms-Heapsort/FreeBASIC/sorting-algorithms-heapsort.freebasic

@@ -0,0 +1,75 @@
+' version 22-10-2016
+' compile with: fbc -s console
+' for boundary checks on array's compile with: fbc -s console -exx
+
+' sort from lower bound to the highter bound
+' array's can have subscript range from -2147483648 to +2147483647
+
+Sub siftdown(hs() As Long, start As ULong , end_ As ULong)
+
+    Dim As ULong root = start
+    Dim As Long lb = LBound(hs)
+
+    While root * 2 +1 < end_
+        Dim As ULong child = root * 2 +1
+        If (child +1  < end_) And (hs(lb + child) < hs(lb + child +1)) Then
+            child = child +1
+        End If
+        If hs(lb + root) < hs(lb + child) Then
+            Swap hs(lb + root), hs(lb + child)
+            root = child
+        Else
+            Return
+        End If
+    Wend
+
+End Sub
+
+Sub heapsort(hs() As Long)
+
+    Dim As Long lb = LBound(hs)
+    Dim As ULong count = UBound(hs) - lb
+    Dim As Long start = (count -2) \ 2
+
+    While start >= 0
+        siftdown(hs(), start, count)
+        start = start -1
+    Wend
+
+    Dim As ULong end_ = count
+    While end_ > 0
+        Swap hs(lb + end_), hs(lb)
+        siftdown(hs(), 0, end_)
+        end_ = end_ -1
+    Wend
+
+End Sub
+
+' ------=< MAIN >=------
+
+Dim As Long array(-7 To 7)
+Dim As Long i, lb = LBound(array), ub = UBound(array)
+
+Randomize Timer
+For i = lb To ub : array(i) = i : Next
+For i = lb To ub
+    Swap array(i), array(Int(Rnd * (ub - lb +1)) + lb)
+Next
+
+Print "Unsorted"
+For i = lb To ub
+    Print Using " ###"; array(i);
+Next : Print : Print
+
+heapsort(array())
+
+Print "After heapsort"
+For i = lb To ub
+    Print Using " ###"; array(i);
+Next : Print
+
+' empty keyboard buffer
+While Inkey <> "" : Wend
+Print : Print "hit any key to end program"
+Sleep
+End

Task/Sorting-algorithms-Heapsort/FunL/sorting-algorithms-heapsort.funl

@@ -0,0 +1,30 @@
+def heapSort( a ) =
+  heapify( a )
+  end = a.length() - 1
+
+  while end > 0
+    a(end), a(0) = a(0), a(end)
+    siftDown( a, 0, --end )
+
+def heapify( a ) =
+  for i <- (a.length() - 2)\2..0 by -1
+    siftDown( a, i, a.length() - 1 )
+
+def siftDown( a, start, end ) =
+  root = start
+
+  while root*2 + 1 <= end
+    child = root*2 + 1
+
+    if child + 1 <= end and a(child) < a(child + 1)
+      child++
+
+    if a(root) < a(child)
+      a(root), a(child) = a(child), a(root)
+      root = child
+    else
+      break
+
+a = array( [7, 2, 6, 1, 9, 5, 0, 3, 8, 4] )
+heapSort( a )
+println( a )

Task/Sorting-algorithms-Heapsort/Nim/sorting-algorithms-heapsort.nim

@@ -0,0 +1,23 @@
+proc siftDown[T](a: var openarray[T]; start, ending: int) =
+  var root = start
+  while root * 2 + 1 < ending:
+    var child = 2 * root + 1
+    if child + 1 < ending and a[child] < a[child+1]:
+      inc child
+    if a[root] < a[child]:
+      swap a[child], a[root]
+      root = child
+    else:
+      return
+
+proc heapSort[T](a: var openarray[T]) =
+  let count = a.len
+  for start in countdown((count - 2) div 2, 0):
+    siftDown(a, start, count)
+  for ending in countdown(count - 1, 1):
+    swap a[ending], a[0]
+    siftDown(a, 0, ending)
+
+var a = @[4, 65, 2, -31, 0, 99, 2, 83, 782]
+heapSort a
+echo a

Task/Sorting-algorithms-Heapsort/Phix/sorting-algorithms-heapsort.phix

@@ -0,0 +1,39 @@
+function siftDown(sequence arr, integer s, integer last)
+integer root = s
+    while root*2<=last do
+        integer child = root*2
+        if child<last and arr[child]<arr[child+1] then
+            child += 1
+        end if
+        if arr[root]>=arr[child] then exit end if
+        object tmp = arr[root]
+        arr[root] = arr[child]
+        arr[child] = tmp
+        root = child
+    end while
+    return arr
+end function
+
+function heapify(sequence arr, integer count)
+integer s = floor(count/2)
+    while s>0 do
+        arr = siftDown(arr,s,count)
+        s -= 1
+    end while
+    return arr
+end function
+
+function heap_sort(sequence arr)
+integer last = length(arr)
+    arr = heapify(arr,last)
+    while last>1 do
+        object tmp = arr[1]
+        arr[1] = arr[last]
+        arr[last] = tmp
+        last -= 1
+        arr = siftDown(arr,1,last)
+    end while
+    return arr
+end function
+
+?heap_sort({5,"oranges","and",3,"apples"})

Task/Sorting-algorithms-Heapsort/Sidef/sorting-algorithms-heapsort.sidef

@@ -0,0 +1,39 @@
+func sift_down(a, start, end) {
+    var root = start;
+    while ((2*root + 1) <= end) {
+        var child = (2*root + 1);
+        if ((child+1 <= end) && (a[child] < a[child + 1])) {
+            child += 1;
+        }
+        if (a[root] < a[child]) {
+            a[child, root] = a[root, child];
+            root = child;
+        } else {
+            return;
+        }
+    }
+}
+
+func heapify(a, count) {
+    var start = ((count - 2) / 2);
+    while (start >= 0) {
+        sift_down(a, start, count-1);
+        start -= 1;
+    }
+}
+
+func heap_sort(a, count) {
+    heapify(a, count);
+    var end = (count - 1);
+    while (end > 0) {
+        a[0, end] = a[end, 0];
+        end -= 1;
+        sift_down(a, 0, end)
+    }
+    return a
+}
+
+var arr = (1..10 -> shuffle);  # creates a shuffled array
+say arr;                       # prints the unsorted array
+heap_sort(arr, arr.len);       # sorts the array in-place
+say arr;                       # prints the sorted array

Task/Sorting-algorithms-Heapsort/Swift/sorting-algorithms-heapsort.swift

@@ -0,0 +1,49 @@
+func heapsort<T:Comparable>(inout list:[T]) {
+    var count = list.count
+
+    func shiftDown(inout list:[T], start:Int, end:Int) {
+        var root = start
+
+        while root * 2 + 1 <= end {
+            var child = root * 2 + 1
+            var swap = root
+
+            if list[swap] < list[child] {
+                swap = child
+            }
+
+            if child + 1 <= end && list[swap] < list[child + 1] {
+                swap = child + 1
+            }
+
+            if swap == root {
+                return
+            } else {
+                (list[root], list[swap]) = (list[swap], list[root])
+                root = swap
+            }
+        }
+    }
+
+    func heapify(inout list:[T], count:Int) {
+        var start = (count - 2) / 2
+
+        while start >= 0 {
+            shiftDown(&list, start, count - 1)
+
+            start--
+        }
+    }
+
+    heapify(&list, count)
+
+    var end = count - 1
+
+    while end > 0 {
+        (list[end], list[0]) = (list[0], list[end])
+
+        end--
+
+        shiftDown(&list, 0, end)
+    }
+}