Initial data commit

Task/Sort-three-variables/00-META.yaml

@@ -0,0 +1,5 @@
+---
+category:
+- Sorting
+from: http://rosettacode.org/wiki/Sort_three_variables
+note: Sorting Algorithms

Task/Sort-three-variables/00-TASK.txt

@@ -0,0 +1,64 @@
+{{Sorting Algorithm}}
+
+;Task:
+Sort   (the values of)   three variables   ('''X''',   '''Y''',   and   '''Z''')   that contain any value   (numbers and/or literals).
+
+If that isn't possible in your language, then just sort numbers   (and note if they can be floating point, integer, or other).
+
+I.E.:     (for the three variables   '''x''',   '''y''',   and   '''z'''),   where:
+                         x =  'lions, tigers, and'
+                         y =  'bears, oh my!'
+                         z =  '(from the "Wizard of OZ")'
+
+After sorting,  the three variables would hold:
+                         x =  '(from the "Wizard of OZ")'
+                         y =  'bears, oh my!'
+                         z =  'lions, tigers, and'
+
+<!--  Care was taken to use a leading lowercase letter so that EBCDIC and ASCII machines sort the literals in the same order. {Gerard Schildberger}  !-->
+For numeric value sorting, use:
+I.E.:  &nbsp;  (for the three variables &nbsp; '''x''', &nbsp; '''y''', &nbsp; and &nbsp; '''z'''), &nbsp; where:
+                         x =  77444
+                         y =    -12
+                         z =      0
+After sorting,  the three variables would hold:
+                         x =    -12
+                         y =      0
+                         z =  77444
+
+The variables should contain some form of a number, but specify if the algorithm
+used can be for floating point or integers. &nbsp; Note any limitations.
+
+The values may or may not be unique.
+
+The method used for sorting can be any algorithm; &nbsp; the goal is to use the most idiomatic in the computer programming language used.
+
+More than one algorithm could be shown if one isn't clearly the better choice.
+
+
+One algorithm could be:
+                         <big><big>&bull;</big></big>  store the three variables &nbsp; '''x''', '''y''', and '''z'''
+                                  into an array (or a list) &nbsp; '''A'''
+                         &nbsp;
+                         <big><big>&bull;</big></big>  sort  (the three elements of)  the array &nbsp; '''A'''
+                         &nbsp;
+                         <big><big>&bull;</big></big>  extract the three elements from the array and place them in the
+                                  variables '''x''', '''y''', and '''z''' &nbsp; in order of extraction
+
+
+
+Another algorithm &nbsp; (only for numeric values):
+        x= 77444 
+        y=   -12 
+        z=     0      
+     low= x                                          
+     mid= y                                          
+    high= z 
+       x= min(low,  mid,  high)            /*determine the lowest value of X,Y,Z. */    
+       z= max(low,  mid,  high)            /*    "      "  highest  "    " " " "  */    
+       y=     low + mid + high - x - z     /*    "      "  middle   "    " " " "  */      
+
+
+Show the results of the sort here on this page using at least the values of those shown above.
+<br><br>
+

Task/Sort-three-variables/11l/sort-three-variables.11l

@@ -0,0 +1,11 @@
+V x = 77444
+V y =   -12
+V z =     0
+(x, y, z) = tuple_sorted((x, y, z))
+print(x‘ ’y‘ ’z)
+
+V xs = ‘lions, tigers, and’
+V ys = ‘bears, oh my!’
+V zs = ‘(from the "Wizard of OZ")’
+(xs, ys, zs) = sorted([xs, ys, zs])
+print(xs"\n"ys"\n"zs)

Task/Sort-three-variables/8086-Assembly/sort-three-variables.8086

@@ -0,0 +1,33 @@
+mov ax,6FFFh
+mov bx,3456h
+mov cx,0
+
+;We'll consider these sorted when ax <= bx <= cx.
+
+SortRegisters proc
+cmp ax,bx
+jbe continue
+     ;if we got here, ax > bx. We don't know the relationship between bx and cx at this time.
+     cmp ax,cx
+     jbe swap_ax_and_bx
+        ;if we got here, ax > bx, and bx > cx. Therefore all we need to do is swap ax and cx, and we're done.
+        xchg ax,cx
+        jmp endOfProc
+
+swap ax_and_bx:
+;if we got here, ax > bx, and ax <= cx. So all we have to do is swap ax and bx, and we're done
+xchg ax,bx
+jmp end  ;back to top
+
+
+continue:  ;if we got here, ax <= bx.
+cmp bx,cx
+jbe end
+          ;if we got here, ax <= bx, and bx > cx. Therefore all we need to do is swap bx and cx, and we're done.
+          xchg bx,cx
+
+
+endOfProc: ;if we got here, ax <= bx, and bx <= cx. Therefore, ax <= bx <=cx and we are done.
+;
+
+SortRegisters endp

Task/Sort-three-variables/ALGOL-68/sort-three-variables.alg

@@ -0,0 +1,50 @@
+BEGIN
+    # MODE that can hold integers and strings - would need to be extended to #
+    # allow for other types                                                  #
+    MODE INTORSTRING = UNION( INT, STRING );
+    # returns TRUE if a is an INT, FALSE otherwise #
+    OP   ISINT    = ( INTORSTRING a )BOOL:   CASE a IN (INT):      TRUE OUT FALSE ESAC;
+    # returns TRUE if a is an INT, FALSE otherwise #
+    OP   ISSTRING = ( INTORSTRING a )BOOL:   CASE a IN (STRING):   TRUE OUT FALSE ESAC;
+    # returns the integer in a or 0 if a isn't an integer #
+    OP   TOINT    = ( INTORSTRING a )INT:    CASE a IN (INT i):    i    OUT 0     ESAC;
+    # returns the string in a or "" if a isn't a string #
+    OP   TOSTRING = ( INTORSTRING a )STRING: CASE a IN (STRING s): s    OUT ""    ESAC;
+    # returns TRUE if a < b, FALSE otherwise #
+    # a and b must have the same type #
+    PRIO LESSTHAN = 4;
+    OP   LESSTHAN = ( INTORSTRING a, b )BOOL:
+        IF  ISSTRING a AND ISSTRING b THEN
+            # both strings #
+            TOSTRING a < TOSTRING b
+        ELIF ISINT a AND ISINT b THEN
+            # both integers #
+            TOINT a < TOINT b
+        ELSE
+            # different MODEs #
+            FALSE
+        FI # LESSTHAN # ;
+    # exchanges the values of a and b #
+    PRIO SWAP = 9;
+    OP   SWAP = ( REF INTORSTRING a, b )VOID: BEGIN INTORSTRING t := a; a := b; b := t END;
+    # sorts a, b and c #
+    PROC sort 3 = ( REF INTORSTRING a, b, c )VOID:
+    BEGIN
+        IF b LESSTHAN a THEN a SWAP b FI;
+        IF c LESSTHAN a THEN a SWAP c FI;
+        IF c LESSTHAN b THEN b SWAP c FI
+    END # sort 3 # ;
+
+    # task test cases #
+    INTORSTRING x, y, z;
+    x := "lions, tigers, and";
+    y := "bears, oh my!";
+    z := "(from the ""Wizard of OZ"")";
+    sort 3( x, y, z );
+    print( ( x, newline, y, newline, z, newline ) );
+    x := 77444;
+    y := -12;
+    z := 0;
+    sort 3( x, y, z );
+    print( ( x, newline, y, newline, z, newline ) )
+END

Task/Sort-three-variables/APL/sort-three-variables.apl

@@ -0,0 +1 @@
+x y z←{⍵[⍋⍵]}x y z

Task/Sort-three-variables/Ada/sort-three-variables.ada

@@ -0,0 +1,64 @@
+with Ada.Text_IO;
+with Ada.Strings.Unbounded;
+
+procedure Sort_Three is
+
+   generic
+      type Element_Type is private;
+      with function "<" (Left, Right : in Element_Type) return Boolean;
+   procedure Generic_Sort (X, Y, Z : in out Element_Type);
+
+   procedure Generic_Sort (X, Y, Z : in out Element_Type)
+   is
+      procedure Swap (Left, Right : in out Element_Type) is
+         T : constant Element_Type := Left;
+      begin
+         Left := Right;
+         Right := T;
+      end Swap;
+   begin
+      if Y < X then Swap (X, Y); end if;
+      if Z < Y then Swap (Y, Z); end if;
+      if Y < X then Swap (X, Y); end if;
+   end Generic_Sort;
+
+   procedure Test_Unbounded_Sort is
+      use Ada.Text_IO;
+      use Ada.Strings.Unbounded;
+
+      X : Unbounded_String := To_Unbounded_String ("lions, tigers, and");
+      Y : Unbounded_String := To_Unbounded_String ("bears, oh my!");
+      Z : Unbounded_String := To_Unbounded_String ("(from the ""Wizard of OZ"")");
+
+      procedure Sort is
+         new Generic_Sort (Unbounded_String, "<");
+   begin
+      Sort (X, Y, Z);
+      Put_Line (To_String (X));
+      Put_Line (To_String (Y));
+      Put_Line (To_String (Z));
+      New_Line;
+   End Test_Unbounded_Sort;
+
+   procedure Test_Integer_Sort is
+
+      use Ada.Text_IO;
+
+      procedure Sort is
+         new Generic_Sort (Integer, "<");
+
+      X : Integer := 77444;
+      Y : Integer :=   -12;
+      Z : Integer :=     0;
+   begin
+      Sort (X, Y, Z);
+      Put_Line (X'Image);
+      Put_Line (Y'Image);
+      Put_Line (Z'Image);
+      New_Line;
+   end Test_Integer_Sort;
+
+begin
+   Test_Unbounded_Sort;
+   Test_Integer_Sort;
+end Sort_Three;

Task/Sort-three-variables/Aime/sort-three-variables.aime

@@ -0,0 +1,28 @@
+integer a, b, c;
+index i;
+text x, y, z;
+record r;
+
+x = "lions, tigers, and";
+y = "bears, oh my!";
+z = "(from the \"Wizard of OZ\")";
+
+r.fit(x, x, y, y, z, z);
+
+x = r.rf_pick;
+y = r.rf_pick;
+z = r.rf_pick;
+
+o_form("~\n~\n~\n", x, y, z);
+
+a = 77444;
+b = -12;
+c = 0;
+
+i.fit(a, a, b, b, c, c);
+
+a = i.if_pick;
+b = i.if_pick;
+c = i.if_pick;
+
+o_form("~\n~\n~\n", a, b, c);

Task/Sort-three-variables/AppleScript/sort-three-variables-1.applescript

@@ -0,0 +1,11 @@
+set x to "lions, tigers, and"
+set y to "bears, oh my!"
+set z to "(from the \"Wizard of OZ\")"
+
+if (x > y) then set {x, y} to {y, x}
+if (y > z) then
+    set {y, z} to {z, y}
+    if (x > y) then set {x, y} to {y, x}
+end if
+
+return {x, y, z}

Task/Sort-three-variables/AppleScript/sort-three-variables-2.applescript

@@ -0,0 +1,11 @@
+set x to 77444
+set y to -12
+set z to 0
+
+if (x > y) then set {x, y} to {y, x}
+if (y > z) then
+    set {y, z} to {z, y}
+    if (x > y) then set {x, y} to {y, x}
+end if
+
+return {x, y, z}

Task/Sort-three-variables/AppleScript/sort-three-variables-3.applescript

@@ -0,0 +1,23 @@
+set x to "lions, tigers, and"
+set y to "bears, oh my!"
+set z to "(from the \"Wizard of OZ\")"
+
+tell x
+    if (it > y) then
+        set x to y
+        set y to it
+    end if
+end tell
+tell z
+    if (it < y) then
+        set z to y
+        if (it < x) then
+            set y to x
+            set x to it
+        else
+            set y to it
+        end if
+    end if
+end tell
+
+return {x, y, z}

Task/Sort-three-variables/Arturo/sort-three-variables.arturo

@@ -0,0 +1,11 @@
+x: {lions, tigers, and}
+y: {bears, oh my!}
+z: {(from the "Wizard of OZ")}
+
+print join.with:"\n" sort @[x y z]
+
+x: 125
+y: neg 2
+z: pi
+
+print sort @[x y z]

Task/Sort-three-variables/AutoHotkey/sort-three-variables-1.ahk

@@ -0,0 +1,7 @@
+SortThreeVariables(ByRef x,ByRef y,ByRef z){
+  obj := []
+  for k, v in (var := StrSplit("x,y,z", ","))
+    obj[%v%] := true
+  for k, v in obj
+    temp := var[A_Index], %temp% := k
+}

Task/Sort-three-variables/AutoHotkey/sort-three-variables-2.ahk

@@ -0,0 +1,12 @@
+x =  lions, tigers, and
+y =  bears, oh my!
+z =  (from the "Wizard of OZ")
+SortThreeVariables(x,y,z)
+MsgBox % x "`n" y "`n" z
+
+x =  77444
+y =    -12
+z =      0
+SortThreeVariables(x,y,z)
+MsgBox % x "`n" y "`n" z
+return

Task/Sort-three-variables/BCPL/sort-three-variables.bcpl

@@ -0,0 +1,48 @@
+get "libhdr"
+
+// Sort 3 variables using a comparator.
+// X, Y and Z are pointers.
+let sort3(comp, x, y, z) be
+$(  sort2(comp, x, y)
+    sort2(comp, x, z)
+    sort2(comp, y, z)
+$)
+and sort2(comp, x, y) be
+    if comp(!x, !y) > 0
+    $(  let t = !x
+        !x := !y
+        !y := t
+    $)
+
+// Integer and string comparators
+let intcomp(x, y) = x - y
+let strcomp(x, y) = valof
+$(  for i=1 to min(x%0, y%0)
+        unless x%i = y%i
+            resultis intcomp(x%i, y%i)
+    resultis intcomp(x%0, y%0)
+$)
+and min(x, y) = x < y -> x, y
+
+// Run the function on both ints and strings
+let start() be
+$(  printAndSort(writen, intcomp, 7444, -12, 0)
+    printAndSort(writes, strcomp,
+        "lions, tigers, and",
+        "bears, oh my!",
+        "(from the *"Wizard of OZ*")")
+$)
+
+// Print the 3 values, sort them, and print them again
+and printAndSort(printfn, comp, x, y, z) be
+$(  print3(printfn, x, y, z) ; writes("*N")
+    sort3(comp, @x, @y, @z)
+    print3(printfn, x, y, z) ; writes("------*N")
+$)
+
+// Print 3 values given printing function
+and print3(printfn, x, y, z) be
+$(  writes("X = ") ; printfn(x) ; wrch('*N')
+    writes("Y = ") ; printfn(y) ; wrch('*N')
+    writes("Z = ") ; printfn(z) ; wrch('*N')
+$)

Task/Sort-three-variables/C++/sort-three-variables.cpp

@@ -0,0 +1,27 @@
+#include <algorithm>
+#include <iostream>
+#include <string>
+#include <vector>
+
+template < class T >
+void sort3( T& x, T& y, T& z) {
+    std::vector<T> v{x, y, z};
+    std::sort(v.begin(), v.end());
+    x = v[0]; y = v[1]; z = v[2];
+}
+int main() {
+    int xi = 77444, yi = -12, zi = 0;
+    sort3( xi, yi, zi );
+    std::cout << xi << "\n" << yi << "\n" << zi << "\n\n";
+
+    std::string xs, ys, zs;
+    xs = "lions, tigers, and";
+    ys = "bears, oh my!";
+    zs = "(from the \"Wizard of OZ\")";
+    sort3( xs, ys, zs );
+    std::cout << xs << "\n" << ys << "\n" << zs << "\n\n";
+
+    float xf = 11.3f, yf = -9.7f, zf = 11.17f;
+    sort3( xf, yf, zf );
+    std::cout << xf << "\n" << yf << "\n" << zf << "\n\n";
+}

Task/Sort-three-variables/C-sharp/sort-three-variables.cs

@@ -0,0 +1,31 @@
+using System;
+public class Program
+{
+    public static void Main()
+    {
+        (int x, int y, int z) = (77444, -12, 0);
+
+        //Sort directly:
+        if (x > y) (x, y) = (y, x);
+        if (x > z) (x, z) = (z, x);
+        if (y > z) (y, z) = (z, y);
+        Console.WriteLine((x, y, z));
+
+        var (a, b, c) = (
+            "lions, tigers, and",
+            "bears, oh my!",
+            "(from the 'Wizard of OZ')");
+
+        //Sort with generic method:
+        Sort(ref a, ref b, ref c);
+        Console.WriteLine((a, b, c));
+    }
+
+    public static void Sort<T>(ref T a, ref T b, ref T c)
+        where T : IComparable<T>
+    {
+        if (a.CompareTo(b) > 0) (a, b) = (b, a);
+        if (a.CompareTo(c) > 0) (a, c) = (c, a);
+        if (b.CompareTo(c) > 0) (b, c) = (c, b);
+    }
+}

Task/Sort-three-variables/C/sort-three-variables-1.c

@@ -0,0 +1,49 @@
+#include<string.h>
+#include<stdlib.h>
+#include<stdio.h>
+
+#define MAX 3
+
+int main()
+{
+  char values[MAX][100],tempStr[100];
+  int i,j,isString=0;
+  double val[MAX],temp;
+
+  for(i=0;i<MAX;i++){
+    printf("Enter %d%s value : ",i+1,(i==0)?"st":((i==1)?"nd":"rd"));
+    fgets(values[i],100,stdin);
+
+    for(j=0;values[i][j]!=00;j++){
+      if(((values[i][j]<'0' || values[i][j]>'9') && (values[i][j]!='.' ||values[i][j]!='-'||values[i][j]!='+'))
+      ||((values[i][j]=='.' ||values[i][j]=='-'||values[i][j]=='+')&&(values[i][j+1]<'0' || values[i][j+1]>'9')))
+        isString = 1;
+    }
+  }
+
+  if(isString==0){
+    for(i=0;i<MAX;i++)
+      val[i] = atof(values[i]);
+  }
+
+  for(i=0;i<MAX-1;i++){
+    for(j=i+1;j<MAX;j++){
+      if(isString==0 && val[i]>val[j]){
+        temp = val[j];
+        val[j] = val[i];
+        val[i] = temp;
+      }
+
+      else if(values[i][0]>values[j][0]){
+        strcpy(tempStr,values[j]);
+        strcpy(values[j],values[i]);
+        strcpy(values[i],tempStr);
+      }
+    }
+  }
+
+  for(i=0;i<MAX;i++)
+    isString==1?printf("%c = %s",'X'+i,values[i]):printf("%c = %lf",'X'+i,val[i]);
+
+  return 0;
+}

Task/Sort-three-variables/C/sort-three-variables-2.c

@@ -0,0 +1,27 @@
+#include<stdio.h>
+
+int main()
+{
+  int x = 77444,y=-12,z=0,temp;
+
+  printf("Before sorting :\nx = %d\ny = %d\nz = %d",x,y,z);
+
+  do{
+  temp = x;
+
+  if(temp > y){
+    x = y;
+    y = temp;
+  }
+
+  if(z < y){
+    temp = y;
+    y = z;
+    z = temp;
+  }
+  }while(x>y || y>z);
+
+  printf("\nAfter sorting :\nx = %d\ny = %d\nz = %d",x,y,z);
+
+  return 0;
+}

Task/Sort-three-variables/CLU/sort-three-variables.clu

@@ -0,0 +1,49 @@
+% Sort three variables.
+% The variables must all be of the same type, and the type
+% must implement the less-than comparator.
+sort_three = proc [T: type] (x,y,z: T) returns (T,T,T)
+             where T has lt: proctype (T,T) returns (bool)
+    if y<x then x,y := y,x end
+    if z<y then y,z := z,y end
+    if y<x then x,y := y,z end
+    return(x,y,z)
+end sort_three
+
+% Test it out on three values, when also given a type and a
+% formatter.
+example = proc [T: type] (x,y,z: T, fmt: proctype (T) returns (string))
+          where T has lt: proctype (T,T) returns (bool)
+    po: stream := stream$primary_output()
+
+    % Print the variables
+    stream$putl(po, "x=" || fmt(x)
+                || " y=" || fmt(y)
+                || " z=" || fmt(z))
+
+    % Sort them
+    x,y,z := sort_three[T](x,y,z)
+
+    % Print them again
+    stream$putl(po, "x=" || fmt(x)
+                || " y=" || fmt(y)
+                || " z=" || fmt(z)
+                || "\n")
+end example
+
+% And then we also need formatters, since those are not standardized
+% such as '<' is.
+fmt_real = proc (n: real) returns (string)
+    return(f_form(n,2,2))
+end fmt_real
+
+fmt_str = proc (s: string) returns (string)
+    return( "'" || s || "'" )
+end fmt_str
+
+% Test it out on values of each type
+start_up = proc ()
+    example[int] (77444, -12, 0, int$unparse)
+    example[real] (11.3, -9.7, 11.17, fmt_real)
+    example[string] ("lions, tigers and", "bears, oh my!",
+                    "(from the \"Wizard of Oz\")", fmt_str)
+end start_up

Task/Sort-three-variables/COBOL/sort-three-variables.cobol

@@ -0,0 +1,43 @@
+       program-id. 3var.
+       data division.
+       working-storage section.
+       1 n binary pic 9(4).
+       1 num pic -(7)9.
+       1 a1 pic x(32) value "lions, tigers, and".
+       1 a2 pic x(32) value "bears, oh my!".
+       1 a3 pic x(32) value "(from the ""Wizard of OZ"")".
+       1 n1 pic x(8) value "77444".
+       1 n2 pic x(8) value "-12".
+       1 n3 pic x(8) value "0".
+       1 alpha-table.
+        2 alpha-entry occurs 3 pic x(32).
+       1 numeric-table.
+        2 numeric-entry occurs 3 pic s9(8).
+       1 filler value "x = y = z = ".
+        2 lead-in occurs 3 pic x(4).
+       procedure division.
+       begin.
+           move a1 to alpha-entry (1)
+           move a2 to alpha-entry (2)
+           move a3 to alpha-entry (3)
+           sort alpha-entry ascending alpha-entry
+           perform varying n from 1 by 1
+           until n > 3
+               display lead-in (n) alpha-entry (n)
+           end-perform
+
+           display space
+
+           compute numeric-entry (1) = function numval (n1)
+           compute numeric-entry (2) = function numval (n2)
+           compute numeric-entry (3) = function numval (n3)
+           sort numeric-entry ascending numeric-entry
+           perform varying n from 1 by 1
+           until n > 3
+               move numeric-entry (n) to num
+               display lead-in (n) num
+           end-perform
+
+           stop run
+           .
+       end program 3var.

Task/Sort-three-variables/Cowgol/sort-three-variables.cowgol

@@ -0,0 +1,49 @@
+include "cowgol.coh";
+
+# Sort 3 values
+sub sort3(a: int32, b: int32, c: int32): (x: int32, y: int32, z: int32) is
+    sub sort2(a: int32, b: int32): (x: int32, y: int32) is
+        if a > b then
+            x := b;
+            y := a;
+        else
+            x := a;
+            y := b;
+        end if;
+    end sub;
+
+    x := a;
+    y := b;
+    z := c;
+    (x, y) := sort2(x, y);
+    (x, z) := sort2(x, z);
+    (y, z) := sort2(y, z);
+end sub;
+
+# Print 3 values
+sub print3(a: int32, b: int32, c: int32) is
+    sub print1(a: int32) is
+        var buf: uint8[10];
+        [IToA(a, 10, &buf[0])] := 0;
+        print(&buf[0]);
+        print_char(' ');
+    end sub;
+
+    print1(a);
+    print1(b);
+    print1(c);
+    print_nl();
+end sub;
+
+var x: int32 := 77444;
+var y: int32 := -12;
+var z: int32 := 0;
+
+# Print 3 values before sorting
+print3(x, y, z);
+
+# Sort 3 values
+(x, y, z) := sort3(x, y, z);
+
+# Print 3 values after sorting
+print3(x, y, z);

Task/Sort-three-variables/D/sort-three-variables.d

@@ -0,0 +1,35 @@
+import std.stdio;
+
+void main() {
+    driver(77444, -12, 0);
+    driver("lions, tigers, and", "bears, oh my!", "(from the \"Wizard of OZ\")");
+}
+
+void driver(T)(T x, T y, T z) {
+    writeln("BEFORE: x=[", x, "]; y=[", y, "]; z=[", z, "]");
+    sort3Var(x,y,z);
+    writeln("AFTER: x=[", x, "]; y=[", y, "]; z=[", z, "]");
+}
+
+void sort3Var(T)(ref T x, ref T y, ref T z)
+out {
+    assert(x<=y);
+    assert(x<=z);
+    assert(y<=z);
+}
+body {
+    import std.algorithm : swap;
+
+    if (x < y) {
+        if (z < x) {
+            swap(x,z);
+        }
+    } else if (y < z) {
+        swap(x,y);
+    } else {
+        swap(x,z);
+    }
+    if (z<y) {
+        swap(y,z);
+    }
+}

Task/Sort-three-variables/EDSAC-order-code/sort-three-variables.edsac

@@ -0,0 +1,47 @@
+[Sort three variables, for Rosetta Code.
+ EDSAC, Initial Orders 2]
+[---------------------------------------------------------------------------
+ Sorts three 35-bit variables x, y, x, stored at 0#V, 2#V, 4#V respectively.
+ Uses the algortihm:
+    if x > z then swap( x,z)
+    if y > z then swap( y,z)
+    if x > y then swap( x,y)
+ At most two swaps are carried out in any particular case.
+ ----------------------------------------------------------------------------]
+[Arrange the storage]
+            T47K P96F  [M parameter: main routine]
+            T55K P128F [V parameter: variables to be sorted]
+
+[Compressed form of library subroutine R2.
+ Reads integers at load time and is then overwritten.]
+            GKT20FVDL8FA40DUDTFI40FA40FS39FG@S2FG23FA5@T5@E4@E13Z
+            T#V     [tell R2 where to store integers]
+[EDIT: List of 35-bit integers separated by 'F', list terminated by '#TZ'.]
+987654321F500000000F123456789#TZ
+
+[Main routine]
+            E25K TM GK
+      [0]   A4#V S#V  [accumulator := z - x]
+            E8@       [skip the swap if x <= z]
+            TD        [0D := z - x]
+            A#V U4#V  [z := x]
+            AD        [acc := old z]
+            T#V       [x := old z]
+      [8]   TF        [clear acc]
+            A4#V S2#V [acc := z - y]
+            E17@      [skip the swap if y <= z]
+            TD        [0D := z - y]
+            A2#V U4#V [z := y]
+            AD        [acc := old z]
+            T2#V      [y := old z]
+     [17]   TF        [clear acc]
+            A2#V S#V  [acc := y - x]
+            E26@      [skip the swap if x <= y]
+            TD        [0D := y - x]
+            A#V U2#V  [y := x]
+            AD        [acc := old y]
+            T#V       [x := old y]
+     [26]   ZF        [halt the machine]
+            EZ        [define entry point]
+            PF        [acc = 0 on entry]
+[end]

Task/Sort-three-variables/Elena/sort-three-variables.elena

@@ -0,0 +1,25 @@
+import extensions;
+
+sortThree(ref object a, ref object b, ref object c)
+{
+    if (a > b) { exchange(ref a, ref b) };
+    if (a > c) { exchange(ref a, ref c) };
+    if (b > c) { exchange(ref b, ref c) }
+}
+
+public program()
+{
+    var x := 5;
+    var y := 1;
+    var z := 2;
+
+    var a := "lions, tigers, and";
+    var b := "bears, oh my!";
+    var c := "(from the 'Wizard of OZ')";
+
+    sortThree(ref x,ref y,ref z);
+    sortThree(ref a,ref b,ref c);
+
+    console.printLine(x,",",y,",",z);
+    console.printLine(a,",",b,",",c)
+}

Task/Sort-three-variables/Elixir/sort-three-variables.elixir

@@ -0,0 +1,13 @@
+x = 'lions, tigers, and'
+y = 'bears, oh my!'
+z = '(from the "Wizard of OZ")'
+
+[x, y, z] = Enum.sort([x, y, z])
+IO.puts "x = #{x}\ny = #{y}\nz = #{z}\n"
+
+x = 77444
+y = -12
+z = 0
+
+[x, y, z] = Enum.sort([x, y, z])
+IO.puts "x = #{x}\ny = #{y}\nz = #{z}"

Task/Sort-three-variables/F-Sharp/sort-three-variables.fs

@@ -0,0 +1,4 @@
+ let x = "lions, tigers, and"
+ let y = "bears, oh my!"
+ let z = """(from the "Wizard of OZ")"""
+ List.iter (printfn "%s") (List.sort [x;y;z])

Task/Sort-three-variables/FALSE/sort-three-variables.false

@@ -0,0 +1,36 @@
+{ [s]waps two variables. (varref; varref) → () }
+[
+  b:  { loads the value at the top of the stack into b }
+  a:  { loads the value at the top of the stack into a }
+
+  a;; t:  { loads the value stored in the variable stored in a (hence the double dereference) into t }
+  b;; a;:  { loads the value stored in the variable stored in b into the variable stored in a }
+  t; b;:  { loads the value stored in t into the variable stored in b }
+]s:
+
+{ [p]rints the three variables. }
+[
+  "X = " x;. 10,
+  "Y = " y;. 10,
+  "Z = " z;. 10,
+]p:
+
+77444 x:
+12_ y:
+0 z:
+
+p;!
+
+{ if x > y, swap x and y }
+x;y;> [xys;!] ?
+
+{ if y > z, swap y and z }
+y;z;> [yzs;!] ?
+
+{ if x > y, swap x and y }
+x;y;> [xys;!] ?
+
+"After sorting:
+"
+
+p;!

Task/Sort-three-variables/Factor/sort-three-variables.factor

@@ -0,0 +1,11 @@
+USING: arrays io kernel prettyprint sequences sorting ;
+IN: rosetta-code.sort-three
+
+: sort3 ( b c a -- a b c ) 3array natural-sort first3 ;
+
+"lions, tigers, and"
+"bears, oh my!"
+"(from the \"Wizard of OZ\")"
+sort3 [ print ] tri@
+
+77444 -12 0 sort3 [ . ] tri@

Task/Sort-three-variables/Fortran/sort-three-variables-1.f

@@ -0,0 +1,8 @@
+      TYPE(MONGREL)
+       INTEGER TYPEIS
+       INTEGER VI
+       REAL VF
+       CHARACTER*(enuff) VC
+       ...etc...
+      END TYPE MONGREL
+      TYPE (MONGREL) DOG

Task/Sort-three-variables/Fortran/sort-three-variables-2.f

@@ -0,0 +1,30 @@
+      SUBROUTINE SORT3(X,Y,Z) !Perpetrate a bubblesort in-line.
+       CHARACTER*(*) X,Y,Z  !Just three to rearrange.
+       CHARACTER*(MAX(LEN(X),LEN(Y),LEN(Z))) T  !Really, they should all be the same length.
+        IF (X.GT.Y) CALL SWAPC(X,Y) !The first pass: for i:=2:3 do if a(i - 1) > a(i) swap
+        IF (Y.GT.Z) CALL SWAPC(Y,Z) !The second test of the first pass.
+        IF (X.GT.Y) CALL SWAPC(X,Y) !The second pass: for i:=2:2...
+       CONTAINS   !Alas, Fortran does not offer a SWAP statement.
+        SUBROUTINE SWAPC(A,B) !So, one must be devised for each case.
+        CHARACTER*(*) A,B !To have their content swapped.
+         T = A      !Ccpy the first to a safe space.
+         A = B      !Copy the second on to the first.
+         B = T      !Copy what had been first to the second.
+        END SUBROUTINE SWAPC  !One of these will be needed for each type of datum.
+       END SUBROUTINE SORT3 !No attempt is made to stop early, as for already-ordered data.
+
+       PROGRAM POKE
+       CHARACTER*28 XYZ(3,2)  !Encompass the two examples.
+       DATA XYZ/    !Storage order is "column-major".
+     1 'lions, tigers, and','bears, oh my!','(from the "Wizard of OZ")',  !So (1,1), (2,1), (3,1)
+     2 '77444','  -12','    0'/ !So this looks like a transposed array. But     (1,2), (2,2), (3,2)
+       INTEGER I    !A stepper for the loop.
+       DO I = 1,2   !Two examples.
+         WRITE (6,66) "Supplied: ", XYZ(1:3,I)  !As given.
+   66    FORMAT (A12,3(" >",A,"<"))   !Show as >text< for clarity.
+
+         CALL SORT3(XYZ(1,I),XYZ(2,I),XYZ(3,I)) !Three separate variables, that happen to be in an array.
+
+         WRITE (6,66) "Sorted, ? ", XYZ(1:3,I)  !The result.
+       END DO     !On to the next example.
+       END  !Nothing much.

Task/Sort-three-variables/Free-Pascal-Lazarus/sort-three-variables.pas

@@ -0,0 +1,59 @@
+{$mode objFPC}
+
+generic procedure sort<T>(var X, Y: T);
+	procedure swap;
+	var
+		Z: T;
+	begin
+		Z := X;
+		X := Y;
+		Y := Z
+	end;
+begin
+	if X > Y then
+	begin
+		swap
+	end
+end;
+
+generic procedure sort<T>(var X, Y, Z: T);
+begin
+	specialize sort<T>(X, Y);
+	specialize sort<T>(X, Z);
+	specialize sort<T>(Y, Z)
+end;
+
+generic procedure print<T>(const X, Y, Z: T);
+begin
+	writeLn('X = ', X);
+	writeLn('Y = ', Y);
+	writeLn('Z = ', Z)
+end;
+
+{ === MAIN ============================================================= }
+var
+	A, B, C: string;
+	I, J, K: integer;
+	P, Q, R: real;
+begin
+	A := 'lions, tigers, and';
+	B := 'bears, oh my!';
+	C := '(from the "Wizard of OZ")';
+	
+	specialize sort<string>(A, B, C);
+	specialize print<string>(A, B, C);
+	
+	writeLn;
+	I := 77444;
+	J :=   -12;
+	K :=     0;
+	specialize sort<integer>(I, J, K);
+	specialize print<integer>(I, J, K);
+	
+	writeLn;
+	P :=  12.34;
+	Q := -56.78;
+	R :=   9.01;
+	specialize sort<real>(P, Q, R);
+	specialize print<real>(P, Q, R)
+end.

Task/Sort-three-variables/FreeBASIC/sort-three-variables.basic

@@ -0,0 +1,26 @@
+#macro sort_three( x, y, z )
+    if x>y then swap x, y
+    if y>z then swap y, z
+    if x>y then swap x, y
+#endmacro
+
+'demonstrate this for strings
+dim as string x =  "lions, tigers, and"
+dim as string y =  "bears, oh my!"
+dim as string z =  "(from the ""Wizard of OZ"")"
+
+sort_three(x,y,z)
+print x
+print y
+print z : print
+
+
+'demonstrate this for signed integers
+dim as integer a = 77444
+dim as integer b = -12
+dim as integer c = 0
+
+sort_three(a,b,c)
+print a
+print b
+print c

Task/Sort-three-variables/Go/sort-three-variables.go

@@ -0,0 +1,175 @@
+package main
+
+import (
+    "fmt"
+    "log"
+    "sort"
+)
+
+var (
+    stringsIn = []string{
+        `lions, tigers, and`,
+        `bears, oh my!`,
+        `(from the "Wizard of OZ")`}
+    intsIn = []int{77444, -12, 0}
+)
+
+func main() {
+    {
+        // initialize three vars
+        x, y, z := stringsIn[0], stringsIn[1], stringsIn[2]
+
+        // I. Task suggested technique, move values to array (slice).
+        // It's consise and relies on library code.
+        s := []string{x, y, z}
+        sort.Strings(s)
+        x, y, z = s[0], s[1], s[2]
+
+        // validate
+        if x > y || y > z {
+            log.Fatal()
+        }
+
+        // II. Likely fastest technique, minimizing tests and data movement.
+        // Least consise though, hardest to understand, and most chance to make
+        // a coding mistake.
+        x, y, z = stringsIn[0], stringsIn[1], stringsIn[2] // (initialize)
+        if x < y {
+            switch {
+            case y < z:
+            case x < z:
+                y, z = z, y
+            default:
+                x, y, z = z, x, y
+            }
+        } else {
+            switch {
+            case x < z:
+                x, y = y, x
+            case z < y:
+                x, z = z, x
+            default:
+                x, y, z = y, z, x
+            }
+        }
+        if x > y || y > z { // (validate)
+            log.Fatal()
+        }
+
+        // III.  A little more consise than II, easier to understand, almost
+        // as fast.
+        x, y, z = stringsIn[0], stringsIn[1], stringsIn[2] // (initialize)
+        if x > y {
+            x, y = y, x
+        }
+        if y > z {
+            y, z = z, y
+        }
+        if x > y {
+            x, y = y, x
+        }
+        if x > y || y > z { // (validate)
+            log.Fatal()
+        }
+        fmt.Println("sorted strings:")
+        fmt.Println(" ", x)
+        fmt.Println(" ", y)
+        fmt.Println(" ", z)
+        fmt.Println("original data:")
+        fmt.Println(" ", stringsIn[0])
+        fmt.Println(" ", stringsIn[1])
+        fmt.Println(" ", stringsIn[2])
+    }
+    // same techniques, with integer test case
+    {
+        // task suggested technique
+        x, y, z := intsIn[0], intsIn[1], intsIn[2] // (initialize)
+        s := []int{x, y, z}
+        sort.Ints(s)
+        x, y, z = s[0], s[1], s[2]
+        if x > y || y > z { // (validate)
+            log.Fatal()
+        }
+
+        // minimizing data movement
+        x, y, z = intsIn[0], intsIn[1], intsIn[2] // (initialize)
+        if x < y {
+            switch {
+            case y < z:
+            case x < z:
+                y, z = z, y
+            default:
+                x, y, z = z, x, y
+            }
+        } else {
+            switch {
+            case x < z:
+                x, y = y, x
+            case z < y:
+                x, z = z, x
+            default:
+                x, y, z = y, z, x
+            }
+        }
+        if x > y || y > z { // (validate)
+            log.Fatal()
+        }
+
+        // three swaps
+        x, y, z = intsIn[0], intsIn[1], intsIn[2] // (initialize)
+        if x > y {
+            x, y = y, x
+        }
+        if y > z {
+            y, z = z, y
+        }
+        if x > y {
+            x, y = y, x
+        }
+        if x > y || y > z { // (validate)
+            log.Fatal()
+        }
+        fmt.Println("sorted ints:", x, y, z)
+        fmt.Println("original data:", intsIn)
+    }
+    // To put any of these techniques in a function, a function could just
+    // take three values and return them sorted.
+    {
+        sort3 := func(x, y, z int) (int, int, int) {
+            if x > y {
+                x, y = y, x
+            }
+            if y > z {
+                y, z = z, y
+            }
+            if x > y {
+                x, y = y, x
+            }
+            return x, y, z
+        }
+        x, y, z := intsIn[0], intsIn[1], intsIn[2] // (initialize)
+        x, y, z = sort3(x, y, z)
+        if x > y || y > z { // (validate)
+            log.Fatal()
+        }
+    }
+    // Alternatively, a function could take pointers
+    {
+        sort3 := func(x, y, z *int) {
+            if *x > *y {
+                *x, *y = *y, *x
+            }
+            if *y > *z {
+                *y, *z = *z, *y
+            }
+            if *x > *y {
+                *x, *y = *y, *x
+            }
+        }
+        x, y, z := intsIn[0], intsIn[1], intsIn[2] // (initialize)
+        sort3(&x, &y, &z)
+        if x > y || y > z { // (validate)
+            log.Fatal()
+        }
+    }
+}

Task/Sort-three-variables/Haskell/sort-three-variables.hs

@@ -0,0 +1,25 @@
+import Data.List (sort)
+
+sortedTriple
+  :: Ord a
+  => (a, a, a) -> (a, a, a)
+sortedTriple (x, y, z) =
+  let [a, b, c] = sort [x, y, z]
+  in (a, b, c)
+
+sortedListfromTriple
+  :: Ord a
+  => (a, a, a) -> [a]
+sortedListfromTriple (x, y, z) = sort [x, y, z]
+
+-- TEST ----------------------------------------------------------------------
+main :: IO ()
+main = do
+  print $
+    sortedTriple
+      ("lions, tigers, and", "bears, oh my!", "(from the \"Wizard of OZ\")")
+  print $
+    sortedListfromTriple
+      ("lions, tigers, and", "bears, oh my!", "(from the \"Wizard of OZ\")")
+  print $ sortedTriple (77444, -12, 0)
+  print $ sortedListfromTriple (77444, -12, 0)

Task/Sort-three-variables/IS-BASIC/sort-three-variables.basic

@@ -0,0 +1,9 @@
+100 LET X=77444:LET Y=-12:LET Z=0
+110 PRINT X;Y;Z
+120 CALL SHORT(X,Y,Z)
+130 PRINT X;Y;Z
+140 DEF SHORT(REF A,REF B,REF C)
+150   IF A>B THEN LET T=A:LET A=B:LET B=T
+160   IF B>C THEN LET T=B:LET B=C:LET C=T
+170   IF A>B THEN LET T=A:LET A=B:LET B=T
+180 END DEF

Task/Sort-three-variables/J/sort-three-variables.j

@@ -0,0 +1,21 @@
+   x =:  'lions, tigers, and'
+   y =:  'bears, oh my!'
+   z =:  '(from the "Wizard of OZ")'
+   'x y z'=: /:~".'x;y;<z'
+   x
+(from the "Wizard of OZ")
+   y
+bears, oh my!
+   z
+lions, tigers, and
+
+   x =:  77444
+   y =:    -12
+   z =:      0
+   'x y z'=: /:~".'x;y;<z'
+   x
+_12
+   y
+0
+   z
+77444

Task/Sort-three-variables/Java/sort-three-variables.java

@@ -0,0 +1,42 @@
+import java.util.Comparator;
+import java.util.stream.Stream;
+
+class Box {
+    public int weightKg;
+
+    Box(final int weightKg) {
+        this.weightKg = weightKg;
+    }
+}
+
+public class Sort3Vars {
+    public static void main(String... args) {
+        int iA = 21;
+        int iB = 11;
+        int iC = 82;
+        int[] sortedInt = Stream.of(iA, iB, iC).sorted().mapToInt(Integer::intValue).toArray();
+        iA = sortedInt[0];
+        iB = sortedInt[1];
+        iC = sortedInt[2];
+        System.out.printf("Sorted values: %d %d %d%n", iA, iB, iC);
+
+        String sA = "s21";
+        String sB = "s11";
+        String sC = "s82";
+        Object[] sortedStr = Stream.of(sA, sB, sC).sorted().toArray();
+        sA = (String) sortedStr[0];
+        sB = (String) sortedStr[1];
+        sC = (String) sortedStr[2];
+        System.out.printf("Sorted values: %s %s %s%n", sA, sB, sC);
+
+        Box bA = new Box(200);
+        Box bB = new Box(12);
+        Box bC = new Box(143);
+        // Provides a comparator for Box instances
+        Object[] sortedBox = Stream.of(bA, bB, bC).sorted(Comparator.comparingInt(a -> a.weightKg)).toArray();
+        bA = (Box) sortedBox[0];
+        bB = (Box) sortedBox[1];
+        bC = (Box) sortedBox[2];
+        System.out.printf("Sorted Boxes: %dKg %dKg %dKg%n", bA.weightKg, bB.weightKg, bC.weightKg);
+    }
+}

Task/Sort-three-variables/JavaScript/sort-three-variables.js

@@ -0,0 +1,26 @@
+const printThree = (note, [a, b, c], [a1, b1, c1]) => {
+  console.log(`${note}
+    ${a} is: ${a1}
+    ${b} is: ${b1}
+    ${c} is: ${c1}
+  `);
+};
+const sortThree = () => {
+
+  let a = 'lions, tigers, and';
+  let b = 'bears, oh my!';
+  let c = '(from the "Wizard of OZ")';
+  printThree('Before Sorting', ['a', 'b', 'c'], [a, b, c]);
+
+  [a, b, c] = [a, b, c].sort();
+  printThree('After Sorting', ['a', 'b', 'c'], [a, b, c]);
+
+  let x = 77444;
+  let y = -12;
+  let z = 0;
+  printThree('Before Sorting', ['x', 'y', 'z'], [x, y, z]);
+
+  [x, y, z] = [x, y, z].sort();
+  printThree('After Sorting', ['x', 'y', 'z'], [x, y, z]);
+};
+sortThree();

Task/Sort-three-variables/Jq/sort-three-variables-1.jq

@@ -0,0 +1,11 @@
+def example1:
+ {x: "lions, tigers, and",
+  y: "bears, oh my",
+  z: "(from the \"Wizard of OZ\")"
+ };
+
+def example2:
+ {x: 77444,
+  y: -12,
+  z: 0
+ };

Task/Sort-three-variables/Jq/sort-three-variables-2.jq

@@ -0,0 +1,4 @@
+def sortVariables:
+  keys_unsorted as $keys
+  | ([.[]] | sort) as $values
+  | reduce range(0; $keys|length) as $i ({}; .[$keys[$i]] = ($values[$i]) ) ;

Task/Sort-three-variables/Jq/sort-three-variables-3.jq

@@ -0,0 +1 @@
+example1 | sortVariables

Task/Sort-three-variables/Jq/sort-three-variables-4.jq

@@ -0,0 +1 @@
+example2 | sortVariables

Task/Sort-three-variables/Jsish/sort-three-variables.jsish

@@ -0,0 +1,88 @@
+#!/usr/bin/env jsish
+/* Sort three variables, in Jsish. semi-colon start/end for unit test echo */
+
+var x =  'lions, tigers, and';
+var y =  'bears, oh my!';
+var z =  '(from the "Wizard of OZ")';
+
+var arr = [x,y,z];
+arr = arr.sort();
+
+;'As strings, before:';
+;x;
+;y;
+;z;
+
+x = arr.shift();
+y = arr.shift();
+z = arr.shift();
+
+;'x,y,z after:';
+;x;
+;y;
+;z;
+
+x =  77444;
+y =    -12;
+z =      0;
+
+arr = [x,y,z];
+arr = arr.sort();
+
+;'As numbers before:';
+;x;
+;y;
+;z;
+
+x = arr.shift();
+y = arr.shift();
+z = arr.shift();
+
+;'x,y,z after:';
+;x;
+;y;
+;z;
+
+;'Mixed, integer, float, string';
+x =  3.14159;
+y =  2;
+z =  '1 string';
+;x;
+;y;
+;z;
+arr = [x,y,z].sort();
+x = arr.shift(); y = arr.shift(); z = arr.shift();
+;'x,y,z after:';
+;x;
+;y;
+;z;
+
+
+/*
+=!EXPECTSTART!=
+'As strings, before:'
+x ==> lions, tigers, and
+y ==> bears, oh my!
+z ==> (from the "Wizard of OZ")
+'x,y,z after:'
+x ==> (from the "Wizard of OZ")
+y ==> bears, oh my!
+z ==> lions, tigers, and
+'As numbers before:'
+x ==> 77444
+y ==> -12
+z ==> 0
+'x,y,z after:'
+x ==> -12
+y ==> 0
+z ==> 77444
+'Mixed, integer, float, string'
+x ==> 3.14159
+y ==> 2
+z ==> 1 string
+'x,y,z after:'
+x ==> 2
+y ==> 3.14159
+z ==> 1 string
+=!EXPECTEND!=
+*/

Task/Sort-three-variables/Julia/sort-three-variables.julia

@@ -0,0 +1,9 @@
+# v0.6
+
+a, b, c = "lions, tigers, and", "bears, oh my!", "(from the \"Wizard of OZ\")"
+a, b, c = sort([a, b, c])
+@show a b c
+
+a, b, c = 77444, -12, 0
+a, b, c = sort([a, b, c])
+@show a b c

Task/Sort-three-variables/Kotlin/sort-three-variables.kotlin

@@ -0,0 +1,38 @@
+// version 1.1.2
+
+inline fun <reified T : Comparable<T>> sortThree(x: T, y: T, z: T): Triple<T, T, T> {
+    val a = arrayOf(x, y, z)
+    a.sort()
+    return Triple(a[0], a[1], a[2])
+}
+
+fun <T> printThree(x: T, y: T, z: T) = println("x = $x\ny = $y\nz = $z\n")
+
+fun main(args: Array<String>) {
+    var x = "lions, tigers, and"
+    var y = "bears, oh my!"
+    var z = """(from the "Wizard of OZ")"""
+    val t = sortThree(x, y, z)
+    x = t.first
+    y = t.second
+    z = t.third
+    printThree(x, y, z)
+
+    var x2 = 77444
+    var y2 = -12
+    var z2 = 0
+    val t2 = sortThree(x2, y2, z2)
+    x2 = t2.first
+    y2 = t2.second
+    z2 = t2.third
+    printThree(x2, y2, z2)
+
+    var x3 = 174.5
+    var y3 = -62.5
+    var z3 = 41.7
+    val t3 = sortThree(x3, y3, z3)
+    x3 = t3.first
+    y3 = t3.second
+    z3 = t3.third
+    printThree(x3, y3, z3)
+}

Task/Sort-three-variables/Ksh/sort-three-variables.ksh

@@ -0,0 +1,106 @@
+#!/bin/ksh
+
+# Sort three variables that may contain any value (numbers and/or literals)
+
+#	# Variables:
+#
+xl='lions, tigers, and'
+yl='bears, oh my!'
+zl='(from the "Wizard of OZ")'
+
+typeset -i xn=77444
+typeset -F yn=-12.0
+typeset -i zn=0
+
+#	# Functions:
+#
+
+#	# Function _intoarray(x, y, z, arr) - put 3 variables into arr[]
+#
+function _intoarray {
+	typeset _x ; nameref _x="$1"
+	typeset _y ; nameref _y="$2"
+	typeset _z ; nameref _z="$3"
+	typeset _arr ; nameref _arr="$4"
+
+	_arr=( "${_x}" "${_y}" "${_z}" )
+}
+
+#	# Function _arraysort(arr) - return sorted array (any type of elements)
+#
+function _arraysort {
+	typeset _arr ; nameref _arr="$1"
+	typeset _i _j ; integer _i _j
+
+	_sorttype _arr
+	case $? in
+		0)	# Literal sort
+			for (( _i=1; _i<${#_arr[*]}; _i++ )); do
+				_val="${_arr[_i]}"
+				(( _j = _i - 1 ))
+				while (( _j>=0 )) && [[ "${_arr[_j]}" > "${_val}" ]]; do
+					_arr[_j+1]="${_arr[_j]}"
+					(( _j-- ))
+				done
+				_arr[_j+1]="${_val}"
+			done
+		;;
+
+		1)	# Numeric sort
+			for (( _i=1; _i<${#_arr[*]}; _i++ )); do
+				_val=${_arr[_i]}
+				(( _j = _i - 1 ))
+				while (( _j>=0 && _arr[_j]>_val )); do
+					_arr[_j+1]=${_arr[_j]}
+					(( _j-- ))
+				done
+				_arr[_j+1]=${_val}
+			done
+		;;
+	esac
+}
+
+#	# Function _sorttype(_arr) - return 0 = Literal sort; 1 = Numeric sort
+#
+function _sorttype {
+	typeset _arr ; nameref _arr="$1"
+	typeset _i ; integer _i
+
+	for ((_i=0; _i<${#_arr[*]}; _i++)); do
+		[[ ${_arr[_i]} != *(\-)+(\d)*(\.)*(\d) ]] && return 0
+	done
+	return 1
+}
+
+#	# Function _outofarray(x, y, z, arr) - Put array elements into x, y, z
+#
+function _outofarray {
+	typeset _x ; nameref _x="$1"
+	typeset _y ; nameref _y="$2"
+	typeset _z ; nameref _z="$3"
+	typeset _arr ; nameref _arr="$4"
+
+	_x="${_arr[0]}"
+	_y="${_arr[1]}"
+	_z="${_arr[2]}"
+}
+
+ ######
+# main #
+ ######
+
+unset x y z
+printf "Numeric Variables:\n%s\n%s\n%s\n\n" "${xn}" "${yn}" "${zn}"
+typeset -a arrayn
+_intoarray xn yn zn arrayn
+_arraysort arrayn
+_outofarray x y z arrayn
+printf "Sorted Variables:\n%s\n%s\n%s\n\n" "${x}" "${y}" "${z}"
+
+unset x y z
+printf "Literal Variables:\n%s\n%s\n%s\n\n" "${xl}" "${yl}" "${zl}"
+typeset -a arrayl
+_intoarray xl yl zl arrayl
+_arraysort arrayl
+_outofarray x y z arrayl
+printf "Sorted Variables:\n%s\n%s\n%s\n\n" "${x}" "${y}" "${z}"

Task/Sort-three-variables/Little-Man-Computer/sort-three-variables.lmc

@@ -0,0 +1,60 @@
+// Little Man Computer
+// Sort x, y, z, in ascending order
+// Based on a sorting network:
+//   if x > z then swap( x, z)
+//   if x > y then swap( x, y)
+//   if y > z then swap( y, z)
+// with the addition that if the 2nd swap is executed
+// then the 3rd comparison is not needed.
+
+// Read numbers x, y, z, and display in their original order
+        INP
+        STA x
+        OUT
+        INP
+        STA y
+        OUT
+        INP
+        STA z
+        OUT
+// Sort so that x <= y <= z, and display in new order
+        LDA z
+        SUB x
+        BRP label1
+        LDA x
+        STA t
+        LDA z
+        STA x
+        LDA t
+        STA z
+label1  LDA y
+        SUB x
+        BRP label2
+        LDA x
+        STA t
+        LDA y
+        STA x
+        LDA t
+        STA y
+        BRA sorted // added to the sorting network
+label2  LDA z
+        SUB y
+        BRP sorted
+        LDA y
+        STA t
+        LDA z
+        STA y
+        LDA t
+        STA z
+sorted  LDA x
+        OUT
+        LDA y
+        OUT
+        LDA z
+        OUT
+        HLT
+x       DAT
+y       DAT
+z       DAT
+t       DAT
+// end

Task/Sort-three-variables/Lua/sort-three-variables.lua

@@ -0,0 +1,26 @@
+function variadicSort (...)
+  local t = {}
+  for _, x in pairs{...} do
+    table.insert(t, x)
+  end
+  table.sort(t)
+  return unpack(t)
+end
+
+local testCases = {
+  { x = 'lions, tigers, and',
+    y = 'bears, oh my!',
+    z = '(from the "Wizard of OZ")'
+  },
+  { x = 77444,
+    y = -12,
+    z = 0
+  }
+}
+for i, case in ipairs(testCases) do
+  x, y, z = variadicSort(case.x, case.y, case.z)
+  print("\nCase " .. i)
+  print("\tx = " .. x)
+  print("\ty = " .. y)
+  print("\tz = " .. z)
+end

Task/Sort-three-variables/M2000-Interpreter/sort-three-variables.m2000

@@ -0,0 +1,31 @@
+Module Sort3 {
+      Let X=77744, Y=-12, Z=0
+      Let X$ =  "lions, tigers, and",  Y$ =  "bears, oh my!",  Z$ =  {(from the "Wizard of OZ")}
+      \\ & use for by reference pass
+      Module SortSome (&X$, &Y$, &Z$){
+            If Type$(X$)<>"String" Then {
+                  Link X$,Y$, Z$ to X,Y,Z
+                  Print3()
+                  If Y>Z then Swap Y, Z  ' both numeric in Swap
+                  If X>Z then Swap X, Z
+                  If X>Y then Swap X, Y
+                  Print3()
+            } Else {
+                  Print3Str()
+                  If Y$>Z$ then Swap Y$, Z$ ' both strings in Swap
+                  If X$>Z$ then Swap X$, Z$
+                  If X$>Y$ then Swap X$, Y$
+                  Print3Str()
+            }
+      }
+      SortSome &X, &Y, &Z
+      SortSome &X$, &Y$, &Z$
+      Sub Print3()
+            \\ double ,, used to insert a New Line
+            Print "X=",X,,"Y=",Y,,"Z=",Z
+      End Sub
+      Sub Print3Str()
+            Print "X$=",X$,,"Y$=",Y$,,"Z$=",Z$
+      End Sub
+}
+Sort3

Task/Sort-three-variables/Maple/sort-three-variables.maple

@@ -0,0 +1,2 @@
+lst := sort([x,y,z]):
+x,y,z := lst[1],lst[2],lst[3]:

Task/Sort-three-variables/Mathematica/sort-three-variables-1.math

@@ -0,0 +1 @@
+{x, y, z} = Sort[{x, y, z}]

Task/Sort-three-variables/Mathematica/sort-three-variables-2.math

@@ -0,0 +1,5 @@
+x = 77444;
+y = -12;
+z = 0;
+{x, y, z} = Sort[{x, y, z}];
+{x, y, z}

Task/Sort-three-variables/Min/sort-three-variables.min

@@ -0,0 +1,19 @@
+(=c =b =a (a -> b -> c ->) => '> sort -> c @ b @ a @) :sort3
+
+"lions, tigers, and" :x
+"bears, oh my!" :y
+"(from the \"Wizard of OZ\")" :z
+
+'x 'y 'z sort3
+x puts!
+y puts!
+z puts!
+
+77444 :x
+-12 :y
+0 :z
+
+'x 'y 'z sort3
+x puts!
+y puts!
+z puts!

Task/Sort-three-variables/Modula-2/sort-three-variables.mod2

@@ -0,0 +1,44 @@
+MODULE SortThreeVariables;
+FROM FormatString IMPORT FormatString;
+FROM Terminal IMPORT WriteString,WriteLn,ReadChar;
+
+PROCEDURE SwapInt(VAR a,b : INTEGER);
+VAR t : INTEGER;
+BEGIN
+    t := a;
+    a := b;
+    b := t;
+END SwapInt;
+
+PROCEDURE Sort3Int(VAR x,y,z : INTEGER);
+BEGIN
+    IF x<y THEN
+        IF z<x THEN
+            SwapInt(x,z);
+        END;
+    ELSIF y<z THEN
+        SwapInt(x,y);
+    ELSE
+        SwapInt(x,z);
+    END;
+    IF z<y THEN
+        SwapInt(y,z);
+    END;
+END Sort3Int;
+
+VAR
+    buf : ARRAY[0..63] OF CHAR;
+    a,b,c : INTEGER;
+BEGIN
+    a := 77444;
+    b := -12;
+    c := 0;
+    FormatString("Before a=[%i]; b=[%i]; c=[%i]\n", buf, a, b, c);
+    WriteString(buf);
+
+    Sort3Int(a,b,c);
+    FormatString("Before a=[%i]; b=[%i]; c=[%i]\n", buf, a, b, c);
+    WriteString(buf);
+
+    ReadChar;
+END SortThreeVariables.

Task/Sort-three-variables/Nanoquery/sort-three-variables.nanoquery

@@ -0,0 +1,25 @@
+import sort
+
+// sorting string literals
+x = "lion, tigers, and"
+y = "bears, oh my!"
+z = "(from the \"Wizard of OZ\")"
+
+varlist = sort({x,y,z})
+
+x = varlist[0]
+y = varlist[1]
+z = varlist[2]
+println x; println y; println z
+
+// sorting integers
+x = 77444
+y = -12
+z = 0
+
+varlist = sort({x, y, z})
+
+x = varlist[0]
+y = varlist[1]
+z = varlist[2]
+println x; println y; println z

Task/Sort-three-variables/Nim/sort-three-variables.nim

@@ -0,0 +1,15 @@
+proc sortThree[T](a, b, c: var T) =
+  # Bubble sort, why not?
+  while not (a <= b and b <= c):
+    if a > b: swap a, b
+    if b > c: swap b, c
+
+proc testWith[T](a, b, c: T) =
+  var (x, y, z) = (a, b, c)
+  echo "Before: ", x, ", ", y, ", ", z
+  sortThree(x, y, z)
+  echo "After: ", x, ", ", y, ", ", z
+
+testWith(6, 4, 2)
+testWith(0.9, -37.1, 4.0)
+testWith("lions", "tigers", "bears")

Task/Sort-three-variables/OCaml/sort-three-variables.ocaml

@@ -0,0 +1,28 @@
+let sortrefs list =
+  let sorted = List.map ( ! ) list
+               |> List.sort (fun a b ->
+                   if a < b then -1 else
+                   if a > b then  1 else
+                     0) in
+  List.iter2 (fun v x -> v := x) list sorted
+
+open Printf
+
+let test () =
+  let x = ref "lions, tigers, and" in
+  let y = ref "bears, oh my!" in
+  let z = ref "(from the \"Wizard of OZ\")" in
+  sortrefs [x; y; z];
+  print_endline "case 1:";
+  printf "\tx: %s\n" !x;
+  printf "\ty: %s\n" !y;
+  printf "\tz: %s\n" !z;
+
+  let x = ref 77444 in
+  let y = ref (-12) in
+  let z = ref 0 in
+  sortrefs [x; y; z];
+  print_endline "case 1:";
+  printf "\tx: %d\n" !x;
+  printf "\ty: %d\n" !y;
+  printf "\tz: %d\n" !z

Task/Sort-three-variables/PHP/sort-three-variables.php

@@ -0,0 +1,34 @@
+<?php
+//Sort strings
+$x = 'lions, tigers, and';
+$y = 'bears, oh my!';
+$z = '(from the "Wizard of OZ")';
+$items = [$x, $y, $z];
+sort($items);
+
+list($x, $y, $z) = $items;
+
+echo <<<EOT
+Case 1:
+  x = $x
+  y = $y
+  z = $z
+
+EOT;
+
+//Sort numbers
+$x = 77444;
+$y = -12;
+$z = 0;
+$items = [$x, $y, $z];
+sort($items);
+
+list($x, $y, $z) = $items;
+
+echo <<<EOT
+Case 2:
+  x = $x
+  y = $y
+  z = $z
+
+EOT;

Task/Sort-three-variables/Pascal/sort-three-variables.pas

@@ -0,0 +1,55 @@
+program sortThreeVariables(output);
+
+type
+	{ this Extended Pascal data type may hold up to 25 `char` values }
+	line = string(25);
+
+{ this procedure sorts two lines }
+procedure sortLines(var X, Y: line);
+	{ nested procedure allocates space for Z only if needed }
+	procedure swap;
+	var
+		Z: line;
+	begin
+		Z := X;
+		X := Y;
+		Y := Z
+	end;
+begin
+	{ for lexical sorting write `if GT(X, Y) then` }
+	if X > Y then
+	begin
+		swap
+	end
+end;
+
+{ sorts three line variables’s values }
+procedure sortThreeLines(var X, Y, Z: line);
+begin
+	{ `var` parameters can be modified at the calling site }
+	sortLines(X, Y);
+	sortLines(X, Z);
+	sortLines(Y, Z)
+end;
+
+{ writes given lines on output preceded by `X = `, `Y = ` and `Z = ` }
+procedure printThreeLines(protected X, Y, Z: line);
+begin
+	{ `protected` parameters cannot be overwritten }
+	writeLn('X = ', X);
+	writeLn('Y = ', Y);
+	writeLn('Z = ', Z)
+end;
+
+{ === MAIN ============================================================= }
+var
+	A, B: line;
+	{ for demonstration purposes: alternative method to initialize }
+	C: line value '(from the "Wizard of OZ")';
+begin
+	A := 'lions, tigers, and';
+	B := 'bears, oh my!';
+	
+	sortThreeLines(A, B, C);
+	printThreeLines(A, B, C)
+end.

Task/Sort-three-variables/Perl/sort-three-variables.pl

@@ -0,0 +1,31 @@
+#!/usr/bin/env perl
+use 5.010_000;
+
+# Sort strings
+
+my $x = 'lions, tigers, and';
+my $y = 'bears, oh my!';
+my $z = '(from the "Wizard of OZ")';
+
+# When assigning a list to list, the values are mapped
+( $x, $y, $z ) = sort ( $x, $y, $z );
+
+say 'Case 1:';
+say "  x = $x";
+say "  y = $y";
+say "  z = $z";
+
+# Sort numbers
+
+$x = 77444;
+$y = -12;
+$z = 0;
+
+# The sort function can take a customizing block parameter.
+# The spaceship operator creates a by-value numeric sort
+( $x, $y, $z ) = sort { $a <=> $b } ( $x, $y, $z );
+
+say 'Case 2:';
+say "  x = $x";
+say "  y = $y";
+say "  z = $z";

Task/Sort-three-variables/Phix/sort-three-variables.phix

@@ -0,0 +1,9 @@
+(phixonline)-->
+ <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
+ <span style="color: #004080;">object</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">x</span><span style="color: #0000FF;">,</span><span style="color: #000000;">y</span><span style="color: #0000FF;">,</span><span style="color: #000000;">z</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">"lions, tigers, and"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"bears, oh my"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"(from the \"Wizard of OZ\")"</span><span style="color: #0000FF;">}</span>
+                          <span style="color: #0000FF;">?{</span><span style="color: #000000;">x</span><span style="color: #0000FF;">,</span><span style="color: #000000;">y</span><span style="color: #0000FF;">,</span><span style="color: #000000;">z</span><span style="color: #0000FF;">}</span>
+ <span style="color: #0000FF;">{</span><span style="color: #000000;">x</span><span style="color: #0000FF;">,</span><span style="color: #000000;">y</span><span style="color: #0000FF;">,</span><span style="color: #000000;">z</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sort</span><span style="color: #0000FF;">({</span><span style="color: #000000;">x</span><span style="color: #0000FF;">,</span><span style="color: #000000;">y</span><span style="color: #0000FF;">,</span><span style="color: #000000;">z</span><span style="color: #0000FF;">})</span>  <span style="color: #0000FF;">?{</span><span style="color: #000000;">x</span><span style="color: #0000FF;">,</span><span style="color: #000000;">y</span><span style="color: #0000FF;">,</span><span style="color: #000000;">z</span><span style="color: #0000FF;">}</span>
+
+ <span style="color: #0000FF;">{</span><span style="color: #000000;">x</span><span style="color: #0000FF;">,</span><span style="color: #000000;">y</span><span style="color: #0000FF;">,</span><span style="color: #000000;">z</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">77444</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">12</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">}</span>  <span style="color: #0000FF;">?{</span><span style="color: #000000;">x</span><span style="color: #0000FF;">,</span><span style="color: #000000;">y</span><span style="color: #0000FF;">,</span><span style="color: #000000;">z</span><span style="color: #0000FF;">}</span>
+ <span style="color: #0000FF;">{</span><span style="color: #000000;">x</span><span style="color: #0000FF;">,</span><span style="color: #000000;">y</span><span style="color: #0000FF;">,</span><span style="color: #000000;">z</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sort</span><span style="color: #0000FF;">({</span><span style="color: #000000;">x</span><span style="color: #0000FF;">,</span><span style="color: #000000;">y</span><span style="color: #0000FF;">,</span><span style="color: #000000;">z</span><span style="color: #0000FF;">})</span>  <span style="color: #0000FF;">?{</span><span style="color: #000000;">x</span><span style="color: #0000FF;">,</span><span style="color: #000000;">y</span><span style="color: #0000FF;">,</span><span style="color: #000000;">z</span><span style="color: #0000FF;">}</span>
+<!--

Task/Sort-three-variables/PicoLisp/sort-three-variables.l

@@ -0,0 +1,4 @@
+(let (X 77444  Y -12  Z 0)
+   (println X Y Z)
+   (mapc set '(X Y Z) (sort (list X Y Z)))
+   (println X Y Z) )

Task/Sort-three-variables/Plain-English/sort-three-variables.plain

@@ -0,0 +1,24 @@
+To run:
+Start up.
+Sort three numbers.
+Wait for the escape key.
+Shut down.
+
+To sort three numbers:
+Put 77444 into an x number.
+Put -12 into a y number.
+Put 0 into a z number.
+Write "===Before sorting===" on the console.
+Write "x: " then the x on the console.
+Write "y: " then the y on the console.
+Write "z: " then the z on the console.
+Sort the x and the y and the z.
+Write "===After sorting===" on the console.
+Write "x: " then the x on the console.
+Write "y: " then the y on the console.
+Write "z: " then the z on the console.
+
+To sort a first number and a second number and a third number:
+If the first number is greater than the second number, swap the first number with the second number.
+If the second number is greater than the third number, swap the second number with the third number.
+If the first number is greater than the second number, swap the first number with the second number.

Task/Sort-three-variables/PureBasic/sort-three-variables.basic

@@ -0,0 +1,40 @@
+;sort three variables: x, y, z
+
+;Macro handles any of the native types, including integers, floating point, and strings
+;because the variable types are not declared but substituted during each instance of the macro.
+;The sorting is in ascending order, i.e. x < y < z.
+Macro sort3vars(x, y, z)
+  If x > y: Swap x, y: EndIf
+  If x > z: Swap x, z: EndIf
+  If y > z: Swap y, z: EndIf
+EndMacro
+
+;Macro to perform the sorting test for each variable type, again by substitution.
+Macro test_sort(x, y, z)
+  PrintN("Variables before sorting: " + #CRLF$ + x + #CRLF$ + y + #CRLF$ + z + #CRLF$)
+  sort3vars(x, y, z)
+
+  PrintN("Variables after sorting: " + #CRLF$ + x + #CRLF$ + y + #CRLF$ + z + #CRLF$)
+EndMacro
+
+
+;Define three sets of variables each with a different type for testing
+Define.s x, y, z ;string
+x = "lions, tigers, and"
+y = "bears, oh my!"
+z = ~"(from the \"Wizard of OZ\")" ;uses an escaped string as one way to include quotation marks
+
+Define x1 = 77444, y1 = -12, z1 = 0 ;integer
+
+Define.f x2= 5.2, y2 = -1133.9, z2 = 0 ;floating point
+If OpenConsole()
+  PrintN("Sort three variables" + #CRLF$)
+  test_sort(x, y, z) ;strings
+
+  test_sort(x1, y1, z1) ;integers
+
+  test_sort(x2, y2, z2) ;floating point
+
+  Print(#CRLF$ + "Press ENTER to exit"): Input()
+  CloseConsole()
+EndIf

Task/Sort-three-variables/Python/sort-three-variables-1.py

@@ -0,0 +1,11 @@
+#python2 Code for Sorting 3 values
+a= raw_input("Enter values one by one ..\n1.").strip()
+b=raw_input("2.").strip()
+c=raw_input("3.").strip()
+if a>b :
+   a,b = b,a
+if a>c:
+   a,c = c,a
+if b>c:
+   b,c = c,b
+print(str(a)+" "+str(b)+" "+str(c))

Task/Sort-three-variables/Python/sort-three-variables-2.py

@@ -0,0 +1,5 @@
+while True:
+    x, y, z = eval(input('Three Python values: '))
+    print(f'As read: x = {x!r}; y = {y!r}; z = {z!r}')
+    x, y, z = sorted((x, y, z))
+    print(f' Sorted: x = {x!r}; y = {y!r}; z = {z!r}')

Task/Sort-three-variables/Quackery/sort-three-variables.quackery

@@ -0,0 +1,29 @@
+  [ stack ] is x
+  [ stack ] is y
+  [ stack ] is z
+
+  $ 'lions, tigers, and'        x put
+  $ 'bears, oh my!'             y put
+  $ '(from the "Wizard of OZ")' z put
+
+  x take y take z take
+  3 pack sortwith $> unpack
+  z put y put x put
+
+  say " x = " x take echo$ cr
+  say " y = " y take echo$ cr
+  say " z = " z take echo$ cr
+
+  cr
+
+   77444 x put
+  -12    y put
+   0     z put
+
+  x take y take z take
+  3 pack sortwith > unpack
+  z put y put x put
+
+  say " x = " x take echo cr
+  say " y = " y take echo cr
+  say " z = " z take echo cr

Task/Sort-three-variables/R/sort-three-variables-1.r

@@ -0,0 +1,4 @@
+#lang R
+
+assignVec <- Vectorize("assign", c("x", "value"))
+`%<<-%` <- function(x, value) invisible(assignVec(x, value, envir = .GlobalEnv)) # define multiple global assignments operator

Task/Sort-three-variables/R/sort-three-variables-2.r

@@ -0,0 +1,26 @@
+x <- 'lions, tigers, and'
+y <- 'bears, oh my!'
+z <- '(from the "Wizard of OZ")'
+
+c("x", "y", "z") %<<-% sort(c(x, y, z))
+
+x
+## [1] "(from the \"Wizard of OZ\")"
+y
+## [1] "bears, oh my!"
+z
+## [1] "lions, tigers, and"
+
+
+x <- 77444
+y <-   -12
+z <-     0
+
+c("x", "y", "z") %<<-% sort(c(x, y, z))
+
+x
+## [1] -12
+y
+## [1] 0
+z
+## [1] 77444

Task/Sort-three-variables/REXX/sort-three-variables-1.rexx

@@ -0,0 +1,15 @@
+/*REXX program sorts three (any value)  variables  (X, Y, and  Z)  into ascending order.*/
+parse arg x y z .                                /*obtain the three variables from C.L. */
+if x=='' | x==","  then x= 'lions, tigers, and'        /*Not specified?  Use the default*/
+if y=='' | y==","  then y= 'bears,  oh my!'            /* "      "        "   "     "   */
+if z=='' | z==","  then z= '(from "The Wizard of Oz")' /* "      "        "   "     "   */
+say '───── original value of X: '   x
+say '───── original value of Y: '   y
+say '───── original value of Z: '   z
+if x>y  then do;   _= x;   x= y;   y= _;   end   /*swap the values of   X   and   Y.    */      /* ◄─── sorting.*/
+if y>z  then do;   _= y;   y= z;   z= _;   end   /*  "   "     "    "   Y    "    Z.    */      /* ◄─── sorting.*/
+if x>y  then do;   _= x;   x= y;   y= _;   end   /*  "   "     "    "   X    "    Y.    */      /* ◄─── sorting */
+say                                              /*stick a fork in it,  we're all done. */
+say '═════  sorted  value of X: '   x
+say '═════  sorted  value of Y: '   y
+say '═════  sorted  value of Z: '   z

Task/Sort-three-variables/REXX/sort-three-variables-2.rexx

@@ -0,0 +1,16 @@
+/*REXX program sorts  three (numeric)  variables  (X, Y, and  Z)  into ascending order. */
+numeric digits 1000                              /*handle some pretty gihugic integers. */      /*can be bigger.*/
+parse arg x y z .                                /*obtain the three variables from C.L. */
+if x=='' | x==","  then x= 77444                 /*Not specified?  Then use the default.*/
+if y=='' | y==","  then y=   -12                 /* "      "         "   "   "     "    */
+if z=='' | z==","  then z=     0                 /* "      "         "   "   "     "    */
+w= max( length(x), length(y), length(z) )   + 5  /*find max width of the values, plus 5.*/
+say '───── original values of X, Y, and Z: '       right(x, w)   right(y, w)   right(z, w)
+low = x                                          /*assign a temporary variable.         */
+mid = y                                          /*   "   "     "        "              */
+high= z                                          /*   "   "     "        "              */
+              x= min(low,  mid,  high)           /*determine the lowest value of X,Y,Z. */      /* ◄─── sorting.*/
+              z= max(low,  mid,  high)           /*    "      "  highest  "    " " " "  */      /* ◄─── sorting.*/
+              y=     low + mid + high - x - z    /*    "      "  middle   "    " " " "  */      /* ◄─── sorting.*/
+                                                 /*stick a fork in it,  we're all done. */
+say '═════  sorted  values of X, Y, and Z: '    right(x, w)    right(y, w)    right(z, w)

Task/Sort-three-variables/Racket/sort-three-variables.rkt

@@ -0,0 +1,40 @@
+#lang racket
+
+(define-syntax-rule (sort-3! x y z <?)
+  (begin
+    (define-syntax-rule (swap! x y) (let ((tmp x)) (set! x y) (set! y tmp)))
+    (define-syntax-rule (sort-2! x y) (when (<? y x) (swap! x y)))
+    (sort-2! x y)
+    (sort-2! x z)
+    (sort-2! y z)))
+
+(module+ test
+  (require rackunit
+           data/order)
+
+  (define (test-permutations l <?)
+    (test-case
+     (format "test-permutations ~a" (object-name <?))
+     (for ((p (in-permutations l)))
+       (match-define (list a b c) p)
+       (sort-3! a b c <?)
+       (check-equal? (list a b c) l))))
+
+  (test-permutations '(1 2 3) <)
+
+  ;; string sorting
+  (let ((x  "lions, tigers, and")
+        (y  "bears, oh my!")
+        (z  "(from the \"Wizard of OZ\")"))
+    (sort-3! x y z string<?)
+    (for-each displayln (list x y z)))
+
+  (newline)
+
+  ;; general data sorting
+  (define datum<? (order-<? datum-order))
+  (let ((x  "lions, tigers, and")
+        (y  "bears, oh my!")
+        (z  '(from the "Wizard of OZ")))
+    (sort-3! x y z datum<?)
+    (for-each displayln (list x y z))))

Task/Sort-three-variables/Raku/sort-three-variables.raku

@@ -0,0 +1,24 @@
+# Sorting strings. Added a vertical bar between strings to make them discernable
+my ($a, $b, $c) = 'lions, tigers, and', 'bears,  oh my!', '(from "The Wizard of Oz")';
+say "sorting: {($a, $b, $c).join('|')}";
+say ($a, $b, $c).sort.join('|'), ' - standard lexical string sort';
+
+# Sorting numeric things
+my ($x, $y, $z) = 7.7444e4, -12, 18/2;
+say "\nsorting: $x $y $z";
+say ($x, $y, $z).sort, ' - standard numeric sort, low to high';
+
+# Or, with a modified comparitor:
+for  -*,       ' - numeric sort high to low',
+     ~*,       ' - lexical "string" sort',
+     *.chars,  ' - sort by string length short to long',
+     -*.chars, ' - or long to short'
+  -> $comparitor, $type {
+    my ($x, $y, $z) = 7.7444e4, -12, 18/2;
+    say ($x, $y, $z).sort( &$comparitor ), $type;
+}
+say '';
+
+# sort ALL THE THINGS
+# sorts by lexical order with numeric values by magnitude.
+.say for ($a, $b, $c, $x, $y, $z).sort;

Task/Sort-three-variables/Red/sort-three-variables.red

@@ -0,0 +1,14 @@
+foreach [x y z] [
+	"lions, tigers, and"
+	"bears, oh my!"
+	{(from the "Wizard of OZ")}
+	77444 -12 0
+	3.1416 3.1415926 3.141592654
+	#"z" #"0" #"A"
+	216.239.36.21 172.67.134.114 127.0.0.1
+	john@doe.org max@min.com cool@bi.net
+	potato carrot cabbage
+][
+	set [x y z] sort reduce [x y z]
+	print ["x:" mold x "y:" mold y "z:" mold z]
+]

Task/Sort-three-variables/Ring/sort-three-variables-1.ring

@@ -0,0 +1,21 @@
+# Project : Sort three variables
+
+x = 'lions, tigers, and'
+y = 'bears, oh my!'
+z = '(from the "Wizard of OZ")'
+sortthree(x,y,z)
+x = 77444
+y = -12
+z = 0
+sortthree(x,y,z)
+
+func sortthree(x,y,z)
+        str = []
+        add(str,x)
+        add(str,y)
+        add(str,z)
+        str = sort(str)
+        see "x = " + str[1] + nl
+        see "y = " + str[2] + nl
+        see "z = " + str[3] + nl
+        see nl

Task/Sort-three-variables/Ring/sort-three-variables-2.ring

@@ -0,0 +1,16 @@
+x = 77444
+y = -12
+z = 0
+sList = sortList(x, y, z)
+see sList + nl
+
+x = 'lions, tigers, and'
+y = 'bears, oh my!'
+z = '(from the "Wizard of OZ")'
+sList = sortList(x, y, z)
+see sList + nl
+
+func sortList (x, y, z)
+     aList = [x, y, z]
+     sList = sort(aList)
+     return sList

Task/Sort-three-variables/Ruby/sort-three-variables.rb

@@ -0,0 +1,9 @@
+x =  'lions, tigers, and'
+y =  'bears, oh my!'
+z =  '(from the "Wizard of OZ")'
+x, y, z = [x, y, z].sort
+puts x, y, z
+
+x, y, z = 7.7444e4, -12, 18/2r # Float, Integer, Rational; taken from Raku
+x, y, z = [x, y, z].sort
+puts x, y, z

Task/Sort-three-variables/Rust/sort-three-variables.rust

@@ -0,0 +1,7 @@
+fn main() {
+    let mut array = [5, 1, 3];
+    array.sort();
+    println!("Sorted: {:?}", array);
+    array.sort_by(|a, b| b.cmp(a));
+    println!("Reverse sorted: {:?}", array);
+}

Task/Sort-three-variables/Seed7/sort-three-variables.seed7

@@ -0,0 +1,29 @@
+$ include "seed7_05.s7i";
+
+const proc: genSort3 (in type: elemType) is func
+  begin
+    global
+
+    const proc: doSort3 (in var elemType: x, in var elemType: y, in var elemType: z) is func
+      local
+        var array elemType: sorted is 0 times elemType.value;
+      begin
+        writeln("BEFORE: x=[" <& x <& "]; y=[" <& y <& "]; z=[" <& z <& "]");
+        sorted := sort([](x, y, z));
+        x := sorted[1];
+        y := sorted[2];
+        z := sorted[3];
+        writeln("AFTER: x=[" <& x <& "]; y=[" <& y <& "]; z=[" <& z <& "]");
+      end func;
+
+    end global;
+  end func;
+
+genSort3(integer);
+genSort3(string);
+
+const proc: main is func
+  begin
+    doSort3(77444, -12, 0);
+    doSort3("lions, tigers, and", "bears, oh my!", "(from the \"Wizard of OZ\")");
+  end func;

Task/Sort-three-variables/SenseTalk/sort-three-variables.sensetalk

@@ -0,0 +1,40 @@
+Set x to "lions, tigers and"
+Set y to "bears, oh my!"
+Set z to "(from the Wizard of Oz)"
+log x
+log y
+log z
+
+set RosettaListAlpha to (x,y,z)
+log RosettaListAlpha
+sort RosettaListAlpha alphabetically
+log RosettaListAlpha
+
+LogSuccess "Alphabetical Sort Successful"
+
+set (x,y,z) to RosettaListAlpha
+log x
+log y
+log z
+
+LogSuccess "Sorted Items back into Original Variables"
+
+Set a to "77444"
+set b to "-12"
+set c to "0"
+set d to "62224"
+
+set RosettaListNum to (a,b,c,d)
+log RosettaListNum
+sort RosettaListNum numerically
+log RosettaListNum
+
+LogSuccess "Numerical Sort Successful"
+
+set (a,b,c,d) to RosettaListNum
+log a
+log b
+log c
+log d
+
+LogSuccess "Sorted Numbers back into Original Variables"

Task/Sort-three-variables/Sidef/sort-three-variables-1.sidef

@@ -0,0 +1,13 @@
+func sort_refs(*arr) {
+    arr.map{ *_ }.sort ~Z arr -> each { *_[1] = _[0] }
+}
+
+var x = 77444
+var y =   -12
+var z =     0
+
+sort_refs(\x, \y, \z)
+
+say x
+say y
+say z

Task/Sort-three-variables/Sidef/sort-three-variables-2.sidef

@@ -0,0 +1,11 @@
+var x = 77444
+var y =   -12
+var z =     0
+
+(x, y) = (y, x) if (x > y)
+(x, z) = (z, x) if (x > z)
+(y, z) = (z, y) if (y > z)
+
+say x
+say y
+say z

Task/Sort-three-variables/Swift/sort-three-variables.swift

@@ -0,0 +1,24 @@
+func varSort<T: Comparable>(_ x: inout T, _ y: inout T, _ z: inout T) {
+  let res = [x, y, z].sorted()
+
+  x = res[0]
+  y = res[1]
+  z = res[2]
+}
+
+var x = "lions, tigers, and"
+var y = "bears, oh my!"
+var z = "(from the \"Wizard of OZ\")"
+
+print("Before:")
+print("x = \(x)")
+print("y = \(y)")
+print("z = \(z)")
+print()
+
+varSort(&x, &y, &z)
+
+print("After:")
+print("x = \(x)")
+print("y = \(y)")
+print("z = \(z)")

Task/Sort-three-variables/TXR/sort-three-variables.txr

@@ -0,0 +1,50 @@
+(defmacro sort-places (. places)
+  (caseql (len places)
+    ((0 1) nil)
+    (2 (with-gensyms (p0 p1)
+         ^(placelet ((p0 (read-once ,[places 0]))
+                     (p1 (read-once ,[places 1])))
+            (if (greater p0 p1)
+              (swap p0 p1)))))
+    (3 (with-gensyms (p0 p1 p2)
+         ^(placelet ((p0 (read-once ,[places 0]))
+                     (p1 (read-once ,[places 1]))
+                     (p2 (read-once ,[places 2])))
+            (if (greater p0 p1)
+              (swap p0 p1))
+            (if (greater p1 p2)
+              (swap p1 p2))
+            (if (greater p0 p1)
+              (swap p0 p1)))))
+    (t (let ((gens [mapcar (ret (gensym)) places]))
+         (with-gensyms (vec)
+           ^(placelet ,(zip gens places)
+              (let ((,vec (vec ,*gens)))
+                (nsort ,vec)
+                (set ,*(append-each ((g gens)
+                                     (i 0))
+                         ^(,g [,vec ,i]))))))))))
+
+(prinl (sort-places))
+
+(let ((x 1))
+  (sort-places x)
+  (prinl x))
+
+(let ((x 2)
+      (y 1))
+  (sort-places x y)
+  (prinl (list x y)))
+
+(let ((a 3)
+      (b 2)
+      (c 1))
+  (sort-places a b c)
+  (prinl (list a b c)))
+
+(let ((a 4)
+      (b 3)
+      (c 2)
+      (d 1))
+  (sort-places a b c d)
+  (prinl (list a b c d)))

Task/Sort-three-variables/Tcl/sort-three-variables.tcl

@@ -0,0 +1,20 @@
+set x {lions, tigers, and}
+set y {bears, oh my!}
+set z {(from the "Wizard of OZ")}
+
+lassign [lsort [list $x $y $z]] x y z
+
+puts "x: $x"
+puts "y: $y"
+puts "z: $z"
+
+
+set x 77444
+set y -12
+set z 0
+
+lassign [lsort [list $x $y $z]] x y z
+
+puts "x: $x"
+puts "y: $y"
+puts "z: $z"

Task/Sort-three-variables/Visual-Basic-.NET/sort-three-variables.vb

@@ -0,0 +1,35 @@
+Module Module1
+
+    Sub Swap(Of T)(ByRef a As T, ByRef b As T)
+        Dim c = a
+        a = b
+        b = c
+    End Sub
+
+    Sub Sort(Of T As IComparable(Of T))(ByRef a As T, ByRef b As T, ByRef c As T)
+        If a.CompareTo(b) > 0 Then
+            Swap(a, b)
+        End If
+        If a.CompareTo(c) > 0 Then
+            Swap(a, c)
+        End If
+        If b.CompareTo(c) > 0 Then
+            Swap(b, c)
+        End If
+    End Sub
+
+    Sub Main()
+        Dim x = 77444
+        Dim y = -12
+        Dim z = 0
+        Sort(x, y, z)
+        Console.WriteLine((x, y, z))
+
+        Dim a = "lions, tigers, and"
+        Dim b = "bears, oh my!"
+        Dim c = "(from the 'Wizard of OZ')"
+        Sort(a, b, c)
+        Console.WriteLine((a, b, c))
+    End Sub
+
+End Module

Task/Sort-three-variables/Wren/sort-three-variables.wren

@@ -0,0 +1,29 @@
+import "/sort" for Sort
+import "/fmt" for Fmt
+
+var sort3 = Fn.new { |x, y, z|
+    var a = [x, y, z]
+    Sort.insertion(a)
+    x = a[0]
+    y = a[1]
+    z = a[2]
+    Fmt.print("  x = $s\n  y = $s\n  z = $s", x, y, z)
+}
+
+System.print("After sorting strings:")
+var x = "lions, tigers, and"
+var y = "bears, oh my!"
+var z = "(from the \"Wizard of OZ\")"
+sort3.call(x, y, z)
+
+System.print("\nAfter sorting integers:")
+x = 77444
+y = -12
+z = 0
+sort3.call(x, y, z)
+
+System.print("\nAfter sorting floats:")
+x = 11.3
+y = -9.7
+z = 11.17
+sort3.call(x, y, z)

Task/Sort-three-variables/Zkl/sort-three-variables.zkl

@@ -0,0 +1,7 @@
+x,y,z := "lions, tigers, and", "bears, oh my!", 0'|(from the "Wizard of OZ")|;
+x,y,z = List(x,y,z).sort();
+println(x," | ",y," | ",z);
+
+x,y,z := 77444, -12, 0;
+x,y,z = List(x,y,z).sort();
+println(x," ",y," ",z);