Sort three variables: Difference between revisions

[[Category:Sorting]]

{{Sorting Algorithm}}

Sort   (the values of)   three variables   ('''X''',   '''Y''',   and   '''Z''')   that contain any value   (numbers and/or literals).

 

 

One algorithm could be:

into an array (or a list)   '''A'''

variables '''x''', '''y''', and '''z'''   in order of extraction

 

Show the results of the sort here on this page using at least the values of those shown above.

<br><br>

 

=={{header|Ada}}==

with Ada.Strings.Unbounded;

 

Test_Unbounded_Sort;

Test_Integer_Sort;

 

{{out}}

 

=={{header|Aime}}==

index i;

text x, y, z;

c = i.if_pick;

 

{{out}}

<pre>(from the "Wizard of OZ")

<br>

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

# MODE that can hold integers and strings - would need to be extended to #

# allow for other types #

sort 3( x, y, z );

print( ( x, newline, y, newline, z, newline ) )

{{out}}

<pre>(from the "Wizard of OZ")

+0

+77444</pre>

 

=={{header|AppleScript}}==

 

set y to "bears, oh my!"

set z to "(from the \"Wizard of OZ\")"

end if

 

 

{{output}}

<pre>{"(from the \"Wizard of OZ\")", "bears, oh my!", "lions, tigers, and"}</pre>

 

set y to -12

set z to 0

end if

 

 

{{output}}

Longer, but more efficiently:

 

set y to "bears, oh my!"

set z to "(from the \"Wizard of OZ\")"

end tell

 

 

=={{header|AutoHotkey}}==

y = bears, oh my!

z = (from the "Wizard of OZ")

SortThreeVariables(x,y,z)

MsgBox % x "`n" y "`n" z

Outputs:<pre>---------------------------

(from the "Wizard of OZ")

77444

---------------------------</pre>

 

=={{header|C}}==

 

===Generic Implementation===

#include<string.h>

#include<stdlib.h>

int main()

{

}

<pre>

Enter 1st value : 77444

</pre>

===Task Specific Implementation===

#include<stdio.h>

 

int main()

{

}

Output :

<pre>Before sorting :

=={{header|C sharp}}==

{{works with|C sharp|7.0}}

public class Program

{

if (b.CompareTo(c) > 0) (b, c) = (c, b);

}

{{out}}

<pre>(-12, 0, 77444)

 

=={{header|C++}}==

#include <string>

#include <vector>

template < class T >

void sort3( T& x, T& y, T& z) {

x = v[0]; y = v[1]; z = v[2];

}

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

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

}

{{out}}

<pre>-12

0

77444

(from the "Wizard of OZ")

bears, oh my!

lions, tigers, and

-9.7

11.17

11.3</pre>

 

=={{header|COBOL}}==

data division.

working-storage section.

stop run

.

{{out}}

<pre>x = (from the "Wizard of OZ")

y = 0

z = 77444</pre>

 

=={{header|D}}==

 

void main() {

swap(y,z);

}

 

{{out}}

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]</pre>

 

=={{header|Elena}}==

sortThree(ref object a, ref object b, ref object c)

console.printLine(x,",",y,",",z);

console.printLine(a,",",b,",",c)

{{out}}

<pre>

 

=={{header|Elixir}}==

y = 'bears, oh my!'

z = '(from the "Wizard of OZ")'

 

[x, y, z] = Enum.sort([x, y, z])

{{out}}

<pre>x = (from the "Wizard of OZ")

 

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

let y = "bears, oh my!"

let z = """(from the "Wizard of OZ")"""

List.iter (printfn "%s") (List.sort [x;y;z])

{{out}}

<pre>(from the "Wizard of OZ")

 

=={{header|Factor}}==

IN: rosetta-code.sort-three

 

sort3 [ print ] tri@

 

{{out}}

<pre>(from the "Wizard of OZ")

0

77444</pre>

 

=={{header|Forth}}==

typically be used directly from the stack by a subsequent operation in the

program.

VARIABLE X VARIABLE Y VARIABLE Z

 

2DUP < IF SWAP THEN ;

 

 

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

==={{header|Strings}}===

Strings require extending the language but the primitives needed are part of ANS/ISO Forth.

: BUFFER: ( n -- ) CREATE ALLOT ;

 

\ non-destructive print 3 counted-strings from data stack

: .STRS ( caddr1 caddr2 caddr3 -- caddr1 caddr2 caddr3) \ order is dependant

With these extensions we can do the same testing at the Forth console and

examine the string order with '.STRS'.

There would be similar requirements for a SWAP routine for each type of parameter, for alas, Fortran does not define a SWAP statement. The temporary variable needed for the SWAP process is defined rather intimidatingly as having the size of the largest of the three parameters; prior to F90 variables defined in a routine could only have a size defined at compile time, which would have to be "surely big enough". Rather than have this redefined for each invocation of SWAPC (where it would be the larger of the two parameters) it is defined once in SORT3. However, all three parameters should be the same size, or risk truncation. Using a great deal more syntax (or, as standardised in F2003) it is possible to have character variables be resized on each assignment to them to accommodate the length of text being assigned.

 

INTEGER TYPEIS

INTEGER VI

...etc...

END TYPE MONGREL

So that DOG.TYPEIS would indicate which component to access. Still further ploys would enable storage to be allocated only for the type currently in use, especially for CHARACTER variables, and via a great deal more syntax defining how to perform operations such as .GT. and the like, MONGREL type variables can be used in expressions involving such operators just as can variables of the basic types. This sort of approach is demonstrated in [[Arithmetic/Rational#Fortran]], but otherwise, every reference to a MONGREL will involve some sort of CASE statement to select the appropriate usage, hopefully of related types only. Serious computation with such MONGREL variables surely will not be speedy and thus would be un-Fortrannish. What to do when a text string meets a complex number remains obscure - convert the number to a text (but, what format?), does the text represent a number? And what type results from such miscegnation?

 

Routines that modify their parameters should not be invoked with constants (or text literals) as such parameters... Some systems allow constants to be in protected storage, and if so, an attempt to modify such storage will produce a run-time error. Otherwise, it all depends on how constants are passed as parameters. If a temporary storage item is loaded with the desired value and the address of that scratch variable is passed, then disaster will be averted - though good results may not be produced.

 

 

PROGRAM POKE

 

 

Output: the texts showing numbers appear in text order, not the order of their numbers. Incidentally, not everything is done in ASCII. The EBCDIC ordering is different.

<pre> Supplied: >lions, tigers, and < >bears, oh my! < >(from the "Wizard of OZ") <

Supplied: >77444 < > -12 < > 0 <

Sorted, ? > 0 < > -12 < >77444 <</pre>

 

=={{header|Go}}==

There are ways of doing this task in a generic way in Go but they are a bit cumbersome and it would not be idiomatic. Shown here then are solutions coded specifically to the string and integer types of the task test cases. Solutions would be very similar for any of the other comparable Go types such as float64.

 

import (

}

}

{{out}}

<pre>sorted strings:

Although mutation is not on the menu, parameterised types do allow us to define polymorphic functions which can, for example, be applied both to lists of strings and also to lists of integers or lists of floats. The following functions work with triples of any type for which the '''<=''' or '''compare''' functions are defined – in other words, any type for which an instance of the Ord class is defined.

 

 

sortedTriple

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

print $ sortedTriple (77444, -12, 0)

{{Out}}

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

 

=={{header|IS-BASIC}}==

110 PRINT X;Y;Z

120 CALL SHORT(X,Y,Z)

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

{{out}}

<pre> 77444 -12 0

=={{header|J}}==

Note that this is extremely bad form, and you will stumble over why it is bad form if you try using it in any useful implementation:

y =: 'bears, oh my!'

z =: '(from the "Wizard of OZ")'

0

z

 

=={{header|Java}}==

import java.util.Comparator;

import java.util.stream.Stream;

}

}

{{out}}

<pre>Sorted values: 11 21 82

 

=={{header|JavaScript}}==

console.log(`${note}

${a} is: ${a1}

};

sortThree();

{{out}}

<pre>Before Sorting

The sorting function defined here is completely generic with respect to the number of variables and the types of their values. For brevity, however, we will only use the required examples.

 

{x: "lions, tigers, and",

y: "bears, oh my",

y: -12,

z: 0

 

The following sorting function will accept an arbitrary JSON object:

keys_unsorted as $keys

| ([.[]] | sort) as $values

 

Examples:

{{out}}

<pre>{

}

</pre>

{{out}}<pre>

{

 

=={{header|Jsish}}==

/* Sort three variables, in Jsish. semi-colon start/end for unit test echo */

 

z ==> 1 string

=!EXPECTEND!=

 

{{out}}

 

=={{header|Julia}}==

 

a, b, c = "lions, tigers, and", "bears, oh my!", "(from the \"Wizard of OZ\")"

a, b, c = 77444, -12, 0

a, b, c = sort([a, b, c])

 

{{out}}

=={{header|Kotlin}}==

Kotlin's standard library contains a sort() function which can sort any generic array whose element type has a defined ordering between its instances. This includes strings, integers and floats examples of which are shown below:

 

inline fun <reified T : Comparable<T>> sortThree(x: T, y: T, z: T): Triple<T, T, T> {

z3 = t3.third

printThree(x3, y3, z3)

 

{{out}}

y = 41.7

z = 174.5</pre>

 

=={{header|Lua}}==

Essentially the same as the example algorithm except that the function is variadic. Sorting is done by the in-built table.sort and copying the unknown number of variables in and out of the table is made simple by the (...) in the parameter list and the unpack function respectively.

local t = {}

for _, x in pairs{...} do

print("\ty = " .. y)

print("\tz = " .. z)

{{out}}

<pre>Case 1

Modules and Functions have a special list, where included at definition time, end excluded when parent exit.

 

Module Sort3 {

Let X=77744, Y=-12, Z=0

}

Sort3

 

=={{header|Maple}}==

{{Out|Example}}

x := 'lions, tigers, and':

77444</pre>

 

All variables in Mathematica are typeless so the follow code works in all cases

 

=={{header|min}}==

{{works with|min|0.19.3}}

The <code>sort3</code> operator updates the values of the variables given to it in the calling scope, much like passing by reference. A small drawback is that we must quote the symbols passed in, lest we lose access to them.

 

"lions, tigers, and" :x

x puts!

y puts!

{{out}}

<pre>

=={{header|Modula-2}}==

{{Output?}}

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

 

ReadChar;

 

=={{header|Nanoquery}}==

 

// sorting string literals

y = varlist[1]

z = varlist[2]

{{out}}

<pre>(from the "Wizard of OZ")

0

77444</pre>

 

=={{header|OCaml}}==

let sorted = List.map ( ! ) list

|> List.sort (fun a b ->

printf "\tx: %d\n" !x;

printf "\ty: %d\n" !y;

 

{{out}}

<pre># test ();;

case 1:

case 1:

- : unit = ()</pre>

 

=={{header|Perl}}==

{{works with|Perl|5.10+}}

 

use 5.010_000;

 

say " x = $x";

say " y = $y";

 

{{out}}

=={{header|Phix}}==

Phix is naturally polymorphic

{{out}}

<pre>{"lions, tigers, and","bears, oh my","(from the \"Wizard of OZ\")"}

 

=={{header|PHP}}==

//Sort strings

$x = 'lions, tigers, and';

EOT;

 

 

{{out}}

 

=={{header|PicoLisp}}==

(println X Y Z)

(mapc set '(X Y Z) (sort (list X Y Z)))

{{out}}

<pre>77444 -12 0

-12 0 77444</pre>

 

=={{header|PureBasic}}==

 

;Macro handles any of the native types, including integers, floating point, and strings

Print(#CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

Sample output:

<pre>Sort three variables

===Python2===

This solution accepts 3 values either strings or numbers from user and then sort it in ascending order. This is implemented in Python 2.

#python2 Code for Sorting 3 values

a= raw_input("Enter values one by one ..\n1.").strip()

b,c = c,b

print(str(a)+" "+str(b)+" "+str(c))

 

===Python3===

The following uses Python3.6 f-strings and uses the built in sorted function and assignment to a target list.

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

 

{{out}}

 

Three Python values:</pre>

 

=={{header|R}}==

 

#lang R

 

assignVec <- Vectorize("assign", c("x", "value"))

`%<<-%` <- function(x, value) invisible(assignVec(x, value, envir = .GlobalEnv)) # define multiple global assignments operator

 

{{out}}

 

x <- 'lions, tigers, and'

y <- 'bears, oh my!'

z

## [1] 77444

 

=={{header|Racket}}==

Ugh... mutation. Anyway...

 

 

(define-syntax-rule (sort-3! x y z <?)

(z '(from the "Wizard of OZ")))

(sort-3! x y z datum<?)

 

{{out}}

The list (77444, -12, 0) is a poor choice to demonstrate numeric sort since it will sort the same numerically or lexically. Instead we'll use (7.7444e4, -12, 18/2). ( A Num, an Int, and a Rat. )

 

my ($a, $b, $c) = 'lions, tigers, and', 'bears, oh my!', '(from "The Wizard of Oz")';

say "sorting: {($a, $b, $c).join('|')}";

# sort ALL THE THINGS

# sorts by lexical order with numeric values by magnitude.

 

{{out}}

bears, oh my!

lions, tigers, and</pre>

 

=={{header|REXX}}==

 

The literals can be of any length &nbsp; (only limited by virtual memory or language limitations).

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*/

say '═════ sorted value of X: ' x

say '═════ sorted value of Y: ' y

{{out|output|text=when using the default inputs:}}

<pre>

 

The maximum integer than be kept &nbsp; ''as an integer'' &nbsp; is &nbsp; (in this program) &nbsp; is 1,000 decimal digits.

numeric digits 1000 /*handle some pretty gihugic integers. */ /*can be bigger.*/

parse arg x y z . /*obtain the three variables from C.L. */

y= low + mid + high - x - z /* " " middle " " " " " */ /* ◄─── sorting.*/

/*stick a fork in it, we're all done. */

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ring}}==

 

x = 'lions, tigers, and'

see "z = " + str[3] + nl

see nl

Output:

<pre>x = (from the "Wizard of OZ")

y = 0

z = 77444</pre> =={{header|Ring}}==

y = -12

z = 0

sList = sort(aList)

return sList

Output:

<pre>-12

lions, tigers, and</pre>

 

 

=={{header|Ruby}}==

y = 'bears, oh my!'

z = '(from the "Wizard of OZ")'

puts x, y, z

 

x, y, z = [x, y, z].sort

puts x, y, z

{{Out}}

<pre>(from the "Wizard of OZ")

9/1

77444.0</pre>

 

=={{header|Seed7}}==

 

 

const proc: genSort3 (in type: elemType) is func

doSort3(77444, -12, 0);

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

 

{{out}}

=={{header|SenseTalk}}==

 

Set y to "bears, oh my!"

Set z to "(from the Wizard of Oz)"

log d

 

 

=={{header|Sidef}}==

Generalized solution, for an arbitrary number of variable references:

arr.map{ *_ }.sort ~Z arr -> each { *_[1] = _[0] }

}

say x

say y

{{out}}

<pre>-12

77444</pre>

Alternatively, without using a sorting function:

var y = -12

var z = 0

say x

say y

{{out}}

<pre>-12

=={{header|Swift}}==

 

let res = [x, y, z].sorted()

 

print("x = \(x)")

print("y = \(y)")

 

{{out}}

 

=={{header|Tcl}}==

set x {lions, tigers, and}

set y {bears, oh my!}

puts "y: $y"

puts "z: $z"

{{out}}

<pre>

z: 77444

</pre>

 

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Sub Swap(Of T)(ByRef a As T, ByRef b As T)

End Sub

 

{{out}}

<pre>(-12, 0, 77444)

((from the 'Wizard of OZ'), bears, oh my!, lions, tigers, and)</pre>

 

=={{header|zkl}}==

This solution uses list assignment and list sorting. Lists are not homogeneous, but sorting usually expects that. If that is a problem, you can give the sort a compare function. Numbers (real and integer) are homogeneous enough to sort.

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

{{out}}

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