Add tasks for all the new languages

Task/Sort-using-a-custom-comparator/Ceylon/sort-using-a-custom-comparator.ceylon

@@ -0,0 +1,14 @@
+shared void run() {
+
+	value strings = [
+		"Cat", "apple", "Adam", "zero", "Xmas", "quit",
+		"Level", "add", "Actor", "base", "butter"
+	];
+
+	value sorted = strings.sort((String x, String y) =>
+			if(x.size == y.size)
+			then increasing(x.lowercased, y.lowercased)
+			else decreasing(x.size, y.size));
+	
+	sorted.each(print);
+}

Task/Sort-using-a-custom-comparator/FreeBASIC/sort-using-a-custom-comparator.freebasic

@@ -0,0 +1,48 @@
+' version 23-10-2016
+' compile with: fbc -s console
+
+#Include Once "crt/stdlib.bi" ' for qsort
+
+Function mycmp Cdecl (s1 As Any Pointer, s2 As Any Pointer) As Long
+
+    ' -1 no swap first element before second element
+    '  0 no swap needed, don't care
+    '  1 swap first element after second element
+
+    Dim As String str1 = *Cast(String Ptr, s1)
+    Dim As String str2 = *Cast(String Ptr, s2)
+
+    Dim As Long l1 = Len(str1), l2 = Len(str2)
+    If (l1 > l2) Then Return -1 ' descending
+    If (l1 < l2) Then Return  1 '
+
+    ' there equal length, sort ascending
+    If UCase(str1) = UCase(str2) Then
+        If str1 > str2 Then Return 1
+    Else
+        If UCase(str1) > UCase(str2) Then Return 1
+    End If
+
+    Return 0
+
+End Function
+
+' ------=< MAIN >=------
+
+Dim As String words(0 To ...) = {"Here", "are", "some", "sample", _
+                                 "strings", "to", "be", "sorted" }
+
+Dim As ULong array_size = UBound(words) - LBound(words) + 1
+
+qsort(@words(0), array_size, SizeOf(String), @mycmp)
+
+For i As Integer = 0 To UBound(words)
+    Print words(i)
+Next
+Print
+
+' empty keyboard buffer
+While InKey <> "" : Wend
+Print : Print "hit any key to end program"
+Sleep
+End

Task/Sort-using-a-custom-comparator/FunL/sort-using-a-custom-comparator.funl

@@ -0,0 +1,3 @@
+def preceeds( a, b ) = b.length() < a.length() or b.length() == a.length() and a.compareToIgnoreCase( b ) < 0
+
+println( ["here", "are", "Some", "sample", "strings", "to", "be", "sorted"].sortWith(preceeds) )

Task/Sort-using-a-custom-comparator/Nim/sort-using-a-custom-comparator.nim

@@ -0,0 +1,8 @@
+import strutils, algorithm
+
+var strings = "here are Some sample strings to be sorted".split(' ')
+
+strings.sort(proc (x,y: string): int =
+  cmp(y.len, x.len))
+
+echo strings

Task/Sort-using-a-custom-comparator/Oforth/sort-using-a-custom-comparator.oforth

@@ -0,0 +1,7 @@
+String method: customCmp(s)
+   s size self size > ifTrue: [ true return ]
+   s size self size < ifTrue: [ false return ]
+   s toUpper self toUpper <= ;
+
+["this", "is", "a", "set", "of", "strings", "to", "sort", "This", "Is", "A", "Set", "Of", "Strings", "To", "Sort"]
+sortWith(#customCmp) println

Task/Sort-using-a-custom-comparator/Phix/sort-using-a-custom-comparator.phix

@@ -0,0 +1,8 @@
+function my_compare(sequence a, sequence b)
+    if length(a)!=length(b) then
+        return -compare(length(a),length(b))
+    else
+        return compare(lower(a),lower(b))
+    end if
+end function
+?custom_sort(routine_id("my_compare"),{"Here", "are", "some", "sample", "strings", "to", "be", "sorted"})

Task/Sort-using-a-custom-comparator/Sidef/sort-using-a-custom-comparator.sidef

@@ -0,0 +1,3 @@
+func mycmp(a, b) { (b.len <=> a.len) || (a.lc <=> b.lc) };
+var strings = %w(Here are some sample strings to be sorted);
+var sorted = strings.sort(mycmp);

Task/Sort-using-a-custom-comparator/Swift/sort-using-a-custom-comparator-1.swift

@@ -0,0 +1,30 @@
+import Foundation
+
+var list = ["this",
+  "is",
+  "a",
+  "set",
+  "of",
+  "strings",
+  "to",
+  "sort",
+  "This",
+  "Is",
+  "A",
+  "Set",
+  "Of",
+  "Strings",
+  "To",
+  "Sort"]
+
+list.sortInPlace {lhs, rhs in
+  let lhsCount = lhs.characters.count
+  let rhsCount = rhs.characters.count
+  let result = rhsCount - lhsCount
+
+  if result == 0 {
+    return lhs.lowercaseString > rhs.lowercaseString
+  }
+
+  return lhsCount > rhsCount
+}

Task/Sort-using-a-custom-comparator/Swift/sort-using-a-custom-comparator-2.swift

@@ -0,0 +1,30 @@
+import Foundation
+
+var list = ["this",
+    "is",
+    "a",
+    "set",
+    "of",
+    "strings",
+    "to",
+    "sort",
+    "This",
+    "Is",
+    "A",
+    "Set",
+    "Of",
+    "Strings",
+    "To",
+    "Sort"]
+
+sort(&list) {lhs, rhs in
+    let lhsCount = count(lhs)
+    let rhsCount = count(rhs)
+    let result = rhsCount - lhsCount
+
+    if result == 0 {
+        return lhs.lowercaseString > rhs.lowercaseString
+    }
+
+    return lhsCount > rhsCount
+}

Task/Sort-using-a-custom-comparator/jq/sort-using-a-custom-comparator-1.jq

@@ -0,0 +1,22 @@
+def quicksort(cmp):
+  if length < 2 then .                                     # it is already sorted
+  else .[0] as $pivot
+    | reduce .[] as $x
+      # state: [less, equal, greater]
+      ( [ [], [], [] ];                                    # three empty arrays:
+        if   $x == $pivot then    .[1] += [$x]             # add x to equal
+        else ([$x,$pivot]|cmp) as $order
+          | if   $order == 0 then .[1] += [$x]             # ditto
+            elif ($order|type) == "number" then
+              if $order < 0 then  .[0] += [$x]             # add x to less
+              else .[2] += [$x]                            # add x to greater
+              end
+            else ([$pivot,$x]|cmp) as $order2
+              | if $order and $order2 then   .[1] += [$x]  # add x to equal
+                elif $order then   .[0] += [$x]            # add x to less
+                else .[2] += [$x]                          # add x to greater
+                end
+            end
+        end )
+    | (.[0] | quicksort(cmp) ) + .[1] + (.[2] | quicksort(cmp) )
+  end ;

Task/Sort-using-a-custom-comparator/jq/sort-using-a-custom-comparator-2.jq

@@ -0,0 +1,3 @@
+# Sort by string length, breaking ties using ordinary string comparison.
+["z", "yz", "ab", "c"]
+  | quicksort( (.[0]|length) > (.[1]|length) or ( (.[0]|length) == (.[1]|length) and .[0] < .[1] ) )

Task/Sort-using-a-custom-comparator/jq/sort-using-a-custom-comparator-3.jq

@@ -0,0 +1,6 @@
+[
+  "ab",
+  "yz",
+  "c",
+  "z"
+]