Sort three variables: Difference between revisions

 

=={{header|11l}}==

V y = -12

V z = 0

V zs = ‘(from the "Wizard of OZ")’

(xs, ys, zs) = sorted([xs, ys, zs])

 

{{out}}

lions, tigers, and

</pre>

 

=={{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|APL}}==

Works in [[Dyalog APL]]. Assumes x,y,z are already defined.

 

 

Uses destructuring assignment syntax.

=={{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|Arturo}}==

y: {bears, oh my!}

z: {(from the "Wizard of OZ")}

z: pi

 

 

{{out}}

 

=={{header|AutoHotkey}}==

obj := []

for k, v in (var := StrSplit("x,y,z", ","))

for k, v in obj

temp := var[A_Index], %temp% := k

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

all one would need to do is define a third comparator.

 

 

// Sort 3 variables using a comparator.

writes("Y = ") ; printfn(y) ; wrch('*N')

writes("Z = ") ; printfn(z) ; wrch('*N')

{{out}}

<pre>X = 7444

 

===Generic Implementation===

#include<string.h>

#include<stdlib.h>

return 0;

}

<pre>

Enter 1st value : 77444

</pre>

===Task Specific Implementation===

#include<stdio.h>

 

return 0;

}

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

#include <string>

std::cout << xf << "\n" << yf << "\n" << zf << "\n\n";

}

{{out}}

<pre>-12

 

=={{header|CLU}}==

% The variables must all be of the same type, and the type

% must implement the less-than comparator.

example[string] ("lions, tigers and", "bears, oh my!",

"(from the \"Wizard of Oz\")", fmt_str)

{{out}}

<pre>x=77444 y=-12 z=0

 

=={{header|COBOL}}==

data division.

working-storage section.

stop run

.

{{out}}

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

=={{header|Cowgol}}==

 

 

# Sort 3 values

 

# Print 3 values after sorting

 

{{out}}

 

=={{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|FreeBASIC}}==

Shows the use of macros, which are type-agnostic (though you cannot mix string and numerical types).

if x>y then swap x, y

if y>z then swap y, z

print a

print b

{{out}}<pre>(from the "Wizard of OZ")

bears, oh my!

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.

 

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.

END DO !On to the next example.

END !Nothing much.

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

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Free Pascal}}==

The FPC (FreePascal Compiler) adopted Delphi’s generics scheme.

It works in the <tt>{$mode objFPC}</tt> and <tt>{$mode Delphi}</tt> compiler compatibility modes, the former requiring the keywords <tt>generic</tt>/<tt>specialize</tt>.

 

generic procedure sort<T>(var X, Y: T);

specialize sort<real>(P, Q, R);

specialize print<real>(P, Q, R)

{{out}}

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

Y = 9.0099999999999998E+000

Z = 1.2340000000000000E+001</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}}

 

=={{header|Ksh}}==

#!/bin/ksh

 

_arraysort arrayl

_outofarray x y z arrayl

{{out}}<pre>

Numeric Variables:

=={{header|Little Man Computer}}==

The LMC in its original form supports only integers in the range 0..999. So the numbers in the task have been changed here from 77444, -12, 0 to 774, 0, 12.

// Little Man Computer

// Sort x, y, z, in ascending order

t DAT

// end

{{out}}

<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':

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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

example:

y = -12;

z = 0;

{x, y, z} = Sort[{x, y, z}];

{{out}}

<pre>{-12, 0, 77444}</pre>

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

 

=={{header|Nim}}==

# Bubble sort, why not?

while not (a <= b and b <= c):

testWith(6, 4, 2)

testWith(0.9, -37.1, 4.0)

 

{{out}}

 

=={{header|OCaml}}==

let sorted = List.map ( ! ) list

|> List.sort (fun a b ->

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

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

 

{{out}}

The data types of all variables and routine parameters need to be known in advance.

The following <tt>program</tt> demonstrates sorting three strings, but can be easily adapted to work for <tt>integer</tt> and <tt>real</tt> variables as well.

 

type

procedure printThreeLines(protected X, Y, Z: line);

begin

writeLn('X = ', X);

writeLn('Y = ', Y);

sortThreeLines(A, B, C);

printThreeLines(A, B, C)

 

=={{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

=={{header|Plain English}}==

This will sort integers only.

Start up.

Sort three numbers.

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.

{{out}}

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

(QACSFOT is the Quackery Arbitrary Character Sequence For Ordered Text, which is <code>0123456789AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz()[]{}<>~=+-*/^\|_.,:;?!'"`%@&#$</code>. Note that, unlike the even more arbitrary ASCII/Unicode character sequence, all the punctuation marks come after all the alphabetic characters, so the result of sorting the strings will vary from the result given in the task description.)

 

[ stack ] is y

[ stack ] is z

say " x = " x take echo cr

say " y = " y take echo cr

 

{{out}}

=={{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}}

=={{header|Red}}==

Red can natively sort values of various types. For instance here (not exhaustive): strings, integers, floats, characters, IP addresses, email addresses, words (~ variable names).

"lions, tigers, and"

"bears, oh my!"

set [x y z] sort reduce [x y z]

print ["x:" mold x "y:" mold y "z:" mold z]

{{out}}

<pre>x: {(from the "Wizard of OZ")} y: "bears, oh my!" z: "lions, tigers, and"

 

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

bears, oh my!

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

 

=={{header|Rust}}==

let mut array = [5, 1, 3];

array.sort();

println!("Reverse sorted: {:?}", array);

}

 

==Scala==

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

{{libheader|Wren-sort}}

{{libheader|Wren-fmt}}

 

var sort3 = Fn.new { |x, y, z|

y = -9.7

z = 11.17

 

{{out}}

=={{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