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
<lang 4d>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 order SORT ARRAY($nums;<) ` sort in descending order</lang>
Français
<lang 4d>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 croissant TRIER TABLEAU($nombres;<) ` pour effectuer un tri par ordre décroissant</lang>
ActionScript
<lang 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);</lang>
Ada
<lang ada>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 2007 with 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;</lang>
ALGOL 68
<lang algol68>CO PR READ "shell_sort.a68" PR CO MODE 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))</lang> Output:
+1 +2 +2 +3 +4
APL
<lang apl> X←63 92 51 92 39 15 43 89 36 69
X[⍋X]
15 36 39 43 51 63 69 89 92 92</lang>
AutoHotkey
<lang AutoHotkey>numbers = 5 4 1 2 3 sort, numbers, N D%A_Space% Msgbox % numbers</lang>
AWK
<lang AWK>
- syntax: GAWK -f SORT_AN_INTEGER_ARRAY.AWK
BEGIN {
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)
} </lang>
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
BBC BASIC
Uses the supplied SORTLIB library. <lang bbcbasic> 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%)</lang>
Output:
1, 2, 3, 4, 5, 6, 7, 8, 9
Befunge
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. <lang Befunge>v > 543** > :#v_ $&> :#v_ 1 > :0g > :#v_ $ 1+: 543** `! #v_ 25*,@
^-1p0\0:< ^-1 p0\+1 g0:&< ^-1\.:\<
^ <</lang>
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: <lang bracmat>{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);</lang>
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
<lang burlesque>{1 3 2 5 4}><</lang>
C
<lang 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;
}</lang>
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++
Simple Array
<lang cpp>#include <algorithm>
int main() {
int nums[] = {2,4,3,1,2};
std::sort(nums, nums+sizeof(nums));
return 0;
}</lang>
std::vector
<lang cpp>#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;
}</lang>
std::list
<lang cpp>#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;
}</lang>
C#
<lang csharp>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);
}
}</lang>
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. <lang clean>import StdEnv
sortArray :: (a e) -> a e | Array a e & Ord e sortArray array = {y \\ y <- sort [x \\ x <-: array]}
Start :: {#Int} Start = sortArray {2, 4, 3, 1, 2}</lang>
Clojure
<lang clojure>(sort [5 4 3 2 1]) ; sort can also take a comparator function (1 2 3 4 5)</lang>
COBOL
<lang 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
.</lang>
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: <lang lisp>CL-USER> (sort #(9 -2 1 2 8 0 1 2) #'<)
- (-2 0 1 1 2 2 8 9)</lang>
D
<lang 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]);
}</lang>
Delphi
<lang Delphi>uses Types, Generics.Collections;
var
a: TIntegerDynArray;
begin
a := TIntegerDynArray.Create(5, 4, 3, 2, 1); TArray.Sort<Integer>(a);
end;</lang>
Déjà Vu
<lang dejavu>!. sort [ 5 4 3 2 1 ]</lang>
- Output:
[ 1 2 3 4 5 ]
DWScript
<lang Delphi>var a : array of Integer := [5, 4, 3, 2, 1]; a.Sort; // ascending natural sort PrintLn(a.Map(IntToStr).Join(',')); // 1,2,3,4,5</lang>
E
<lang e>[2,4,3,1,2].sort()</lang>
Erlang
<lang erlang>List = [2, 4, 3, 1, 2]. SortedList = lists:sort(List).</lang>
Euphoria
<lang euphoria>include sort.e print(1,sort({20, 7, 65, 10, 3, 0, 8, -60}))</lang>
EGL
The following works in EDT with Rich UI and stand-alone programs. <lang EGL>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</lang>
The following works in RBD but only with Rich UI programs. <lang EGL>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</lang>
Factor
<lang factor>{ 1 4 9 2 3 0 5 } natural-sort .</lang>
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
<lang forth>create test-data 2 , 4 , 3 , 1 , 2 , test-data 5 cell-sort</lang>
Fortran
<lang fortran>CALL ISORT@(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.</lang>
F#
<lang fsharp>// sorting an array in place let nums = [| 2; 4; 3; 1; 2 |] Array.sortInPlace nums
// create a sorted copy of a list let nums2 = [2; 4; 3; 1; 2] let sorted = List.sort nums2</lang>
GAP
<lang 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 place
Sort(a); a;
- [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
- Sort without changing the argument
SortedList(b);
- [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
b;
- [ 8, 2, 5, 9, 1, 3, 6, 7, 4 ]</lang>
Go
<lang go>package main import "fmt" import "sort"
func main() {
nums := []int {2, 4, 3, 1, 2}
sort.Ints(nums)
fmt.Println(nums)
}</lang>
Golfscript
<lang golfscript>[2 4 3 1 2]$</lang>
Groovy
<lang groovy>println ([2,4,0,3,1,2,-12].sort())</lang>
Output:
[-12, 0, 1, 2, 2, 3, 4]
Haskell
<lang haskell>nums = [2,4,3,1,2] :: [Int] sorted = List.sort nums</lang>
HicEst
<lang hicest>DIMENSION array(100)
array = INT( RAN(100) ) SORT(Vector=array, Sorted=array) </lang>
IDL
<lang idl>result = array[sort(array)]</lang>
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. <lang Icon>S := sort(L:= [63, 92, 51, 92, 39, 15, 43, 89, 36, 69]) # will sort a list</lang>
Io
<lang lua>mums := list(2,4,3,1,2) sorted := nums sort # returns a new sorted array. 'nums' is unchanged nums sortInPlace # sort 'nums' "in-place"</lang>
Inform 7
<lang inform7>let L be {5, 4, 7, 1, 18}; sort L;</lang>
J
<lang j>/:~</lang> The verb /:~ sorts anything. For example:
<lang j> ] a=: 10 ?@$ 100 NB. random vector 63 92 51 92 39 15 43 89 36 69
/:~ a
15 36 39 43 51 63 69 89 92 92</lang>
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.
This code also applies to any data type.
Java
Array
<lang java>import java.util.Arrays;
public class example {
public static void main(String[] args)
{
int[] nums = {2,4,3,1,2};
Arrays.sort(nums);
}
}</lang>
List
<lang java5>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);
}
}</lang>
JavaScript
JavaScript sorts lexically by default, so "10000" comes before "2". To sort numerically, a custom comparator is used.
<lang javascript>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);</lang>
Lasso
<lang 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</lang>
Julia
Julia has both out-of-place (sort) and in-place (sort!) sorting functions in its standard-library:
<lang julia>julia> a = [4,2,3,1]
4-element Int32 Array:
4 2 3 1
julia> sort(a) #out-of-place/non-mutating sort 4-element Int32 Array:
1 2 3 4
julia> a 4-element Int32 Array:
4 2 3 1
julia> sort!(a) # in-place/mutating sort 4-element Int32 Array:
1 2 3 4
julia> a 4-element Int32 Array:
1 2 3 4</lang>
K
<lang k> num: -10?10 / Integers from 0 to 9 in random order 5 9 4 2 0 3 6 1 8 7
srt: {x@<x} / Generalized sort ascending
srt num
0 1 2 3 4 5 6 7 8 9</lang>
Liberty BASIC
LB has an array-sort command. Parameters are arrayname, start term, finish term. <lang lb>N =20 dim IntArray( N)
print "Original order" for i =1 to N
t =int( 1000 *rnd( 1)) IntArray( i) =t print t
next i
sort IntArray(), 1, N
print "Sorted oprder" for i =1 to N
print IntArray( i)
next i</lang>
LiveCode
LiveCode can sort lines or items natively. The delimiter for items can be set to any single character, but defaults to comma. <lang LiveCode>put "3,2,5,4,1" into X sort items of X numeric put X -- outputs "1,2,3,4,5"</lang>
Lua
<lang lua>t = {4, 5, 2} table.sort(t) print(unpack(t))</lang>
Maple
<lang Maple>sort([5,7,8,3,6,1]); sort(Array([5,7,8,3,6,1]))</lang>
Mathematica
<lang mathematica>numbers = Sort[{2,4,3,1,2}]</lang>
MATLAB
<lang 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)</lang>
Maxima
<lang maxima>sort([9, 4, 3, 7, 6, 1, 10, 2, 8, 5]);</lang>
MAXScript
<lang maxscript>arr = #(5, 4, 3, 2, 1) arr = sort arr</lang>
Mercury
<lang>:- 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).</lang>
Modula-3
Modula-3 provides a generic ArraySort module, as well as an instance of that module for integers called IntArraySort. <lang modula3>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.</lang>
MUMPS
<lang 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</lang>
Output:
USER>W $$SORTARRAY^ROSETTA("3,5,1,99,27,16,0,-1",",")
-1,0,1,3,5,16,27,99
Nemerle
<lang 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);
}
}</lang> Output:
[1, 5, 3, 7, 2, 8, 3, 9] [1, 2, 3, 3, 5, 7, 8, 9]
NetRexx
<lang 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 results method 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</lang>
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:
<lang NetRexx>/* 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]= 1 a[ 2]= 0 a[ 3]= -1 a[ 4]= 0 a[ 5]= 5 a[ 6]= 0 a[ 7]= -61 a[ 8]= 0 a[ 9]= 1385 a[10]= 0 a[11]= -50521 a[12]= 0 a[13]= 2702765 a[14]= 0 a[15]= -199360981 a[16]= 0 a[17]= 19391512145 a[18]= 0 a[19]= -2404879675441 a[20]= 0 a[21]= 370371188237525
size = 21 /*we have a list of 21 Euler numbers.*/ tell('un-sorted', a, size) a[0] = size esort(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</lang>
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
<lang NetRexx>/* 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 = 0 loop j = 1 for size
a[j] = list.word(j) end j
say ' as is='list a[0] = size esort(a, size) bList =
loop j = 1 for size
bList = bList a[j] end j
blist = bList.strip say ' 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</lang>
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
<lang nial>sort >= 9 6 8 7 1 10 = 10 9 8 7 6 1</lang>
Nimrod
<lang nimrod>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)</lang>
- Output:
1 2 3 4 5 6 7 8 9
Niue
Library <lang Niue>2 6 1 0 3 8 sort .s 0 1 2 3 6 8</lang>
Objective-C
<lang objc>NSArray *nums = @[@2, @4, @3, @1, @2]; NSArray *sorted = [nums sortedArrayUsingSelector:@selector(compare:)];</lang>
Objeck
<lang objeck>bundle Default {
class Sort {
function : Main(args : System.String[]) ~ Nil {
nums := Structure.IntVector->New([2,4,3,1,2]);
nums->Sort();
}
}
}</lang>
OCaml
Array
<lang ocaml>let nums = [|2; 4; 3; 1; 2|] Array.sort compare nums</lang>
List
<lang ocaml>let nums = [2; 4; 3; 1; 2] let sorted = List.sort compare nums</lang>
Octave
The variable v can be a vector or a matrix (columns will be sorted).
<lang octave>sortedv = sort(v);</lang>
ooRexx
<lang rexx>a = .array~of(4, 1, 6, -2, 99, -12) a~sortWith(.numbercomparator~new) say "The sorted numbers are" do num over a
say num
end
-- a custom comparator that sorts strings as numeric values rather than -- strings
- class numberComparator subclass comparator
- method compare
use strict arg left, right -- perform the comparison on the names. By subtracting -- the two and returning the sign, we give the expected -- results for the compares return (left - right)~sign</lang>
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: <lang c>#include <order/interpreter.h>
ORDER_PP( 8seq_sort(8less, 8seq(2, 4, 3, 1, 2)) )</lang>
Oz
<lang oz>declare
Nums = [2 4 3 1 2]
Sorted = {List.sort Nums Value.'<'}
in
{Show Sorted}</lang>
PARI/GP
<lang parigp>vecsort(v)</lang>
Perl
<lang perl>@nums = (2,4,3,1,2); @sorted = sort {$a <=> $b} @nums;</lang>
Perl 6
If @a contains only numbers:
<lang perl6>my @sorted = sort @a;</lang>
If some elements of @a are strings or are otherwise non-numeric but you want to treat them as numbers:
<lang perl6>my @sorted = sort +*, @a;</lang>
For an in-place sort:
<lang perl6>@a .= sort;</lang>
PHP
<lang php><?php $nums = array(2,4,3,1,2); sort($nums); ?></lang>
PicoLisp
The sort function in PicoLisp returns already by default an ascending list (of any type, not only integers): <lang PicoLisp>(sort (2 4 3 1 2)) -> (1 2 2 3 4)</lang>
PL/I
<lang pli>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;</lang>
Pop11
Pop11 library function sorts lists. So we first convert array to list, then sort and finally convert back:
<lang pop11>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 were
destvector(ar);
- conslist uses the items left on the stack plus the integer, to make a list of those items.
lvars ls = conslist();
- Sort it
sort(ls) -> ls;
- Convert list to array
destlist(ls); consvector() -> ar;</lang>
The above can be abbreviated to more economical, but possibly more opaque, syntax, using pop11 as a functional language:
<lang pop11>lvars ar = {2 4 3 1 2}; consvector(destlist(sort(conslist(destvector(ar))))) -> ar;
- print the sorted vector
ar =>
- {1 2 2 3 4}</lang>
(The list created by conslist will be garbage-collected.)
Alternatively, using the datalist function, even more economically:
<lang pop11>lvars ar = {2 4 3 1 2}; consvector(destlist(sort(datalist(ar)))) -> ar;</lang>
or in Forth-like pop11 postfix syntax:
<lang pop11>lvars ar = {2 4 3 1 2}; ar.datalist.sort.destlist.consvector -> ar;</lang>
PowerBASIC
PowerBASIC has several options available for sorting. At its simplest, an array (of any type) is sorted using ARRAY SORT:
<lang powerbasic>ARRAY SORT x()</lang>
Options are available to limit sorting to only part of the array, collate string arrays, sort multiple arrays together, etc. (Details here.)
PowerShell
<lang powershell>34,12,23,56,1,129,4,2,73 | Sort-Object</lang>
Prolog
?- msort([10,5,13,3, 85,3,1], L). L = [1,3,3,5,10,13,85].
Note that sort/2 remove duplicates.
PureBasic
<lang PureBasic>Dim numbers(20) For i = 0 To 20
numbers(i) = Random(1000)
Next
SortArray(numbers(), #PB_Sort_Ascending)</lang>
Protium
Sorting a list of numbers as strings and as numbers (from the manual.) <lang html>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</@></lang>
Output <lang html>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^</lang>
Python
<lang python>nums = [2,4,3,1,2] nums.sort()</lang>
Note: The array nums is sorted in place.
Interpreter: Python 2.4 (and above)
You could also use the built-in sorted() function
<lang python>nums = sorted([2,4,3,1,2])</lang>
R
<lang r>nums <- c(2,4,3,1,2) sorted <- sort(nums)</lang>
Racket
<lang Racket> -> (sort '(1 9 2 8 3 7 4 6 5) <) '(1 2 3 4 5 6 7 8 9) </lang>
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). <lang rascal>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]</lang>
Raven
Sort list in place:
<lang raven>[ 2 4 3 1 2 ] sort</lang>
REBOL
<lang rebol>sort [2 4 3 1 2]</lang>
REXX
sort an array
This REXX version creates an array with over a score of Euler numbers (integers), then sorts it. <lang rexx>/*REXX program to sort (E-sort) an array (which contains integers). */
numeric digits 30 /*handle larger numbers.*/ a.1= 1 a.2= 0 a.3= -1 a.4= 0 a.5= 5 a.6= 0 a.7= -61 a.8= 0 a.9= 1385
a.10= 0 a.11= -50521 a.12= 0 a.13= 2702765 a.14= 0 a.15= -199360981 a.16= 0 a.17= 19391512145 a.18= 0 a.19= -2404879675441 a.20= 0 a.21= 370371188237525
size=21 /*have a list of 21 Euler numbers*/ call tell 'un-sorted' call esort size call tell ' sorted' exit /*stick a fork in it, we're done.*/ /*──────────────────────────────────ESORT subroutine────────────────────*/ esort: procedure expose a.; parse arg N; h=N
do while h>1; h=h%2
do i=1 for N-h; j=i; k=h+i
do while a.k<a.j
parse value a.j a.k with a.k a.j /*swap two elements.*/
if h>=j then leave; j=j-h; k=k-h
end /*while a.k<a.j*/
end /*i*/
end /*while h>1*/
return /*──────────────────────────────────TELL subroutine─────────────────────*/ tell: say center(arg(1),50,'─')
do j=1 for size
say arg(1) 'array element' right(j,length(size))'='right(a.j,20)
end /*j*/
say return</lang> 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
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,
sorted, than the list is re-constituted.
<lang rexx>/*REXX program sorts (using E-sort) a list of some interesting integers.*/
/*quotes aren't needed if all elements in a list are non-negative.*/
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 /*throw 'em───>a pot*/ say 'original =' list /*an annoucement... */ size=words(list) /*nice to have SIZE.*/
do j=1 for size /*build an array, 1 */
a.j=word(list,j) /*element at a time.*/
end /*j*/
call esort size /*sort the stuff. */ bList=a.1 /*start with 1st. */
do k=2 to size /*build a list. */
bList=bList a.k
end /*k*/
say ' sorted =' bList /*show & tell time. */ exit /*stick a fork in it, we're done.*/ /*──────────────────────────────────ESORT subroutine────────────────────*/ esort: procedure expose a.; parse arg N; h=N
do while h>1; h=h%2
do i=1 for N-h; j=i; k=h+i
do while a.k<a.j
parse value a.j a.k with a.k a.j /*swap two elements.*/
if h>=j then leave; j=j-h; k=k-h
end /*while a.k<a.j*/
end /*i*/
end /*while h>1*/
return</lang> output
original = 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
Ruby
<lang ruby>nums = [2,4,3,1,2] sorted = nums.sort # returns a new sorted array. 'nums' is unchanged nums.sort! # sort 'nums' "in-place"</lang>
Rust
Works with Rust 0.11-pre. Uses merge sort in place, allocating ~2*n memory where n is a length of an array. <lang rust>fn main() {
let mut a = vec!(9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
a.sort();
println!("{}", a);
}</lang>
Scala
<lang scala>println(List(5,2,78,2,578,-42).sortWith(_<_)) //--> List(-42, 2, 2, 5, 78, 578)</lang>
Scheme
Same as Common Lisp <lang scheme>(sort #(9 -2 1 2 8 0 1 2) #'<)</lang>
Seed7
<lang seed7>var array integer: nums is [] (2, 4, 3, 1, 2);
nums := sort(nums);</lang>
Slate
<lang slate> #(7 5 2 9 0 -1) sort</lang>
Smalltalk
<lang smalltalk> #(7 5 2 9 0 -1) asSortedCollection</lang> or destructive: <lang smalltalk> #(7 5 2 9 0 -1) sort</lang>
Standard ML
The Standard ML Basis library does not have any sorting facilities. But each implementation of Standard ML has its own.
Array
<lang sml>- 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</lang>
<lang sml>- 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</lang>
List
<lang sml>- 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</lang>
<lang sml>- 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</lang>
Swift
<lang swift>let nums = [2, 4, 3, 1, 2] nums.sort {$0 < $1} println(nums)</lang> or <lang swift>let nums = [2, 4, 3, 1, 2] sort(nums) println(nums)</lang> or <lang swift>let nums = [2, 4, 3, 1, 2] sort(nums) {$0 < $1} println(nums)</lang>
Tcl
<lang tcl>set result [lsort -integer $unsorted_list]</lang>
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:
<lang toka>needs bsort arrayname number_elements bsort</lang>
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).
<lang bash>nums="2 4 3 1 5" sorted=`printf "%s\n" $nums | sort -n` echo $sorted # prints 1 2 3 4 5</lang>
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.
<lang bash>set -A nums 2 4 3 1 5 set -A sorted $(printf "%s\n" ${nums[*]} | sort -n) echo ${sorted[*]} # prints 1 2 3 4 5</lang>
Users of bash, ksh93 and mksh can probably use the nums=(2 4 3 1 2) syntax.
Ursala
using the built in sort operator, -<, with the nleq library function for comparing natural numbers <lang Ursala>#import nat
- cast %nL
example = nleq-< <39,47,40,53,14,23,88,52,78,62,41,92,88,66,5,40></lang> output:
<5,14,23,39,40,40,41,47,52,53,62,66,78,88,88,92>
Wortel
<lang wortel>@sort [39 47 40 53 14 23 88 52 78 62 41 92 88 66 5 40]</lang>
XPL0
<lang XPL0>include c:\cxpl\codes; \intrinsic 'code' declarations
proc SSort(A, N); \Shell sort array in ascending order int A; \address of array int 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); ]</lang>
Output:
1 1 2 3 4 4 5 5 6 9
Yorick
In Yorick, sort returns an index list into the array that will put it in sorted order. <lang yorick> nums = [2,4,3,1,2]; nums = nums(sort(nums)); </lang>
zkl
In place sorting read/write list: <lang zkl>a:=L(4,5,2,6); a.sort(); a.println() //--> L(2,4,5,6)</lang> Sort a read only list: <lang zkl>a:=T(4,5,2,6); b:=a.sort(); b.println(); //--> L(2,4,5,6) a.println(); //--> L(4,5,2,6)</lang>
- Programming Tasks
- Sorting
- 4D
- ActionScript
- Ada
- ALGOL 68
- APL
- AutoHotkey
- AWK
- BBC BASIC
- Befunge
- Bracmat
- Burlesque
- C
- C++
- C sharp
- Clean
- Clojure
- COBOL
- Common Lisp
- D
- Delphi
- Déjà Vu
- DWScript
- E
- Erlang
- Euphoria
- EGL
- Factor
- Fantom
- Forth
- Fortran
- F Sharp
- GAP
- Go
- Golfscript
- Groovy
- Haskell
- HicEst
- IDL
- Icon
- Unicon
- Io
- Inform 7
- J
- Java
- JavaScript
- Lasso
- Julia
- K
- Liberty BASIC
- LiveCode
- Lua
- Maple
- Mathematica
- MATLAB
- Maxima
- MAXScript
- Mercury
- Modula-3
- MUMPS
- Nemerle
- NetRexx
- Nial
- Nimrod
- Niue
- Objective-C
- Objeck
- OCaml
- Octave
- OoRexx
- Order
- Oz
- PARI/GP
- Perl
- Perl 6
- PHP
- PicoLisp
- PL/I
- Pop11
- PowerBASIC
- PowerShell
- Prolog
- PureBasic
- Protium
- Python
- R
- Racket
- Rascal
- Raven
- REBOL
- REXX
- Ruby
- Rust
- Scala
- Scheme
- Seed7
- Slate
- Smalltalk
- Standard ML
- Swift
- Tcl
- TI-83 BASIC
- Toka
- UNIX Shell
- Ursala
- Wortel
- XPL0
- Yorick
- Zkl