# Sort an integer array

Sort an integer array
You are encouraged to solve this task according to the task description, using any language you may know.

Sort an array (or list) of integers in ascending numerical order.

Use a sorting facility provided by the language/library if possible.

## 4D

### English

`ARRAY INTEGER(\$nums;0)APPEND TO ARRAY(\$nums;2)APPEND TO ARRAY(\$nums;4)APPEND TO ARRAY(\$nums;3)APPEND TO ARRAY(\$nums;1)APPEND TO ARRAY(\$nums;2)SORT ARRAY(\$nums)  ` sort in ascending orderSORT ARRAY(\$nums;<)  ` sort in descending order`

### Français

`TABLEAU ENTIER(\$nombres;0)AJOUTER A TABLEAU(\$nombres;2)AJOUTER A TABLEAU(\$nombres;4)AJOUTER A TABLEAU(\$nombres;3)AJOUTER A TABLEAU(\$nombres;1)AJOUTER A TABLEAU(\$nombres;2)TRIER TABLEAU(\$nombres)  ` pour effectuer un tri par ordre croissantTRIER TABLEAU(\$nombres;<)  ` pour effectuer un tri par ordre décroissant`

## 8th

` [ 10,2,100 ] ' n:cmp a:sort . cr `

Output is: [2,10,100]

## ActionScript

`//Comparison function must returns Numbers even though it deals with integers.function compare(x:int, y:int):Number{	return Number(x-y);}var nums:Vector.<int> = Vector.<int>([5,12,3,612,31,523,1,234,2]);nums.sort(compare);`

Works with: GNAT version GPL 2006
`with Gnat.Heap_Sort_G; procedure Integer_Sort is   -- Heap sort package requires data to be in index values starting at   -- 1 while index value 0 is used as temporary storage   type Int_Array is array(Natural range <>) of Integer;   Values : Int_Array := (0,1,8,2,7,3,6,4,5);    -- define move and less than subprograms for use by the heap sort package   procedure Move_Int(From : Natural; To : Natural) is   begin      Values(To) := Values(From);   end Move_Int;    function Lt_Int(Left, Right : Natural) return Boolean is   begin      return Values(Left) < Values (Right);   end Lt_Int;    -- Instantiate the generic heap sort package   package Heap_Sort is new Gnat.Heap_Sort_G(Move_Int, Lt_Int); begin   Heap_Sort.Sort(8);end Integer_Sort; requires an Ada05 compiler, e.g GNAT GPL 2007with Ada.Containers.Generic_Array_Sort; procedure Integer_Sort is   --    type Int_Array is array(Natural range <>) of Integer;   Values : Int_Array := (0,1,8,2,7,3,6,4,5);    -- Instantiate the generic sort package from the standard Ada library   procedure Sort is new Ada.Containers.Generic_Array_Sort     (Index_Type   => Natural,      Element_Type => Integer,      Array_Type   => Int_Array); begin   Sort(Values);end Integer_Sort;`

## ALGOL 68

Translation of: python
Works with: ALGOL 68 version Standard - no extensions to language used
Works with: ALGOL 68G version Any - tested with release mk15-0.8b.fc9.i386
Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386
`CO PR READ "shell_sort.a68" PR COMODE TYPE = INT; PROC in place shell sort = (REF[]TYPE seq)REF[]TYPE:(    INT inc := ( UPB seq + LWB seq + 1 ) OVER 2;    WHILE inc NE 0 DO        FOR index FROM LWB seq TO UPB seq DO            INT i := index;            TYPE el = seq[i];            WHILE ( i  - LWB seq >= inc | seq[i - inc] > el | FALSE ) DO                seq[i] := seq[i - inc];                i -:= inc            OD;            seq[i] := el        OD;        inc := IF inc = 2 THEN 1 ELSE ENTIER(inc * 5 / 11) FI    OD;      seq  );     PROC shell sort = ([]TYPE seq)[]TYPE:  in place shell sort(LOC[LWB seq: UPB seq]TYPE:=seq); print((shell sort((2, 4, 3, 1, 2)), new line))`

Output:

```         +1         +2         +2         +3         +4
```

## APL

Works with: APL2
`      X←63 92 51 92 39 15 43 89 36 69      X[⍋X]15 36 39 43 51 63 69 89 92 92`

## AppleScript

AppleScript has no native sort function.

Later versions of AppleScript (OS X 10.10 onwards) do allow access to the ObjC NSArray library, but while this approach can yield reasonably fast sorts, it is slow in terms of scripter time, requiring digestion of the ObjC library documentation, and leading to code like the sort function below, which is possibly more messy than it is worth for the purposes of casual end-user scripting, for which AppleScript was presumably designed.

`use framework "Foundation" -- sort :: [a] -> [a]on sort(lst)    ((current application's NSArray's arrayWithArray:lst)'s ¬        sortedArrayUsingSelector:"compare:") as listend sort -- TEST -----------------------------------------------------------------------on run     map(sort, [[9, 1, 8, 2, 8, 3, 7, 0, 4, 6, 5], ¬        ["alpha", "beta", "gamma", "delta", "epsilon", "zeta", "eta", ¬            "theta", "iota", "kappa", "lambda", "mu"]]) end run  -- GENERIC FUNCTIONS  --------------------------------------------------------- -- map :: (a -> b) -> [a] -> [b]on map(f, xs)    tell mReturn(f)        set lng to length of xs        set lst to {}        repeat with i from 1 to lng            set end of lst to |λ|(item i of xs, i, xs)        end repeat        return lst    end tellend map -- Lift 2nd class handler function into 1st class script wrapper -- mReturn :: Handler -> Scripton mReturn(f)    if class of f is script then        f    else        script            property |λ| : f        end script    end ifend mReturn`
Output:
```{{0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9},
{"alpha", "beta", "delta", "epsilon", "eta", "gamma",
"iota", "kappa", "lambda", "mu", "theta", "zeta"}}```

## AutoHotkey

`numbers = 5 4 1 2 3sort, numbers, N D%A_Space%Msgbox % numbers`

## AWK

` # syntax: GAWK -f SORT_AN_INTEGER_ARRAY.AWKBEGIN {    split("9,10,3,1234,99,1,200,2,0,-2",arr,",")    show("@unsorted","unsorted")    show("@val_num_asc","sorted ascending")    show("@val_num_desc","sorted descending")    exit(0)}function show(sequence,description,  i) {    PROCINFO["sorted_in"] = sequence    for (i in arr) {      printf("%s ",arr[i])    }    printf("\t%s\n",description)} `

output:

```9 10 3 1234 99 1 200 2 0 -2     unsorted
-2 0 1 2 3 9 10 99 200 1234     sorted ascending
1234 200 99 10 9 3 2 1 0 -2     sorted descending
```

## Axe

There is no ascending sort function in Axe, but there is a descending sort function. One can either implement a custom ascending sorting function or simply reverse the output from SortD.

`2→{L₁}4→{L₁+1}3→{L₁+2}1→{L₁+3}2→{L₁+4} SortD(L₁,5)`

## Babel

Use the sortval operator to sort an array of integers (val-array in Babel terminology). The following code creates a list of random values, converts it to a val-array, sorts that val-array, then converts it back to a list for display using the lsnum utility.

`babel> nil { zap {1 randlf 100 rem} 20 times collect ! } nest dup lsnum ! --> Create a list of random numbers( 20 47 69 71 18 10 92 9 56 68 71 92 45 92 12 7 59 55 54 24 )babel> ls2lf                                                              --> Convert list to array for sortingbabel> dup {fnord} merge_sort                                             --> The internal sort operatorbabel> ar2ls lsnum !                                                      --> Display the results( 7 9 10 12 18 20 24 45 47 54 55 56 59 68 69 71 71 92 92 92 )`

In Babel, lists and arrays are distinct. If you want to sort a list, use the lssort utility:

`babel> ( 68 73 63 83 54 67 46 53 88 86 49 75 89 83 28 9 34 21 20 90 )babel> {lt?} lssort ! lsnum !( 9 20 21 28 34 46 49 53 54 63 67 68 73 75 83 83 86 88 89 90 )`

To reverse the sort-order, use the 'gt?' predicate instead of the 'lt?' predicate:

`babel> ( 68 73 63 83 54 67 46 53 88 86 49 75 89 83 28 9 34 21 20 90 ) {gt?} lssort ! lsnum !( 90 89 88 86 83 83 75 73 68 67 63 54 53 49 46 34 28 21 20 9 )`

## BaCon

`' Sort an integer arrayDECLARE values[5] TYPE NUMBERvalues[0] = 23values[1] = 32values[2] = 12values[3] = 21values[4] = 01 SORT values FOR i = 0 TO 3    PRINT values[i], ", ";NEXTPRINT values[4]`
Output:
```prompt\$ ./sort-integer
1, 12, 21, 23, 32```

Use SORT array DOWN for descending sort order.

## BBC BASIC

Uses the supplied SORTLIB library.

`      INSTALL @lib\$+"SORTLIB"      sort% = FN_sortinit(0,0)       DIM array(8)      array() = 8, 2, 5, 9, 1, 3, 6, 7, 4       C% = DIM(array(),1) + 1      CALL sort%, array(0)       FOR i% = 0 TO DIM(array(),1) - 1        PRINT ; array(i%) ", ";      NEXT      PRINT ; array(i%)`

Output:

```1, 2, 3, 4, 5, 6, 7, 8, 9
```

## Befunge

Works with: befungee

Elements of the array are read from standard input, preceded by their quantity. The algorithm uses counting sort and allows numbers between 1 and 60, inclusive.

`v > 543** >     :#v_ \$&>           :#v_ 1 > :0g >    :#v_ \$ 1+: 543** `! #v_ 25*,@        ^-1p0\0:<    ^-1 p0\+1 g0:&<          ^-1\.:\<                                        ^                               <`

## Bracmat

As a Computer Algebra system, Bracmat transforms expressions to a canonical form. Terms in a sum are sorted and, where possible, added together. So the task is partially solved by expressing the list as a sum of terms. Evaluating the list sorts the list, but also adds like terms. To illustrate, this is what happens when entering our list at the prompt:

```{?} (9.)+(-2.)+(1.)+(2.)+(8.)+(0.)+(1.)+(2.)
{!} (-2.)+(0.)+2*(1.)+2*(2.)+(8.)+(9.)```

The use of a computationally inert operator like the dot `.` is essential:

```{?} (9)+(-2)+(1)+(2)+(8)+(0)+(1)+(2)
{!} 21```

To complete the task need to unfold the terms with a numerical factor >1:

`{sort takes a list of space-separated integers}(sort=  sum elem sorted n.   0:?sum  &   whl    ' (!arg:%?elem ?arg&(!elem.)+!sum:?sum)  & :?sorted  &   whl    ' ( !sum:?n*(?elem.)+?sum      &   whl        ' ( !n+-1:~<0:?n          & !sorted !elem:?sorted          )      )  & !sorted);   out\$sort\$(9 -2 1 2 8 0 1 2);`

Output:

`-2 0 1 1 2 2 8 9`

This solution becomes very ineffective for long lists. To add a single term to an already sorted sum of N terms requires on average N/2 steps. It is much more efficient to merge two already sorted sums of about equal length. Also, adding elements to the end of the list 'sorted' is costly. Better is to prepend elements to a list, which will have inverted sorting order, and to invert this list in an extra loop.

## Burlesque

`{1 3 2 5 4}><`

## C

`#include <stdlib.h>  /* qsort() */#include <stdio.h>   /* printf() */ int intcmp(const void *aa, const void *bb){    const int *a = aa, *b = bb;    return (*a < *b) ? -1 : (*a > *b);} int main(){    int nums[5] = {2,4,3,1,2};    qsort(nums, 5, sizeof(int), intcmp);    printf("result: %d %d %d %d %d\n",      nums[0], nums[1], nums[2], nums[3], nums[4]);    return 0;}`

Caution: An older version of intcmp() did return *a - *b. This is only correct when the subtraction does not overflow. Suppose that *a = 2000000000 and *b = -2000000000 on a machine with 32-bit int. The subtraction *a - *b would overflow to -294967296, and intcmp() would believe *a < *b, but the correct answer is *a > *b.

## C++

Works with: g++ version 4.0.1

### Simple Array

`#include <algorithm> int main(){    int nums[] = {2,4,3,1,2};    std::sort(nums, nums+sizeof(nums)/sizeof(int));    return 0;}`

### std::vector

`#include <algorithm>#include <vector> int main(){    std::vector<int> nums;    nums.push_back(2);    nums.push_back(4);    nums.push_back(3);    nums.push_back(1);    nums.push_back(2);    std::sort(nums.begin(), nums.end());    return 0;}`

### std::list

`#include <list> int main(){    std::list<int> nums;    nums.push_back(2);    nums.push_back(4);    nums.push_back(3);    nums.push_back(1);    nums.push_back(2);    nums.sort();    return 0;}`

## C#

`using System;using System.Collections.Generic; public class Program {    static void Main() {        int[] unsorted = { 6, 2, 7, 8, 3, 1, 10, 5, 4, 9 };        Array.Sort(unsorted);    }}`

## Clean

We use list and array comprehensions to convert an array to and from a list in order to use the built-in sort on lists.

`import StdEnv sortArray :: (a e) -> a e | Array a e & Ord esortArray array = {y \\ y <- sort [x \\ x <-: array]} Start :: {#Int}Start = sortArray {2, 4, 3, 1, 2}`

## Clojure

`(sort [5 4 3 2 1]) ; sort can also take a comparator function(1 2 3 4 5)`

## COBOL

Works with: Visual COBOL
`       PROGRAM-ID. sort-ints.        DATA DIVISION.       WORKING-STORAGE SECTION.       01  array-area             VALUE "54321".           03  array              PIC 9 OCCURS 5 TIMES.       01  i                      PIC 9.        PROCEDURE DIVISION.       main-line.           PERFORM display-array           SORT array ASCENDING array           PERFORM display-array            GOBACK           .       display-array.           PERFORM VARYING i FROM 1 BY 1 UNTIL 5 < i               DISPLAY array (i) " " NO ADVANCING           END-PERFORM           DISPLAY SPACE           .`

## Common Lisp

In Common Lisp, the sort function takes a predicate that is used as the comparator. This parameter can be any two-argument function. To sort a sequence (list or array) of integers, call sort with the < operator as the predicate:

`CL-USER> (sort #(9 -2 1 2 8 0 1 2) #'<)#(-2 0 1 1 2 2 8 9)`

## Crystal

Example demonstrating the support for copy sort and in-place sort (like Ruby)

` a = [5, 4, 3, 2, 1]puts a.sort# => [1, 2, 3, 4, 5] puts a# => [5, 4, 3, 2, 1] a.sort!puts a# => [1, 2, 3, 4, 5] `

## D

`import std.stdio, std.algorithm; void main() {    auto data = [2, 4, 3, 1, 2];    data.sort(); // in-place    assert(data == [1, 2, 2, 3, 4]);}`

## Delphi

`uses Types, Generics.Collections; var  a: TIntegerDynArray;begin  a := TIntegerDynArray.Create(5, 4, 3, 2, 1);  TArray.Sort<Integer>(a);end;`

## Déjà Vu

`!. sort [ 5 4 3 2 1 ]`
Output:
`[ 1 2 3 4 5 ]`

## DWScript

`var a : array of Integer := [5, 4, 3, 2, 1];a.Sort; // ascending natural sortPrintLn(a.Map(IntToStr).Join(','));  // 1,2,3,4,5`

## E

`[2,4,3,1,2].sort()`

## Elena

ELENA 3.4 :

`import system'routines.import extensions. public program[    var unsorted := (6, 2, 7, 8, 3, 1, 10, 5, 4, 9).     console printLine(unsorted clone; sort:ifOrdered; toLiteral).]`

## Elixir

`list = [2, 4, 3, 1, 2]IO.inspect Enum.sort(list)IO.inspect Enum.sort(list, &(&1>&2))`
Output:
```[1, 2, 2, 3, 4]
[4, 3, 2, 2, 1]
```

## Erlang

`List = [2, 4, 3, 1, 2].SortedList = lists:sort(List).`

## Euphoria

`include sort.eprint(1,sort({20, 7, 65, 10, 3, 0, 8, -60}))`

## EGL

Works with: EDT

The following works in EDT with Rich UI and stand-alone programs.

`program SortExample     function main()        test1 int[] = [1,-1,8,-8,2,-2,7,-7,3,-3,6,-6,9,-9,4,-4,5,-5,0];        test1.sort(sortFunction); 	for(i int from 1 to test1.getSize())	    SysLib.writeStdout(test1[i]);	end    end     function sortFunction(a any in, b any in) returns (int)        return (a as int) - (b as int);    end end`
Works with: RBD

The following works in RBD but only with Rich UI programs.

`test1 int[] = [1,-1,8,-8,2,-2,7,-7,3,-3,6,-6,9,-9,4,-4,5,-5,0];RUILib.sort(test1, sortFunction);  function sortFunction(a any in, b any in) returns (int)    return ((a as int) - (b as int));end`

## Factor

`{ 1 4 9 2 3 0 5 } natural-sort .`

## Fantom

The List collection contains a sort method which uses the usual comparison method for the data in the list; the sort is done 'in place'.

```fansh> a := [5, 1, 4, 2, 3]
[5, 1, 4, 2, 3]
fansh> a.sort
[1, 2, 3, 4, 5]
fansh> a
[1, 2, 3, 4, 5]
```

## Forth

Works with: Win32Forth version 4.2

### Win32Forth

`create test-data 2 , 4 , 3 , 1 , 2 ,test-data 5 cell-sort `

### ANS/ISO Forth

Works with: GForth

Standard Forth does not have a library sort

`100000 CONSTANT SIZE CREATE MYARRAY   SIZE CELLS ALLOT : []   ( n addr -- addr[n])  SWAP CELLS + ; : FILLIT ( -- ) ( reversed order)  SIZE 0  DO   SIZE I -   I MYARRAY [] !  LOOP ; : SEEIT  ( -- )   SIZE 0 DO  I MYARRAY [] ?   LOOP ; \ define non-standard words used by Quicksort author1 CELLS CONSTANT CELLCELL NEGATE CONSTANT -CELL: CELL-   CELL - ; : MID ( l r -- mid ) OVER - 2/ -CELL AND + ; : EXCH    ( addr1 addr2 -- )   OVER @ OVER @        ( read values)  SWAP ROT ! SWAP ! ;  ( exchange values) : PARTITION ( l r -- l r r2 l2 )  2DUP MID @ >R ( r: pivot )  2DUP  BEGIN    SWAP BEGIN  DUP @  [email protected]  < WHILE CELL+ REPEAT    SWAP BEGIN  [email protected] OVER @  < WHILE CELL- REPEAT    2DUP <= IF 2DUP EXCH  >R CELL+ R> CELL-  THEN    2DUP >  UNTIL  R> DROP ; : QSORT ( l r -- )  PARTITION  SWAP ROT  2DUP < IF RECURSE ELSE 2DROP THEN  2DUP < IF RECURSE ELSE 2DROP THEN ; : QUICKSORT ( array len -- )  DUP 2 < IF 2DROP EXIT THEN  1- CELLS OVER + QSORT ;`

Test at the console

`FILLIT okMYARRAY SIZE QUICKSORT ok`

## Fortran

Works with: Silverfrost FTN95
`CALL [email protected](b, a, n)! n = number of elements! a = array to be sorted! b = array of indices of a. b(1) 'points' to the minimum value etc.`

## FreeBASIC

Qsort is not buildin, but include in the compiler package.

`' version 11-03-2016' compile with: fbc -s console #Include Once "crt/stdlib.bi"      ' needed for qsort subroutine ' Declare Sub qsort (ByVal As Any Ptr, <== point to start of array'                    ByVal As size_t,  <== size of array'                    ByVal As size_t,  <== size of array element' ByVal As Function(ByVal As Any Ptr, ByVal As Any Ptr) As Long)  <== callback function' declare callback function with Cdecl to ensures that the parameters are passed in the correct order'' size of long: 4 bytes on 32bit OS, 8 bytes on 64bit OS ' ascending Function callback Cdecl (ByVal element1 As Any Ptr, ByVal element2 As Any Ptr) As Long     Function = *Cast(Long Ptr, element1) - *Cast(Long Ptr, element2)End Function ' Function callback Cdecl (ByVal element1 As Any Ptr, ByVal element2 As Any Ptr) As Long' Dim As Long e1 = *Cast(Long Ptr, element1)' Dim As Long e2 = *Cast(Long Ptr, element2)' Dim As Long result = Sgn(e1 - e2)' If Sgn(e1) = -1 And Sgn(e2) = -1 Then result = -result'     Function = result' End Function ' ------=< MAIN >=------ Dim As Long i, array(20) Dim As Long lb = LBound(array)Dim As Long ub = UBound(array) For i = lb To ub     ' fill array    array(i) = 10 - iNext PrintPrint "unsorted array"For i = lb To ub     ' display array    Print Using "###";array(i);NextPrint : Print ' sort arrayqsort(@array(lb), ub - lb +1, SizeOf(array), @callback) Print "sorted array"For i = lb To ub     ' show sorted array    Print Using "###";array(i);NextPrint ' empty keyboard bufferWhile Inkey <> "" : WendPrint : Print "hit any key to end program"SleepEnd`
Output:
```unsorted array
10  9  8  7  6  5  4  3  2  1  0 -1 -2 -3 -4 -5 -6 -7 -8 -9-10

sorted array
-10 -9 -8 -7 -6 -5 -4 -3 -2 -1  0  1  2  3  4  5  6  7  8  9 10```

## Frink

The following sorts an array in-place.

`a = [5, 2, 4, 1, 6, 7, 9, 3, 8, 0]sort[a]`

## F#

`// sorting an array in placelet nums = [| 2; 4; 3; 1; 2 |]Array.sortInPlace nums // create a sorted copy of a listlet nums2 = [2; 4; 3; 1; 2]let sorted = List.sort nums2`

## FunL

`nums = [5, 2, 78, 2, 578, -42]println( sort(nums) )           // sort in ascending orderprintln( nums.sortWith((>)) )   // sort in descending order`
Output:
```[-42, 2, 2, 5, 78, 578]
[578, 78, 5, 2, 2, -42]
```

## GAP

`a := [ 8, 2, 5, 9, 1, 3, 6, 7, 4 ];# Make a copy (with "b := a;", b and a would point to the same list)b := ShallowCopy(a); # Sort in placeSort(a);a;# [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ] # Sort without changing the argumentSortedList(b);# [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]b;# [ 8, 2, 5, 9, 1, 3, 6, 7, 4 ]`

## Gambas

`Public Sub Main()Dim iArray As Integer[] = [8, 2, 5, 9, 1, 3, 6, 7, 4]Dim iTemp As IntegerDim sOutput As String For Each iTemp In iArray.Sort()  sOutput &= iTemp & ", "Next Print Left(sOutput, -2) End`

Output:

```1, 2, 3, 4, 5, 6, 7, 8, 9
```

## Go

`package mainimport "fmt"import "sort" func main() {  nums := []int {2, 4, 3, 1, 2}  sort.Ints(nums)  fmt.Println(nums)}`

## Golfscript

`[2 4 3 1 2]\$`

## Groovy

`println ([2,4,0,3,1,2,-12].sort())`

Output:

`[-12, 0, 1, 2, 2, 3, 4]`

Works with: GHCi version 6.6
`nums = [2,4,3,1,2] :: [Int]sorted = List.sort nums`

## HicEst

`DIMENSION array(100)    array = INT( RAN(100) )   SORT(Vector=array, Sorted=array) `

## Huginn

`main() {  nums = [2, 4, 3, 1, 2];  nums.sort();}`

## IDL

`result = array[sort(array)]`

## Icon and Unicon

Icon and Unicon lists allow mixed type and the built-in function 'sort' will deal with mixed type arrays by sorting by type first then value. Integers sort before, reals, strings, lists, tables, etc. As a result a list of mixed numeric valuess (i.e. integers and reals) will not sort by numeric value, rather the reals will appear after the integers. Sort returns a sorted copy of it's argument. It will also perform some type conversion, such converting an unordered set into an ordered list.

In the example below, L will remain an unsorted list and S will be sorted.

`S := sort(L:= [63, 92, 51, 92, 39, 15, 43, 89, 36, 69])  # will sort a list`

## Inform 7

`let L be {5, 4, 7, 1, 18};sort L;`

## Io

`mums := list(2,4,3,1,2)sorted := nums sort  # returns a new sorted array.  'nums' is unchangednums sortInPlace  # sort 'nums' "in-place"`

## J

`/:~`

The verb /:~ sorts anything that J can represent. For example:

`   ] a=: 10 [email protected]\$ 100    NB. random vector63 92 51 92 39 15 43 89 36 69   /:~ a15 36 39 43 51 63 69 89 92 92`

Arrays of any rank are treated as lists of component arrays. Thus /:~ sorts not only atoms within a list, but whole lists within a table, tables within a three-axis array, and so on. The level of structure at which sorting occurs may also be specified, so that /:~"1 sorts the atoms within the finest-grained list within the array, regardless of the overall rank of the array. See the Total Array Ordering essay on the JWiki for more details.

This code also applies to any data type.

## Java

### Array

`import java.util.Arrays; public class Example {    public static void main(String[] args)    {        int[] nums = {2,4,3,1,2};        Arrays.sort(nums);    }}`

### List

Works with: Java version 1.5+
`import java.util.Arrays;import java.util.Collections;import java.util.List; public class Example {    public static void main(String[] args)    {        List<Integer> nums = Arrays.asList(2,4,3,1,2);        Collections.sort(nums);    }}`

## JavaScript

Works with: Firefox version 2.0

JavaScript sorts lexically by default, so "10000" comes before "2". To sort numerically, a custom comparator is used.

`function int_arr(a, b) {  return a - b;}var numbers = [20, 7, 65, 10, 3, 0, 8, -60];numbers.sort(int_arr);document.write(numbers);`

## Kotlin

`// version 1.0.6 fun main(args: Array<String>) {   val ints = intArrayOf(6, 2, 7, 8, 3, 1, 10, 5, 4, 9)   ints.sort()   println(ints.joinToString(prefix = "[", postfix = "]"))}`
Output:
```[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
```

## Lasso

`local(array) = array(5,20,3,2,6,1,4)#array->sort#array // 1, 2, 3, 4, 5, 6, 20 // Reverse the sort order#array->sort(false)#array // 20, 6, 5, 4, 3, 2, 1`

## jq

jq's builtin `sort` filter sorts the elements of an array in ascending order:

`[2,1,3] | sort  # => [1,2,3]`

## Julia

Julia has both out-of-place (`sort`) and in-place (`sort!`) sorting functions in its standard-library:

`julia> a = [4,2,3,1]4-element Int32 Array: 4 2 3 1julia> sort(a) #out-of-place/non-mutating sort4-element Int32 Array: 1 2 3 4 julia> a4-element Int32 Array: 4 2 3 1 julia> sort!(a) # in-place/mutating sort4-element Int32 Array: 1 2 3 4 julia> a4-element Int32 Array: 1 2 3 4`

## K

`  num: -10?10              / Integers from 0 to 9 in random order5 9 4 2 0 3 6 1 8 7   srt: {[email protected]<x}              / Generalized sort ascending  srt num0 1 2 3 4 5 6 7 8 9`

## Liberty BASIC

LB has an array-sort command. Parameters are arrayname, start term, finish term.

`N =20dim IntArray( N) print "Original order"for i =1 to N    t =int( 1000 *rnd( 1))    IntArray( i) =t    print tnext i sort IntArray(), 1, N print "Sorted oprder"for i =1 to N    print IntArray( i)next i`

## Lingo

`l = [7, 4, 23]l.sort()put l-- [4, 7, 23]`

## LiveCode

LiveCode can sort lines or items natively. The delimiter for items can be set to any single character, but defaults to comma.

`put "3,2,5,4,1" into Xsort items of X numericput X-- outputs "1,2,3,4,5"`

## Lua

`t = {4, 5, 2}table.sort(t)print(unpack(t))`

## Maple

`sort([5,7,8,3,6,1]);sort(Array([5,7,8,3,6,1]))`

## Mathematica

`numbers = Sort[{2,4,3,1,2}]`

## MATLAB

`a = [4,3,7,-2,9,1]; b = sort(a)     % b contains elements of a in ascending order[b,idx] = sort(a)                   % b contains a(idx)`

## Maxima

`sort([9, 4, 3, 7, 6, 1, 10, 2, 8, 5]);`

## MAXScript

`arr = #(5, 4, 3, 2, 1)arr = sort arr`

## Mercury

`:- module sort_int_list.:- interface.:- import_module io. :- pred main(io::di, uo::uo) is det. :- implementation.:- import_module list. main(!IO) :-  Nums = [2, 4, 0, 3, 1, 2],  list.sort(Nums, Sorted),  io.write(Sorted, !IO),  io.nl(!IO).`

## Modula-3

Modula-3 provides a generic ArraySort module, as well as an instance of that module for integers called IntArraySort.

`MODULE ArraySort EXPORTS Main; IMPORT IntArraySort; VAR arr := ARRAY [1..10] OF INTEGER{3, 6, 1, 2, 10, 7, 9, 4, 8, 5}; BEGIN  IntArraySort.Sort(arr);END ArraySort.`

## MUMPS

`SORTARRAY(X,SEP) ;X is the list of items to sort ;X1 is the temporary array ;SEP is the separator string between items in the list X ;Y is the returned list ;This routine uses the inherent sorting of the arrays NEW I,X1,Y SET Y="" FOR I=1:1:\$LENGTH(X,SEP) SET X1(\$PIECE(X,SEP,I))="" SET I="" FOR  SET I=\$O(X1(I)) Q:I=""  SET Y=\$SELECT(\$L(Y)=0:I,1:Y_SEP_I) KILL I,X1 QUIT Y`
Output:
```USER>W \$\$SORTARRAY^ROSETTA("3,5,1,99,27,16,0,-1",",")
-1,0,1,3,5,16,27,99
```

## Neko

`/** <doc><h2>Sort integer array, in Neko</h2>   <p>Array sort function modified from Haxe codegen with -D neko-source</p>   <p>The Neko target emits support code for Haxe basics, sort is included</p>   <p>Tectonics:<br />prompt\$ nekoc sort.neko<br />prompt\$ neko sort</p> </doc>**/ var sort = function(a) {    var i = 0;    var len = \$asize(a);    while ( i < len ) {        var swap = false;        var j = 0;        var max = (len - i) - 1;        while ( j < max ) {            if ( (a[j] - a[j + 1]) > 0 ) {                var tmp = a[j + 1];                a[j + 1] = a[j];                a[j] = tmp;                swap = true;            }            j += 1;        }        if ( \$not(swap) )            break;;        i += 1;    }    return a;} var arr = \$array(5,3,2,1,4)\$print(arr, "\n") /* Sorts in place */sort(arr)\$print(arr, "\n") /* Also returns the sorted array for chaining */\$print(sort(\$array(3,1,4,1,5,9,2,6,5,3,5,8)), "\n")`
Output:
```prompt\$ nekoc sort.neko
prompt\$ neko sort.n
[5,3,2,1,4]
[1,2,3,4,5]
[1,1,2,3,3,4,5,5,5,6,8,9]```

## Nemerle

`using System.Console; module IntSort{    Main() : void    {        def nums = [1, 5, 3, 7, 2, 8, 3, 9];        def sorted = nums.Sort((x, y) => x.CompareTo(y));         WriteLine(nums);        WriteLine(sorted);    }}`

Output:

```[1, 5, 3, 7, 2, 8, 3, 9]
[1, 2, 3, 3, 5, 7, 8, 9]```

## NetRexx

`/* NetRexx */options replace format comments java crossref savelog symbols binary ia = int[]ia = [ 2, 4, 3, 1, 2, -1, 0, -2 ] display(ia)Arrays.sort(ia)display(ia) -- Display resultsmethod display(in = int[]) public static   sorted = Rexx('')   loop ix = 0 for in.length    sorted = sorted || Rexx(in[ix]).right(4)    end ix   say sorted.strip('t')   return`

Output

```   2   4   3   1   2  -1   0  -2
-2  -1   0   1   2   2   3   4
```

NetRexx reimplementations of the Rexx samples from below:

`/* NetRexx */options replace format comments java crossref savelog symbols /*REXX program to sort an integer array.*/ numeric digits 20    /*handle larger numbers.*/a = ''a[ 1]=               1a[ 2]=               0a[ 3]=              -1a[ 4]=               0a[ 5]=               5a[ 6]=               0a[ 7]=             -61a[ 8]=               0a[ 9]=            1385a[10]=               0a[11]=          -50521a[12]=               0a[13]=         2702765a[14]=               0a[15]=      -199360981a[16]=               0a[17]=     19391512145a[18]=               0a[19]=  -2404879675441a[20]=               0a[21]= 370371188237525 size = 21                          /*we have a list of 21 Euler numbers.*/tell('un-sorted', a, size)a[0] = sizeesort(a, 1)tell('   sorted', a, size) return /*----------------------------------ESORT subroutine--------------------*/method esort(a, size) public static--esort: procedure expose a.;   h = a[0]   loop while h > 1    h = h % 2    loop i = 1 for a[0] - h      j = i      k = h + i      loop while a[k] < a[j]        t    = a[j]        a[j] = a[k]        a[k] = t        if h >= j then leave        j = j - h        k = k - h        end      end i    end return /*----------------------------------TELL subroutine---------------------*/method tell(arg, a, size) public static--tell:   say arg.center(40, '-')  loop j = 1 for size    say arg 'array element' j.right(size.length)'='a[j].right(25)    end j  say   return`

Output

```---------------un-sorted----------------
un-sorted array element  1=                        1
un-sorted array element  2=                        0
un-sorted array element  3=                       -1
un-sorted array element  4=                        0
un-sorted array element  5=                        5
un-sorted array element  6=                        0
un-sorted array element  7=                      -61
un-sorted array element  8=                        0
un-sorted array element  9=                     1385
un-sorted array element 10=                        0
un-sorted array element 11=                   -50521
un-sorted array element 12=                        0
un-sorted array element 13=                  2702765
un-sorted array element 14=                        0
un-sorted array element 15=               -199360981
un-sorted array element 16=                        0
un-sorted array element 17=              19391512145
un-sorted array element 18=                        0
un-sorted array element 19=           -2404879675441
un-sorted array element 20=                        0
un-sorted array element 21=          370371188237525

---------------   sorted----------------
sorted array element  1=           -2404879675441
sorted array element  2=               -199360981
sorted array element  3=                   -50521
sorted array element  4=                      -61
sorted array element  5=                       -1
sorted array element  6=                        0
sorted array element  7=                        0
sorted array element  8=                        0
sorted array element  9=                        0
sorted array element 10=                        0
sorted array element 11=                        0
sorted array element 12=                        0
sorted array element 13=                        0
sorted array element 14=                        0
sorted array element 15=                        0
sorted array element 16=                        1
sorted array element 17=                        5
sorted array element 18=                     1385
sorted array element 19=                  2702765
sorted array element 20=              19391512145
sorted array element 21=          370371188237525
```
`/* NetRexx */options replace format comments java crossref savelog symbols /*REXX program to sort an interesting integer list.*/ bell = '1 1 2 5 15 52 203 877 4140 21147 115975'      /*some Bell numbers.*/bern = '1 -1 1 0 -1 0 1 0 -1 0 5 0 -691 0 7 0 -3617'  /*some Bernoulli num*/perrin = '3 0 2 3 2 5 5 7 10 12 17 22 29 39 51 68 90' /*some Perrin nums. */list = bell bern perrin                               /*combine the three.*/ size = list.words a = 0loop j = 1 for size  a[j] = list.word(j)  end j say '  as is='lista[0] = sizeesort(a, size)bList = '' loop j = 1 for size  bList = bList a[j]  end j blist = bList.stripsay ' sorted='bList return /*----------------------------------ESORT subroutine--------------------*/method esort(a, size) public static--esort: procedure expose a.;   h = a[0]   loop while h > 1    h = h % 2    loop i = 1 for a[0] - h      j = i      k = h + i      loop while a[k] < a[j]        t    = a[j]        a[j] = a[k]        a[k] = t        if h >= j then leave        j = j - h        k = k - h        end      end i    end return`

Output

```  as is=1 1 2 5 15 52 203 877 4140 21147 115975 1 -1 1 0 -1 0 1 0 -1 0 5 0 -691 0 7 0 -3617 3 0 2 3 2 5 5 7 10 12 17 22 29 39 51 68 90
sorted=-3617 -691 -1 -1 -1 0 0 0 0 0 0 0 0 1 1 1 1 1 2 2 2 3 3 5 5 5 5 7 7 10 12 15 17 22 29 39 51 52 68 90 203 877 4140 21147 115975
```

## Nial

`sort >= 9 6 8 7 1 10= 10 9 8 7 6 1`

## Nim

`import algorithm var a: array[0..8,int] = [2,3,5,8,4,1,6,9,7]a.sort(system.cmp[int], Ascending)for x in a:   echo(x)`
Output:
```1
2
3
4
5
6
7
8
9```

## Niue

Library

`2 6 1 0 3 8 sort .s0 1 2 3 6 8`

## Objective-C

`NSArray *nums = @[@2, @4, @3, @1, @2];NSArray *sorted = [nums sortedArrayUsingSelector:@selector(compare:)];`

## Objeck

`bundle Default {  class Sort {    function : Main(args : System.String[]) ~ Nil {      nums := Structure.IntVector->New([2,4,3,1,2]);      nums->Sort();    }  }}`

## OCaml

### Array

`let nums = [|2; 4; 3; 1; 2|]Array.sort compare nums`

### List

`let nums = [2; 4; 3; 1; 2]let sorted = List.sort compare nums`

## Octave

The variable v can be a vector or a matrix (columns will be sorted).

`sortedv = sort(v);`

## Oforth

`[ 8, 2, 5, 9, 1, 3, 6, 7, 4 ] sort`

## ooRexx

`a = .array~of(4, 1, 6, -2, 99, -12)say "The sorted numbers are"say a~sortWith(.numericComparator~new)~makeString`

Output:

```The sorted numbers are
-12
-2
1
4
6
99
```

## Order

Passing the less-than operator to the built-in sequence (i.e. list) sort function:

`#include <order/interpreter.h> ORDER_PP( 8seq_sort(8less, 8seq(2, 4, 3, 1, 2)) )`

## Oz

`declare  Nums = [2 4 3 1 2]  Sorted = {List.sort Nums Value.'<'}in  {Show Sorted}`

## PARI/GP

`vecsort(v)`

## Peloton

Sorting a list of numbers as strings and as numbers (from the manual.)

`Construct a list of numbers <@ LETCNSLSTLIT>L|65^84^1^25^77^4^47^2^42^44^41^25^69^3^51^45^4^39^</@> Numbers sort as strings<@ ACTSRTENTLST>L</@> <@ SAYDMPLST>L</@> <@ ACTSRTENTLSTLIT>L|__StringDescending</@> <@ SAYDMPLST>L</@> Construct another list of numbers<@ LETCNSLSTLIT>list|65^84^1^25^77^4^47^2^42^44^41^25^69^3^51^45^4^39^</@> Numbers sorted as numbers<@ ACTSRTENTLSTLIT>list|__Numeric</@> <@ SAYDMPLST>list</@> <@ ACTSRTENTLSTLIT>list|__NumericDescending</@> <@ SAYDMPLST>list</@>`

Output

`Construct a list of numbers  Numbers sort as strings 1^2^25^25^3^39^4^4^41^42^44^45^47^51^65^69^77^84^  84^77^69^65^51^47^45^44^42^41^4^4^39^3^25^25^2^1^ Construct another list of numbers Numbers sorted as numbers 1^2^3^4^4^25^25^39^41^42^44^45^47^51^65^69^77^84^  84^77^69^65^51^47^45^44^42^41^39^25^25^4^4^3^2^1^`

## Perl

Works with: Perl version 5.8.6
`@nums = (2,4,3,1,2);@sorted = sort {\$a <=> \$b} @nums;`

## Perl 6

If `@a` contains only numbers:

`my @sorted = sort @a;`

For an in-place sort:

`@a .= sort;`

## Phix

`?sort({9, 10, 3, 1, 4, 5, 8, 7, 6, 2})`

## PHP

Works with: PHP version 4.4.4 CLI
`<?php\$nums = array(2,4,3,1,2);sort(\$nums);?>`

## PicoLisp

The sort function in PicoLisp returns already by default an ascending list (of any type, not only integers):

`(sort (2 4 3 1 2))-> (1 2 2 3 4)`

## PL/I

Works with: IBM PL/I version 7.5
`DCL (T(10)) FIXED BIN(31); /* scratch space of length N/2 */ MERGE: PROCEDURE (A,LA,B,LB,C);   DECLARE (A(*),B(*),C(*)) FIXED BIN(31);   DECLARE (LA,LB) FIXED BIN(31) NONASGN;   DECLARE (I,J,K) FIXED BIN(31);    I=1; J=1; K=1;   DO WHILE ((I <= LA) & (J <= LB));      IF(A(I) <= B(J)) THEN         DO; C(K)=A(I); K=K+1; I=I+1; END;      ELSE         DO; C(K)=B(J); K=K+1; J=J+1; END;   END;   DO WHILE (I <= LA);      C(K)=A(I); I=I+1; K=K+1;   END;   RETURN;END MERGE; MERGESORT: PROCEDURE (A,N) RECURSIVE ;     DECLARE (A(*))               FIXED BINARY(31);     DECLARE N                    FIXED BINARY(31) NONASGN;     DECLARE Temp                 FIXED BINARY;     DECLARE (M,I)                FIXED BINARY;     DECLARE AMP1(N)              FIXED BINARY(31) BASED(P);     DECLARE P POINTER;    IF (N=1) THEN RETURN;   M = trunc((N+1)/2);   IF (M>1) THEN CALL MERGESORT(A,M);   P=ADDR(A(M+1));    IF (N-M > 1) THEN CALL MERGESORT(AMP1,N-M);   IF A(M) <= AMP1(1) THEN RETURN;   DO I=1 to M; T(I)=A(I); END;   CALL MERGE(T,M,AMP1,N-M,A);   RETURN;END MERGESORT;`

## Pop11

Pop11 library function sorts lists. So we first convert array to list, then sort and finally convert back:

`lvars ar = {2 4 3 1 2};;;; Convert array to list.;;; destvector leaves its results and on the pop11 stack + an integer saying how many there weredestvector(ar);;;; conslist uses the items left on the stack plus the integer, to make a list of those items.lvars ls = conslist();;;; Sort itsort(ls) -> ls;;;; Convert list to arraydestlist(ls);consvector() -> ar;`

The above can be abbreviated to more economical, but possibly more opaque, syntax, using pop11 as a functional language:

`lvars ar = {2 4 3 1 2};consvector(destlist(sort(conslist(destvector(ar))))) -> ar;;;; print the sorted vector:ar =>** {1 2 2 3 4}`

(The list created by conslist will be garbage-collected.)

Alternatively, using the datalist function, even more economically:

`lvars ar = {2 4 3 1 2};consvector(destlist(sort(datalist(ar)))) -> ar;`

or in Forth-like pop11 postfix syntax:

`lvars ar = {2 4 3 1 2};ar.datalist.sort.destlist.consvector -> ar;`

## Potion

`(7, 5, 1, 2, 3, 8, 9) sort join(", ") print`

## PowerBASIC

PowerBASIC has several options available for sorting. At its simplest, an array (of any type) is sorted using `ARRAY SORT`:

`ARRAY SORT x()`

Options are available to limit sorting to only part of the array, collate string arrays, sort multiple arrays together, etc. (Details here.)

## PowerShell

`34,12,23,56,1,129,4,2,73 | Sort-Object`

## Prolog

``` ?- msort([10,5,13,3, 85,3,1], L).
L = [1,3,3,5,10,13,85].```

Note that sort/2 removes duplicates.

## PureBasic

`Dim numbers(20)For i = 0 To 20   numbers(i) = Random(1000)Next SortArray(numbers(), #PB_Sort_Ascending)`

## Python

Works with: Python version 2.3
`nums = [2,4,3,1,2]nums.sort()`

Note: The array nums is sorted in place.

Interpreter: Python 2.4 (and above)

You could also use the built-in sorted() function

`nums = sorted([2,4,3,1,2])`

## R

`nums <- c(2,4,3,1,2)sorted <- sort(nums)`

## Racket

` -> (sort '(1 9 2 8 3 7 4 6 5) <)'(1 2 3 4 5 6 7 8 9) `

## Rascal

Rascal has a built-in sort function that sort the elements of a list. Additionally, one can give a LessThenOrEqual function to compare the elements (See documentation).

`rascal>import List;ok rascal>a = [1, 4, 2, 3, 5];list[int]: [1,4,2,3,5] rascal>sort(a)list[int]: [1,2,3,4,5] rascal>sort(a, bool(int a, int b){return a >= b;})list[int]: [5,4,3,2,1]`

## Raven

Sort list in place:

`[ 2 4 3 1 2 ] sort`

## REBOL

`sort [2 4 3 1 2]`

## Red

`>> nums: [3 2 6 4 1 9 0 5 7]== [3 2 6 4 1 9 0 5 7]>> sort nums== [0 1 2 3 4 5 6 7 9]`

## REXX

### sort an array

This REXX version creates an array with over a score of Euler numbers (integers), then sorts it.

`/*REXX program sorts an array (using E─sort), in this case, the array contains integers.*/numeric digits 30                                /*enables handling larger Euler numbers*/                          @.  =              0;            @.1 =               1                          @.3 =             -1;            @.5 =               5                          @.7 =            -61;            @.9 =            1385                          @.11=         -50521;            @.13=         2702765                          @.15=     -199360981;            @.17=     19391512145                          @.19= -2404879675441;            @.21= 370371188237525#= 21                                            /*indicate there're  21 Euler  numbers.*/call tell  'unsorted'                            /*display the array before the  eSort. */call eSort     #                                 /*sort the array of some Euler numbers.*/call tell  '  sorted'                            /*display the array  after  the eSort. */exit                                             /*stick a fork in it,  we're all done. *//*──────────────────────────────────────────────────────────────────────────────────────*/eSort: procedure expose @.;   parse arg N;     h=N                   /*an eXchange sort.*/              do  while h>1;                   h= h%2                /*define a segment.*/                 do i=1  for N-h;              j=i;     k= h+i       /*sort top segment.*/                    do  while  @.k<@.j                               /*see if need swap.*/                        parse value  @.j @.k   with   @.k @.j        /*swap two elements*/                        if h>=j  then leave;   j= j-h;   k= k-h      /*this part sorted?*/                        end   /*while @.k<@.j*/                    end       /*i*/              end             /*while h>1*/       return/*──────────────────────────────────────────────────────────────────────────────────────*/tell:  say copies('─', 65);       _= left('',9);                       w= length(#)              do j=1  for #;  say _ arg(1)  'array element'   right(j, w)"="right(@.j, 20)              end   /*j*/       return`
output   when using the default internal input:
```─────────────────────────────────────────────────────────────────
unsorted array element  1=                   1
unsorted array element  2=                   0
unsorted array element  3=                  -1
unsorted array element  4=                   0
unsorted array element  5=                   5
unsorted array element  6=                   0
unsorted array element  7=                 -61
unsorted array element  8=                   0
unsorted array element  9=                1385
unsorted array element 10=                   0
unsorted array element 11=              -50521
unsorted array element 12=                   0
unsorted array element 13=             2702765
unsorted array element 14=                   0
unsorted array element 15=          -199360981
unsorted array element 16=                   0
unsorted array element 17=         19391512145
unsorted array element 18=                   0
unsorted array element 19=      -2404879675441
unsorted array element 20=                   0
unsorted array element 21=     370371188237525
─────────────────────────────────────────────────────────────────
sorted array element  1=      -2404879675441
sorted array element  2=          -199360981
sorted array element  3=              -50521
sorted array element  4=                 -61
sorted array element  5=                  -1
sorted array element  6=                   0
sorted array element  7=                   0
sorted array element  8=                   0
sorted array element  9=                   0
sorted array element 10=                   0
sorted array element 11=                   0
sorted array element 12=                   0
sorted array element 13=                   0
sorted array element 14=                   0
sorted array element 15=                   0
sorted array element 16=                   1
sorted array element 17=                   5
sorted array element 18=                1385
sorted array element 19=             2702765
sorted array element 20=         19391512145
sorted array element 21=     370371188237525
```

### sort a list

This REXX version creates a list with a bunch of interesting integers, then sorts it.

Because it so much more efficient to sort an array,   an array is built from the list,
it is then sorted,   and then the list is re-constituted.

`/*REXX program sorts  (using E─sort)  and displays a list of some interesting integers. */  Bell=  1 1 2 5 15 52 203 877 4140 21147 115975           /*a few  Bell          "     */  Bern= '1 -1 1 0 -1 0 1 0 -1 0 5 0 -691 0 7 0 -3617'      /*"  "   Bernoulli     "     */Perrin=  3 0 2 3 2 5 5 7 10 12 17 22 29 39 51 68 90        /*"  "   Perrin        "     */list=Bell  Bern  Perrin                                    /*throw them all ───► a pot. */say 'unsorted =' list                                      /*display what's being shown.*/size=words(list)                                           /*nice to have # of elements.*/                              do j=1  for size             /*build an array, a single   */                              @.j=word(list,j)             /*     ··· element at a time.*/                              end    /*j*/call eSort size                                            /*sort the collection of #s. */\$=                                                         /*list: define as null so far*/                              do k=1  for size             /*build a list from the array*/                              \$=\$ @.k                      /*append a number to the list*/                              end    /*k*/say '  sorted =' space(\$)                                  /*display the sorted list.   */exit                                              /*stick a fork in it,  we're all done.*//*──────────────────────────────────────────────────────────────────────────────────────*/eSort: procedure expose @.;   parse arg N;     h=N                   /*an eXchange sort.*/              do  while h>1;                   h= h%2                /*define a segment.*/                 do i=1  for N-h;              j=i;     k= h+i       /*sort top segment.*/                    do  while  @.k<@.j                               /*see if need swap.*/                        parse value  @.j @.k   with   @.k @.j        /*swap two elements*/                        if h>=j  then leave;   j= j-h;   k= k-h      /*this part sorted?*/                        end   /*while @.k<@.j*/                    end       /*i*/              end             /*while h>1*/       return`
output   when using the default internal inputs:
```unsorted = 1 1 2 5 15 52 203 877 4140 21147 115975 1 -1 1 0 -1 0 1 0 -1 0 5 0 -691 0 7 0 -3617 3 0 2 3 2 5 5 7 10 12 17 22 29 39 51 68 90
sorted = -3617 -691 -1 -1 -1 0 0 0 0 0 0 0 0 1 1 1 1 1 2 2 2 3 3 5 5 5 5 7 7 10 12 15 17 22 29 39 51 52 68 90 203 877 4140 21147 115975
```

## Ring

`aArray = [2,4,3,1,2]see sort(aArray)`

## Ruby

`nums = [2,4,3,1,2]sorted = nums.sort      # returns a new sorted array.  'nums' is unchangedp sorted                #=> [1, 2, 2, 3, 4]p nums                  #=> [2, 4, 3, 1, 2] nums.sort!              # sort 'nums' "in-place"p nums                  #=> [1, 2, 2, 3, 4]`

## Rust

Uses merge sort in place (undocumented), allocating ~2*n memory where n is a length of an array.

`fn main() {    let mut a = vec!(9, 8, 7, 6, 5, 4, 3, 2, 1, 0);     a.sort();    println!("{:?}", a);}`

## Scala

Library: Scala

### Array

Scala's "default" Array is a mutable data structure, very close to Java's Array. Generally speaking, that means an "array" is not very Scala-lesque, even as mutable data structures go. It can serves a purpose, though. If array is the right data type for your need, then that is how you sort it.
`import scala.compat.Platform object Sort_an_integer_array extends App {  val array = Array((for (i <- 0 to 10) yield scala.util.Random.nextInt()):    _* /*Sequence is passed as multiple parameters to Array(xs : T*)*/)   /** Function test the array if it is in order */  def isSorted[T](arr: Array[T]) = array.sliding(2).forall(pair => pair(0) <= pair(1))   assert(!isSorted(array), "Not random")  scala.util.Sorting.quickSort(array)  assert(isSorted(array), "Not sorted")   println(s"Array in sorted order.\nSuccessfully completed without errors. [total \${Platform.currentTime - executionStart} ms]")}`

### List

`println(List(5,2,78,2,578,-42).sorted)//--> List(-42, 2, 2, 5, 78, 578)`

## Scheme

Works with: Guile

Same as Common Lisp

`(sort #(9 -2 1 2 8 0 1 2) #'<)`
Library: Scheme/SRFIs

Sorting is also available through SRFIs. SRFI 132 provides separate list-sort and vector-sort routines:

` > (import (srfi 132))> (list-sort < '(9 -2 1 2 8 0 1 2))(-2 0 1 1 2 2 8 9) > (vector-sort < #(9 -2 1 2 8 0 1 2))#(-2 0 1 1 2 2 8 9) `

SRFI 132 replaced the older SRFI 95, which is still found in many implementations. SRFI 95 provides a generic sort function (but note the order of the sequence and comparator!):

` > (import (srfi 95))> (sort '(9 -2 1 2 8 0 1 2) <)(-2 0 1 1 2 2 8 9)> (sort #(9 -2 1 2 8 0 1 2) <)#(-2 0 1 1 2 2 8 9) `

## Seed7

`var array integer: nums is [] (2, 4, 3, 1, 2); nums := sort(nums);`

## Sidef

`var nums = [2,4,3,1,2];var sorted = nums.sort;  # returns a new sorted array.nums.sort!;              # sort 'nums' "in-place"`

## Slate

` #(7 5 2 9 0 -1) sort`

## Smalltalk

` #(7 5 2 9 0 -1) asSortedCollection`

or destructive:

` #(7 5 2 9 0 -1) sort`

## Sparkling

`var arr = { 2, 8, 1, 4, 6, 5, 3, 7, 0, 9 };sort(arr);`

## Standard ML

The Standard ML Basis library does not have any sorting facilities. But each implementation of Standard ML has its own.

### Array

Works with: SML/NJ
`- val nums = Array.fromList [2, 4, 3, 1, 2];val nums = [|2,4,3,1,2|] : int array- ArrayQSort.sort Int.compare nums;val it = () : unit- nums;val it = [|1,2,2,3,4|] : int array`
Works with: Moscow ML
`- load "Arraysort";> val it = () : unit- load "Int";> val it = () : unit- val nums = Array.fromList [2, 4, 3, 1, 2];> val nums = <array> : int array- Arraysort.sort Int.compare nums;> val it = () : unit- Array.foldr op:: [] nums;> val it = [1, 2, 2, 3, 4] : int list`

### List

Works with: SML/NJ
`- val nums = [2, 4, 3, 1, 2];val nums = [2,4,3,1,2] : int list- val sorted = ListMergeSort.sort op> nums;val sorted = [1,2,2,3,4] : int list`
Works with: Moscow ML
`- load "Listsort";> val it = () : unit- load "Int";> val it = () : unit- val nums = [2, 4, 3, 1, 2];> val nums = [2, 4, 3, 1, 2] : int list- val sorted = Listsort.sort Int.compare nums;> val sorted = [1, 2, 2, 3, 4] : int list`

## Stata

### Sort a Stata dataset

See sort in Stata help.

`. clear. matrix a=(2,9,4,7,5,3,6,1,8)'. qui svmat a. sort a. list      +----+     | a1 |     |----|  1. |  1 |  2. |  2 |  3. |  3 |  4. |  4 |  5. |  5 |     |----|  6. |  6 |  7. |  7 |  8. |  8 |  9. |  9 |     +----+`

### Sort a macro list

See macrolists in Stata help for other functions on lists stored in macros.

`. local a 2 9 4 7 5 3 6 1 8. di "`: list sort a'"1 2 3 4 5 6 7 8 9`

### Mata

See Mata's sort function.

`mata: a=2\9\4\7\5\3\6\1\8 : sort(a,1)       1    +-----+  1 |  1  |  2 |  2  |  3 |  3  |  4 |  4  |  5 |  5  |  6 |  6  |  7 |  7  |  8 |  8  |  9 |  9  |    +-----+end`

## Swift

### Sort in place

Works with: Swift version 2.x+
`var nums = [2, 4, 3, 1, 2]nums.sortInPlace()print(nums)`

or

`var nums = [2, 4, 3, 1, 2]nums.sortInPlace(<)print(nums)`
Works with: Swift version 1.x
`var nums = [2, 4, 3, 1, 2]nums.sort(<)println(nums)`

or

`var nums = [2, 4, 3, 1, 2]sort(&nums)println(nums)`

or

`var nums = [2, 4, 3, 1, 2]sort(&nums, <)println(nums)`

### Return new array

You could also create a new sorted array without affecting the original one:

Works with: Swift version 2.x+
`let nums = [2,4,3,1,2].sort()print(nums)`

or

`let nums = [2,4,3,1,2].sort(<)print(nums)`
Works with: Swift version 1.x
`let nums = sorted([2,4,3,1,2])println(nums)`

or

`let nums = [2,4,3,1,2].sorted(<)println(nums)`

## Tcl

`set result [lsort -integer \$unsorted_list]`

## TI-83 BASIC

Store input into L1, run prgmSORTBTIN, and L2 will be L1, only sorted.

```:L1→L2
:SortA(L2)
```

SortA is found via: [LIST] → ENTER. SortD is also available for a descending sort.

## Toka

This can be done by using the bubble sort library:

`needs bsortarrayname number_elements bsort`

See the Toka entry on Bubble Sort for a full example.

## UNIX Shell

Each shell parameter separates the integers using the default IFS whitespace (space, tab, newline).

`nums="2 4 3 1 5"sorted=`printf "%s\n" \$nums | sort -n`echo \$sorted  # prints 1 2 3 4 5`

Alternate solution: sorted=`for i in \$nums; do echo \$i; done | sort -n`

Some shells have real arrays. You still need IFS to split the string from sort -n to an array.

Works with: pdksh version 5.2.14
`set -A nums 2 4 3 1 5set -A sorted \$(printf "%s\n" \${nums[*]} | sort -n)echo \${sorted[*]}  # prints 1 2 3 4 5`

Users of bash, ksh93 and mksh can probably use the nums=(2 4 3 1 2) syntax.

## Ursa

`decl int<> numsappend 2 4 3 1 2 numssort nums`

## Ursala

using the built in sort operator, -<, with the nleq library function for comparing natural numbers

`#import nat #cast %nL example = nleq-< <39,47,40,53,14,23,88,52,78,62,41,92,88,66,5,40>`

output:

`<5,14,23,39,40,40,41,47,52,53,62,66,78,88,88,92>`

## WDTE

`let a => import 'arrays';a.sort [39; 47; 40; 53; 14; 23; 88; 52; 78; 62; 41; 92; 88; 66; 5; 40] < -- io.writeln io.stdout;`

## Wortel

`@sort [39 47 40 53 14 23 88 52 78 62 41 92 88 66 5 40]`

## XPL0

`include c:\cxpl\codes;          \intrinsic 'code' declarations proc    SSort(A, N);            \Shell sort array in ascending orderint     A;                      \address of arrayint     N;                      \number of elements in array (size)int     I, J, Gap, JG, T;[Gap:= N>>1;while Gap > 0 do        [for I:= Gap to N-1 do                [J:= I - Gap;                loop    [JG:= J + Gap;                        if A(J) <= A(JG) then quit;                        T:= A(J);   A(J):= A(JG);   A(JG):= T;  \swap elements                        J:= J - Gap;                        if J < 0 then quit;                        ];                ];        Gap:= Gap>>1;        ];];      \SSort int A, I;[A:= [3, 1, 4, 1, 5, 9, 2, 6, 5, 4];SSort(A, 10);for I:= 0 to 10-1 do [IntOut(0, A(I));  ChOut(0, ^ )];CrLf(0);]`

Output:

```1 1 2 3 4 4 5 5 6 9
```

## Yabasic

`export sub shell_sort(x())// Shell sort based on insertion sort    local gap, i, j, first, last, tempi, tempj    last = arraysize(x(),1)   gap = int(last / 10) + 1   while(TRUE)	first = gap + 1	for i = first to last	   	tempi = x(i)	    	j = i - gap	    	while(TRUE)			tempj = x(j)			if tempi >= tempj then		    		j = j + gap		    		break			end if			x(j+gap) = tempj			if j <= gap then		    		break			end if			j = j - gap	    	wend	    	x(j) = tempi	next i	if gap = 1 then	   	return	else	   	gap = int(gap / 3.5) + 1	end if   wendend sub if peek\$("library") = "main" then 	clear screen 	ITEMS = 100	dim numeros(ITEMS) 	for n = 1 to ITEMS		numeros(n) = ran(ITEMS + 1)	next n 	print time\$	shell_sort(numeros())	print time\$	print "Press a key to see ordered numbers."	inkey\$ 	for n = 1 to ITEMS		print numeros(n),", ";	next n end if`

## Yorick

In Yorick, sort returns an index list into the array that will put it in sorted order.

` nums = [2,4,3,1,2];nums = nums(sort(nums)); `

## zkl

`a:=L(4,5,2,6); a.sort(); a.println() //--> L(2,4,5,6)`
`a:=T(4,5,2,6); b:=a.sort();b.println(); //--> L(2,4,5,6)a.println(); //--> L(4,5,2,6)`