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'

For numeric value sorting, use: I.E.: (for the three variables '''x''', '''y''', and '''z'''), 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. Note any limitations.

The values may or may not be unique.

The method used for sorting can be any algorithm; 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:

Θ  store the three variables   '''x''', '''y''', and '''z'''
      into an array (or a list)   '''A'''

Θ  sort  (the three elements of)  the array   '''A'''

Θ  extract the three elements from the array and place them in the
      variables '''x''', '''y''', and '''z'''   in order of extraction

Another algorithm (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.

Aime

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);

Output:

(from the "Wizard of OZ")
bears, oh my!
lions, tigers, and
-12
0
77444

ALGOL 68

This uses Algol 68's UNION facility which allows a variable to have values of a number of types whilst maintaining Algol 68's strong-typing.

Assignment allows any value of one of the UNION MODEs to be directly assigned to the variable. When using the variable, its MODE (type) and value must be tested and extracted using a CASE construct.

As the task only requires sorting three values, we use a simple, three-element specific sort routine.

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

Output:

(from the "Wizard of OZ")
bears, oh my!
lions, tigers, and
        -12
         +0
     +77444

AutoHotkey

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
}

Examples:

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

Outputs:

---------------------------
(from the "Wizard of OZ")
bears, oh my!
lions, tigers, and
---------------------------
-12
0
77444
---------------------------

C

Although C does not have a generic catch-all variable type, strings or arrays of characters can be used ( or misused ) to simulate the effect. Strings are often used to process arbitrarily large or small numbers which can't be represented by the C Standard Library. Strings are thus used for this task to accept whatever the user enters. Each entry is treated as a string and is scanned. If any one of them contains a single 'non-number' character, then the whole set is treated as a set of strings.

The first implementation is generic and can be used for any entries ( integer, floating point, strings). The second one is specific to the task and only sorts integers.

Generic Implementation

#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;
}

The output shows three test cases, two as specified in the task, and one which mixes numbers and strings. The output is sorted considering all of them as strings in that case.

Enter 1st value : 77444
Enter 2nd value : -12
Enter 3rd value : 0
X = -12
Y = 0
Z = 77444

Enter 1st value : lions, tigers, and
Enter 2nd value : bears, oh my!
Enter 3rd value : (from the "Wizard of OZ")
X = (from the "Wizard of OZ")
Y = bears, oh my!
Z = lions, tigers, and

Enter 1st value : -12
Enter 2nd value : bears, oh my!
Enter 3rd value : 77444
X = -12
Y = 77444
Z = bears, oh my!

Task Specific Implementation

#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;
}

Output :

Before sorting :
x = 77444
y = -12
z = 0
After sorting :
x = -12
y = 0
z = 77444

C#

Works with C sharp|7.0

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);
    }
}

Output:

(-12, 0, 77444)
((from the 'Wizard of OZ'), bears, oh my!, lions, tigers, and)

C++

#include <iostream>
#include <string>
#include <vector>

template < class T >
void sort3( T& x, T& y, T& z) {
    std::vector<T> v;
    v.push_back( x ); v.push_back( y ); v.push_back( z );
    bool b = true;
    while( b ) {
        b = false;
        for( size_t i = 0; i < v.size() - 1; i++ ) {
            if( v[i] > v[i+1] ) {
                T t = v[i];
                v[i] = v[i + 1];
                v[i + 1] = t;
                b = true;
            }
        }
    }
    x = v[0]; y = v[1]; z = v[2];
}
int main(int argc, char* argv[]) {
    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";

    return 0;
}

Output:

-12
0
77444
(from the "Wizard of OZ")
bears, oh my!
lions, tigers, and
-9.7
11.17
11.3

COBOL

       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.

Output:

x = (from the "Wizard of OZ")
y = bears, oh my!
z = lions, tigers, and

x =      -12
y =        0
z =    77444

D

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);
    }
}

Output:

BEFORE: x=[77444]; y=[-12]; z=[0]
AFTER: x=[-12]; y=[0]; z=[77444]
BEFORE: x=[lions, tigers, and]; y=[bears, oh my!]; z=[(from the "Wizard of OZ")]
AFTER: x=[(from the "Wizard of OZ")]; y=[bears, oh my!]; z=[lions, tigers, and]

Elena

ELENA 4.1 :

import system'routines;
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)
}

Output:

1,2,5
(from the 'Wizard of OZ'),bears, oh my!,lions, tigers, and

Elixir

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}"

Output:

x = (from the "Wizard of OZ")
y = bears, oh my!
z = lions, tigers, and

x = -12
y = 0
z = 77444

=={{header|F_Sharp|F#}}==

 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])

Output:

(from the "Wizard of OZ")
bears, oh my!
lions, tigers, and

Factor

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@

Output:

(from the "Wizard of OZ")
bears, oh my!
lions, tigers, and
-12
0
77444

Forth

=

Integers

= In GNU Forth the machine's integers are the default data type. It is straightforward to sort these on the Forth Data Stack.
Note: Assigning the values to variables is simple however unless storage in variables was needed to retain the values, they would typically be used directly from the stack by a subsequent operation in the program. \ sort 3 integers VARIABLE X VARIABLE Y VARIABLE Z

: VARS@ ( --- n n n) X @ Y @ Z @ ; \ read variables : VARS! ( n n n -- ) Z ! Y ! X ! ; \ store variables

: ?SWAP ( a b -- a b) \ conditional swap 2DUP < IF SWAP THEN ;

: SORT3INTS ( a b c -- c b a) ?SWAP >R ?SWAP R> ?SWAP ;

Testing is done using the Forth console using '?' to view VARIABLE contents

```txt
 ok
77000 -12 0 VARS!  ok
X ? 77000  ok
Y ? -12  ok
Z ? 0  ok
VARS@ SORT3INTS VARS!  ok
X ? 77000  ok
Y ? 0  ok
Z ? -12  ok</PRE>

=
## Strings
=
Strings require extending the language but the primitives needed are part of ANS/ISO Forth.
<LANG>DECIMAL
: BUFFER: ( n -- ) CREATE ALLOT ;

64 BUFFER: X
64 BUFFER: Y
64 BUFFER: Z

: S'  ( <text> )  [CHAR] ' PARSE ;

S' (from the "Wizard of OZ")' X PLACE
S' bears, oh my!'             Y PLACE
S' lions, tigers, and'        Z PLACE

\ counted string compare less than
: <S        ( caddr caddr -- caddr caddr flag)
            COUNT ROT COUNT COMPARE 1 = ;

: ?SWAPSTR  ( caddr caddr -- caddr caddr)  \ conditional string swap
             2DUP <S IF SWAP THEN ;

\ sort on stack as done for integers
: SORT3STRINGS   ?SWAPSTR >R  ?SWAPSTR R> ?SWAPSTR ;

\ non-destructive print 3 counted-strings from data stack
: .STRS  ( caddr1 caddr2 caddr3 -- caddr1 caddr2 caddr3) \ order is dependant
           3 0 DO ROT  DUP CR COUNT TYPE  LOOP ;

With these extensions we can do the same testing at the Forth console and examine the string order with '.STRS'.

 ok
X Y Z  ok
.S <3> 2142061672 2142061760 2142061848  ok
.STRS
(from the "Wizard of OZ")
bears, oh my!
lions, tigers, and ok
SORT3STRINGS  ok
.S <3> 2142061848 2142061760 2142061672  ok
.STRS
lions, tigers, and
bears, oh my!
(from the "Wizard of OZ") ok