Sort an integer array: Difference between revisions
m
→{{header|Wren}}: Minor tidy
m (→{{header|Wren}}: Minor tidy) |
|||
(59 intermediate revisions by 34 users not shown) | |||
Line 1:
{{task|Sorting}}
{{Sorting Algorithm}}
;Task:
Sort an array (or list) of integers in ascending numerical order.
Use a sorting facility provided by the language/library if possible.
<br><br>
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">nums = [2,4,3,1,2]
nums.sort()</syntaxhighlight>
You could also use the built-in sorted() function:
<syntaxhighlight lang="11l">nums = sorted([2,4,3,1,2])</syntaxhighlight>
=={{header|4D}}==
===English===
<
APPEND TO ARRAY($nums;2)
APPEND TO ARRAY($nums;4)
Line 16 ⟶ 27:
APPEND TO ARRAY($nums;2)
SORT ARRAY($nums) ` sort in ascending order
SORT ARRAY($nums;<) ` sort in descending order</
===Français===
<
AJOUTER A TABLEAU($nombres;2)
AJOUTER A TABLEAU($nombres;4)
Line 27 ⟶ 38:
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</
=={{header|8th}}==
<
[ 10,2,100 ] ' n:cmp a:sort . cr
</syntaxhighlight>
Output is: [2,10,100]
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program integerSort64.s with selection sort */
/*******************************************/
/* Constantes file */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeConstantesARM64.inc"
/*********************************/
/* Initialized data */
/*********************************/
.data
szMessSortOk: .asciz "Table sorted.\n"
szMessSortNok: .asciz "Table not sorted !!!!!.\n"
sMessResult: .asciz "Value : @ \n"
szCarriageReturn: .asciz "\n"
.align 4
#TableNumber: .quad 1,3,6,2,5,9,10,8,4,7
TableNumber: .quad 10,9,8,7,6,5,4,3,2,1
.equ NBELEMENTS, (. - TableNumber) / 8
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
sZoneConv: .skip 24
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: // entry of program
ldr x0,qAdrTableNumber // address number table
mov x1,0
mov x2,NBELEMENTS // number of élements
bl selectionSort
ldr x0,qAdrTableNumber // address number table
bl displayTable
ldr x0,qAdrTableNumber // address number table
mov x1,NBELEMENTS // number of élements
bl isSorted // control sort
cmp x0,1 // sorted ?
beq 1f
ldr x0,qAdrszMessSortNok // no !! error sort
bl affichageMess
b 100f
1: // yes
ldr x0,qAdrszMessSortOk
bl affichageMess
100: // standard end of the program
mov x0,0 // return code
mov x8,EXIT // request to exit program
svc 0 // perform the system call
qAdrsZoneConv: .quad sZoneConv
qAdrszCarriageReturn: .quad szCarriageReturn
qAdrsMessResult: .quad sMessResult
qAdrTableNumber: .quad TableNumber
qAdrszMessSortOk: .quad szMessSortOk
qAdrszMessSortNok: .quad szMessSortNok
/******************************************************************/
/* control sorted table */
/******************************************************************/
/* x0 contains the address of table */
/* x1 contains the number of elements > 0 */
/* x0 return 0 if not sorted 1 if sorted */
isSorted:
stp x2,lr,[sp,-16]! // save registers
stp x3,x4,[sp,-16]! // save registers
mov x2,0
ldr x4,[x0,x2,lsl 3]
1:
add x2,x2,1
cmp x2,x1
bge 99f
ldr x3,[x0,x2, lsl 3]
cmp x3,x4
blt 98f
mov x4,x3
b 1b
98:
mov x0,0 // not sorted
b 100f
99:
mov x0,1 // sorted
100:
ldp x3,x4,[sp],16 // restaur 2 registers
ldp x2,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
/******************************************************************/
/* selection sort */
/******************************************************************/
/* x0 contains the address of table */
/* x1 contains the first element */
/* x2 contains the number of element */
selectionSort:
stp x1,lr,[sp,-16]! // save registers
stp x2,x3,[sp,-16]! // save registers
stp x4,x5,[sp,-16]! // save registers
stp x6,x7,[sp,-16]! // save registers
mov x3,x1 // start index i
sub x7,x2,1 // compute n - 1
1: // start loop
mov x4,x3
add x5,x3,1 // init index 2
2:
ldr x1,[x0,x4,lsl 3] // load value A[mini]
ldr x6,[x0,x5,lsl 3] // load value A[j]
cmp x6,x1 // compare value
csel x4,x5,x4,lt // j -> mini
add x5,x5,1 // increment index j
cmp x5,x2 // end ?
blt 2b // no -> loop
cmp x4,x3 // mini <> j ?
beq 3f // no
ldr x1,[x0,x4,lsl 3] // yes swap A[i] A[mini]
ldr x6,[x0,x3,lsl 3]
str x1,[x0,x3,lsl 3]
str x6,[x0,x4,lsl 3]
3:
add x3,x3,1 // increment i
cmp x3,x7 // end ?
blt 1b // no -> loop
100:
ldp x6,x7,[sp],16 // restaur 2 registers
ldp x4,x5,[sp],16 // restaur 2 registers
ldp x2,x3,[sp],16 // restaur 2 registers
ldp x1,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
/******************************************************************/
/* Display table elements */
/******************************************************************/
/* x0 contains the address of table */
displayTable:
stp x1,lr,[sp,-16]! // save registers
stp x2,x3,[sp,-16]! // save registers
mov x2,x0 // table address
mov x3,0
1: // loop display table
ldr x0,[x2,x3,lsl 3]
ldr x1,qAdrsZoneConv
bl conversion10 // décimal conversion
ldr x0,qAdrsMessResult
ldr x1,qAdrsZoneConv
bl strInsertAtCharInc // insert result at @ character
bl affichageMess // display message
add x3,x3,1
cmp x3,NBELEMENTS - 1
ble 1b
ldr x0,qAdrszCarriageReturn
bl affichageMess
100:
ldp x2,x3,[sp],16 // restaur 2 registers
ldp x1,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
/********************************************************/
/* File Include fonctions */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
<syntaxhighlight lang="action!">INCLUDE "D2:SORT.ACT" ;from the Action! Tool Kit
PROC PrintArray(INT ARRAY a INT size)
INT i
Put('[)
FOR i=0 TO size-1
DO
IF i>0 THEN Put(' ) FI
PrintI(a(i))
OD
Put(']) PutE()
RETURN
PROC Test(INT ARRAY a INT size BYTE order)
PrintE("Array before sort:")
PrintArray(a,size)
SortI(a,size,order)
PrintE("Array after sort:")
PrintArray(a,size)
PutE()
RETURN
PROC Main()
DEFINE ASCENDING="0"
INT ARRAY
a(10)=[1 4 65535 0 3 7 4 8 20 65530],
b(21)=[10 9 8 7 6 5 4 3 2 1 0
65535 65534 65533 65532 65531
65530 65529 65528 65527 65526],
c(8)=[101 102 103 104 105 106 107 108],
d(12)=[1 65535 1 65535 1 65535 1
65535 1 65535 1 65535]
Put(125) PutE() ;clear screen
Test(a,10,ASCENDING)
Test(b,21,ASCENDING)
Test(c,8,ASCENDING)
Test(d,12,ASCENDING)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sort_an_integer_array.png Screenshot from Atari 8-bit computer]
<pre>
Array before sort:
[1 4 -1 0 3 7 4 8 20 -6]
Array after sort:
[-6 -1 0 1 3 4 4 7 8 20]
Array before sort:
[10 9 8 7 6 5 4 3 2 1 0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10]
Array after sort:
[-10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 9 10]
Array before sort:
[101 102 103 104 105 106 107 108]
Array after sort:
[101 102 103 104 105 106 107 108]
Array before sort:
[1 -1 1 -1 1 -1 1 -1 1 -1 1 -1]
Array after sort:
[-1 -1 -1 -1 -1 -1 1 1 1 1 1 1]
</pre>
=={{header|ActionScript}}==
<
function compare(x:int, y:int):Number
{
Line 41 ⟶ 287:
}
var nums:Vector.<int> = Vector.<int>([5,12,3,612,31,523,1,234,2]);
nums.sort(compare);</
=={{header|Ada}}==
{{works with|GNAT|GPL 2006}}
<
procedure Integer_Sort is
Line 87 ⟶ 333:
begin
Sort(Values);
end Integer_Sort;</
=={{header|ALGOL 68}}==
Line 95 ⟶ 341:
{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}
{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386}}
<
MODE TYPE = INT;
Line 118 ⟶ 364:
in place shell sort(LOC[LWB seq: UPB seq]TYPE:=seq);
print((shell sort((2, 4, 3, 1, 2)), new line))</
Output:
<pre>
+1 +2 +2 +3 +4
</pre>
=={{header|ALGOL W}}==
Algol W doesn't have standard sorting facilities. This uses the Algol W quicksort sample in the Sorting Algorithms Quicksort task.
<syntaxhighlight lang="algolw">begin
% use the quicksort procedure from the Sorting_Algorithms/Quicksort task %
% Quicksorts in-place the array of integers v, from lb to ub - external %
procedure quicksort ( integer array v( * )
; integer value lb, ub
) ; algol "sortingAlgorithms_Quicksort" ;
% sort an integer array with the quicksort routine %
begin
integer array t ( 1 :: 5 );
integer p;
p := 1;
for v := 2, 3, 1, 9, -2 do begin t( p ) := v; p := p + 1; end;
quicksort( t, 1, 5 );
for i := 1 until 5 do writeon( i_w := 1, s_w := 1, t( i ) )
end
end.</syntaxhighlight>
{{out}}
<pre>
-2 1 2 3 9
</pre>
=={{header|APL}}==
{{works with|APL2}}
<
X[⍋X]
15 36 39 43 51 63 69 89 92 92</
=={{header|AppleScript}}==
Line 141 ⟶ 409:
for which AppleScript was presumably designed.
<
-- sort :: [a] -> [a]
Line 183 ⟶ 451:
end script
end if
end mReturn</
{{Out}}
<pre>{{0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9},
{"alpha", "beta", "delta", "epsilon", "eta", "gamma",
"iota", "kappa", "lambda", "mu", "theta", "zeta"}}</pre>
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
/* program integerSort.s with selection sort */
/* REMARK 1 : this program use routines in a include file
see task Include a file language arm assembly
for the routine affichageMess conversion10
see at end of this program the instruction include */
/* for constantes see task include a file in arm assembly */
/************************************/
/* Constantes */
/************************************/
.include "../constantes.inc"
/*********************************/
/* Initialized data */
/*********************************/
.data
szMessSortOk: .asciz "Table sorted.\n"
szMessSortNok: .asciz "Table not sorted !!!!!.\n"
sMessResult: .asciz "Value : @ \n"
szCarriageReturn: .asciz "\n"
.align 4
TableNumber: .int 1,3,6,2,5,9,10,8,4,7
#TableNumber: .int 10,9,8,7,6,5,4,3,2,1
.equ NBELEMENTS, (. - TableNumber) / 4
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
sZoneConv: .skip 24
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: @ entry of program
1:
ldr r0,iAdrTableNumber @ address number table
mov r1,#0
mov r2,#NBELEMENTS @ number of élements
bl selectionSort
ldr r0,iAdrTableNumber @ address number table
bl displayTable
ldr r0,iAdrTableNumber @ address number table
mov r1,#NBELEMENTS @ number of élements
bl isSorted @ control sort
cmp r0,#1 @ sorted ?
beq 2f
ldr r0,iAdrszMessSortNok @ no !! error sort
bl affichageMess
b 100f
2: @ yes
ldr r0,iAdrszMessSortOk
bl affichageMess
100: @ standard end of the program
mov r0, #0 @ return code
mov r7, #EXIT @ request to exit program
svc #0 @ perform the system call
iAdrszCarriageReturn: .int szCarriageReturn
iAdrsMessResult: .int sMessResult
iAdrTableNumber: .int TableNumber
iAdrszMessSortOk: .int szMessSortOk
iAdrszMessSortNok: .int szMessSortNok
/******************************************************************/
/* control sorted table */
/******************************************************************/
/* r0 contains the address of table */
/* r1 contains the number of elements > 0 */
/* r0 return 0 if not sorted 1 if sorted */
isSorted:
push {r2-r4,lr} @ save registers
mov r2,#0
ldr r4,[r0,r2,lsl #2]
1:
add r2,#1
cmp r2,r1
movge r0,#1
bge 100f
ldr r3,[r0,r2, lsl #2]
cmp r3,r4
movlt r0,#0
blt 100f
mov r4,r3
b 1b
100:
pop {r2-r4,lr}
bx lr @ return
/******************************************************************/
/* selection sort */
/******************************************************************/
/* r0 contains the address of table */
/* r1 contains the first element */
/* r2 contains the number of element */
selectionSort:
push {r1-r7,lr} @ save registers
mov r3,r1 @ start index i
sub r7,r2,#1 @ compute n - 1
1: @ start loop
mov r4,r3
add r5,r3,#1 @ init index 2
2:
ldr r1,[r0,r4,lsl #2] @ load value A[mini]
ldr r6,[r0,r5,lsl #2] @ load value A[j]
cmp r6,r1 @ compare value
movlt r4,r5 @ j -> mini
add r5,#1 @ increment index j
cmp r5,r2 @ end ?
blt 2b @ no -> loop
cmp r4,r3 @ mini <> j ?
beq 3f @ no
ldr r1,[r0,r4,lsl #2] @ yes swap A[i] A[mini]
ldr r6,[r0,r3,lsl #2]
str r1,[r0,r3,lsl #2]
str r6,[r0,r4,lsl #2]
3:
add r3,#1 @ increment i
cmp r3,r7 @ end ?
blt 1b @ no -> loop
100:
pop {r1-r7,lr}
bx lr @ return
/******************************************************************/
/* Display table elements */
/******************************************************************/
/* r0 contains the address of table */
displayTable:
push {r0-r3,lr} @ save registers
mov r2,r0 @ table address
mov r3,#0
1: @ loop display table
ldr r0,[r2,r3,lsl #2]
ldr r1,iAdrsZoneConv @
bl conversion10 @ décimal conversion
ldr r0,iAdrsMessResult
ldr r1,iAdrsZoneConv @ insert conversion
bl strInsertAtCharInc
bl affichageMess @ display message
add r3,#1
cmp r3,#NBELEMENTS - 1
ble 1b
ldr r0,iAdrszCarriageReturn
bl affichageMess
100:
pop {r0-r3,lr}
bx lr
iAdrsZoneConv: .int sZoneConv
/***************************************************/
/* ROUTINES INCLUDE */
/***************************************************/
.include "../affichage.inc"
</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">arr: [2 3 5 8 4 1 6 9 7]
sort 'arr ; in-place
loop arr => print</syntaxhighlight>
{{out}}
<pre>1
2
3
4
5
6
7
8
9</pre>
=={{header|AutoHotkey}}==
<
sort, numbers, N D%A_Space%
Msgbox % numbers</
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f SORT_AN_INTEGER_ARRAY.AWK
BEGIN {
Line 212 ⟶ 658:
printf("\t%s\n",description)
}
</syntaxhighlight>
<p>output:</p>
<pre>
Line 223 ⟶ 669:
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.
<
4→{L₁+1}
3→{L₁+2}
Line 229 ⟶ 675:
2→{L₁+4}
SortD(L₁,5)</
=={{header|Babel}}==
Line 235 ⟶ 681:
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.
<
( 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 sorting
babel> dup {fnord} merge_sort --> The internal sort operator
babel> 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> {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:
<
( 90 89 88 86 83 83 75 73 68 67 63 54 53 49 46 34 28 21 20 9 )</
=={{header|BaCon}}==
<
DECLARE values[5] TYPE NUMBER
values[0] = 23
Line 267 ⟶ 713:
PRINT values[i], ", ";
NEXT
PRINT values[4]</
{{out}}
Line 277 ⟶ 723:
{{works with|BBC BASIC for Windows}}
Uses the supplied SORTLIB library.
<
sort% = FN_sortinit(0,0)
Line 289 ⟶ 735:
PRINT ; array(i%) ", ";
NEXT
PRINT ; array(i%)</
Output:
<pre>
1, 2, 3, 4, 5, 6, 7, 8, 9
</pre>
=={{header|Beads}}==
<syntaxhighlight lang="beads">beads 1 program 'Sort an integer array'
calc main_init
var arr = [4, 1, 2, -1, 3, 0, 2]
var newarr : array of num
loop across:arr sort:val count:c val:v
newarr[c] = v</syntaxhighlight>
=={{header|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.
<syntaxhighlight lang="befunge">v
> 543** > :#v_ $&> :#v_ 1 > :0g > :#v_ $ 1+: 543** `! #v_ 25*,@
^-1p0\0:< ^-1 p0\+1 g0:&< ^-1\.:\<
^ <</
=={{header|BQN}}==
<syntaxhighlight lang="bqn">∧ [4, 1, 2, ¯9, ¯5, 3, 6, 9, ¯2]</syntaxhighlight>
{{out}}
<pre>⟨ ¯9 ¯5 ¯2 1 2 3 4 6 9 ⟩</pre>
=={{header|Bracmat}}==
Line 315 ⟶ 774:
{!} 21</pre>
To complete the task need to unfold the terms with a numerical factor >1:
<
(sort=
sum elem sorted n
Line 331 ⟶ 790:
& !sorted);
out$sort$(9 -2 1 2 8 0 1 2);</
{{out}}
<pre>-2 0 1 1 2 2 8 9</pre>
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.
Line 338 ⟶ 797:
=={{header|Burlesque}}==
<
=={{header|C}}==
<
#include <stdio.h> /* printf() */
Line 357 ⟶ 816:
nums[0], nums[1], nums[2], nums[3], nums[4]);
return 0;
}</
''Caution:'' An older version of <tt>intcmp()</tt> did <tt>return *a - *b</tt>. This is only correct when the subtraction does not overflow. Suppose that <tt>*a = 2000000000</tt> and <tt>*b = -2000000000</tt> on a machine with 32-bit <tt>int</tt>. The subtraction <tt>*a - *b</tt> would overflow to <tt>-294967296</tt>, and <tt>intcmp()</tt> would believe <tt>*a < *b</tt>, but the correct answer is <tt>*a > *b</tt>.
=={{header|C sharp|C#}}==
<syntaxhighlight 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);
}
}</syntaxhighlight>
=={{header|C++}}==
Line 365 ⟶ 836:
===Simple Array===
<
int main()
Line 372 ⟶ 843:
std::sort(nums, nums+sizeof(nums)/sizeof(int));
return 0;
}</
===<tt>std::vector</tt>===
<
#include <vector>
Line 388 ⟶ 859:
std::sort(nums.begin(), nums.end());
return 0;
}</
===<tt>std::list</tt>===
<
int main()
Line 403 ⟶ 874:
nums.sort();
return 0;
}</
=={{header|Clean}}==
We use list and array comprehensions to convert an array to and from a list in order to use the built-in <tt>sort</tt> on lists.
<
sortArray :: (a e) -> a e | Array a e & Ord e
Line 425 ⟶ 884:
Start :: {#Int}
Start = sortArray {2, 4, 3, 1, 2}</
=={{header|Clojure}}==
<
(1 2 3 4 5)</
=={{header|COBOL}}==
{{works with|Visual COBOL}}
<
DATA DIVISION.
Line 454 ⟶ 913:
END-PERFORM
DISPLAY SPACE
.</
=={{header|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:
<
#(-2 0 1 1 2 2 8 9)</
=={{header|Crystal}}==
Example demonstrating the support for copy sort and in-place sort (like Ruby)
<syntaxhighlight lang="ruby">
a = [5, 4, 3, 2, 1]
puts a.sort
Line 474 ⟶ 933:
puts a
# => [1, 2, 3, 4, 5]
</syntaxhighlight>
=={{header|D}}==
<
void main() {
Line 483 ⟶ 942:
data.sort(); // in-place
assert(data == [1, 2, 2, 3, 4]);
}</
=={{header|Delphi}}==
<
var
Line 493 ⟶ 952:
a := TIntegerDynArray.Create(5, 4, 3, 2, 1);
TArray.Sort<Integer>(a);
end;</
=={{header|DWScript}}==
<
a.Sort; // ascending natural sort
PrintLn(a.Map(IntToStr).Join(',')); // 1,2,3,4,5</
=={{header|Déjà Vu}}==
<syntaxhighlight lang="dejavu">!. sort [ 5 4 3 2 1 ]</syntaxhighlight>
{{out}}
<pre>[ 1 2 3 4 5 ]</pre>
=={{header|
<syntaxhighlight lang
=={{header|EGL}}==
{{works with|EDT}}
The following works in EDT with Rich UI and stand-alone programs.
<
function main()
Line 555 ⟶ 985:
end
end</
{{works with|RBD}}
The following works in RBD but only with Rich UI programs.
<
RUILib.sort(test1, sortFunction);
Line 564 ⟶ 994:
function sortFunction(a any in, b any in) returns (int)
return ((a as int) - (b as int));
end</
=={{header|Eiffel}}==
[https://github.com/ljr1981/rosettacode_answers/blob/main/testing/rc_array_sort/rc_array_sort_test_set.e Full example code]
Using a SORTED_TWO_WAY_LIST means that the contents of the list will be sorted ascending automatically.
The list can be easily sorted in reverse. There is a call for `sort' to manually initiate sorting.
<syntaxhighlight lang="eiffel">
local
l_array: SORTED_TWO_WAY_LIST [INTEGER]
do
create l_array.make_from_iterable (<<9,8,7,6,5,4,3,2,1,0>>)
end
</syntaxhighlight>
=={{header|Elena}}==
ELENA 5.0 :
<syntaxhighlight lang="elena">import system'routines;
import extensions;
public program()
{
var unsorted := new int[]{6, 2, 7, 8, 3, 1, 10, 5, 4, 9};
console.printLine(unsorted.clone().sort(ifOrdered).asEnumerable())
}</syntaxhighlight>
=={{header|Elixir}}==
<syntaxhighlight lang="elixir">list = [2, 4, 3, 1, 2]
IO.inspect Enum.sort(list)
IO.inspect Enum.sort(list, &(&1>&2))</syntaxhighlight>
{{out}}
<pre>
[1, 2, 2, 3, 4]
[4, 3, 2, 2, 1]
</pre>
=={{header|Erlang}}==
<syntaxhighlight lang="erlang">List = [2, 4, 3, 1, 2].
SortedList = lists:sort(List).</syntaxhighlight>
=={{header|Euphoria}}==
<syntaxhighlight lang="euphoria">include sort.e
print(1,sort({20, 7, 65, 10, 3, 0, 8, -60}))</syntaxhighlight>
=={{header|F_Sharp|F#}}==
<syntaxhighlight 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</syntaxhighlight>
=={{header|Factor}}==
<
=={{header|Fantom}}==
Line 585 ⟶ 1,070:
{{works with|Win32Forth|4.2}}
===Win32Forth===
<
test-data 5 cell-sort
</syntaxhighlight>
===ANS/ISO Forth===
{{works with|GForth}}
Uses quicksort http://rosettacode.org/wiki/Sorting_algorithms/Quicksort#Forth
Standard Forth does not have a library sort
<
CREATE MYARRAY SIZE CELLS ALLOT
Line 634 ⟶ 1,120:
DUP 2 < IF 2DROP EXIT THEN 1- CELLS OVER + QSORT ;</LANG>
Test at the console
<
MYARRAY SIZE QUICKSORT ok
=={{header|Fortran}}==
{{works with|Silverfrost FTN95}}
<
! n = number of elements
! a = array to be sorted
! b = array of indices of a. b(1) 'points' to the minimum value etc.</
=={{header|FreeBASIC}}==
Qsort is not buildin, but include in the compiler package.
<
' compile with: fbc -s console
Line 703 ⟶ 1,189:
Print : Print "hit any key to end program"
Sleep
End</
{{out}}
<pre>unsorted array
Line 713 ⟶ 1,199:
=={{header|Frink}}==
The following sorts an array in-place.
<
sort[a]</
=={{header|FunL}}==
<
println( sort(nums) ) // sort in ascending order
println( nums.sortWith((>)) ) // sort in descending order</
{{out}}
Line 737 ⟶ 1,214:
</pre>
=={{header|
<syntaxhighlight lang="futurebasic">
window 1, @"Sort an integer array"
void local fn DoIt
CFArrayRef array = @[@13,@71,@42,@8,@5,@27]
array = fn ArraySortedArrayUsingSelector( array, @"compare:" )
print fn ArrayComponentsJoinedByString( array, @", " )
end fn
fn DoIt
HandleEvents
</syntaxhighlight>
{{out}}
<pre>
5, 8, 13, 27, 42, 71
</pre>
=={{header|Fōrmulæ}}==
{{FormulaeEntry|page=https://formulae.org/?script=examples/Sort_an_integer_array}}
'''Solution'''
[[File:Fōrmulæ - Sort an integer array 01.png]]
[[File:Fōrmulæ - Sort an integer array 02.png]]
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=1f1d244aa95c329eb87cb538f0d5fc4a Click this link to run this code]'''
<
Dim iArray As Integer[] = [8, 2, 5, 9, 1, 3, 6, 7, 4]
Dim iTemp As Integer
Line 766 ⟶ 1,256:
Print Left(sOutput, -2)
End</
Output:
Line 772 ⟶ 1,262:
1, 2, 3, 4, 5, 6, 7, 8, 9
</pre>
=={{header|GAP}}==
<syntaxhighlight 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 ]</syntaxhighlight>
=={{header|Go}}==
<
import "fmt"
import "sort"
Line 782 ⟶ 1,288:
sort.Ints(nums)
fmt.Println(nums)
}</
=={{header|Golfscript}}==
<
=={{header|Groovy}}==
<
Output:
Line 796 ⟶ 1,302:
{{works with|GHC|GHCi|6.6}}
<
sorted = List.sort nums</
=={{header|HicEst}}==
<
array = INT( RAN(100) )
SORT(Vector=array, Sorted=array) </
=={{header|Huginn}}==
<
nums = [2, 4, 3, 1, 2];
nums.sort();
}</
=={{header|Icon}} and {{header|Unicon}}==
Line 818 ⟶ 1,321:
In the example below, L will remain an unsorted list and S will be sorted.
<
=={{header|IDL}}==
<syntaxhighlight lang="idl">result = array[sort(array)]</syntaxhighlight>
=={{header|Inform 7}}==
<
sort L;</
=={{header|Io}}==
<
sorted := nums sort # returns a new sorted array. 'nums' is unchanged
nums sortInPlace # sort 'nums' "in-place"</
=={{header|J}}==
<syntaxhighlight lang
The verb<tt> /:~ </tt>sorts <i>anything</i> that J can represent. For example:
<
63 92 51 92 39 15 43 89 36 69
/:~ a
15 36 39 43 51 63 69 89 92 92</
Arrays of any rank are treated as lists of component arrays. Thus <tt>/:~</tt> 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 <tt>/:~"1</tt> sorts the atoms within the finest-grained list within the array, regardless of the overall rank of the array. See the [[j:Essays/The_TAO_of_J|Total Array Ordering essay]] on the JWiki for more details.
This code also applies to any data type.
=={{header|Java}}==
===Array===
<
public class
public static void main(String[] args)
{
Line 850 ⟶ 1,357:
Arrays.sort(nums);
}
}</
===List===
{{works with|Java|1.5+}}
<
import java.util.Collections;
import java.util.List;
public class
public static void main(String[] args)
{
Line 864 ⟶ 1,371:
Collections.sort(nums);
}
}</
=={{header|JavaScript}}==
Line 871 ⟶ 1,378:
JavaScript sorts lexically by default, so "10000" comes before "2". To sort numerically, a custom comparator is used.
<
return a - b;
}
var numbers = [20, 7, 65, 10, 3, 0, 8, -60];
numbers.sort(int_arr);
document.write(numbers);</
=={{header|
<syntaxhighlight lang="jinja">
from jinja2 import Template
print(Template("{{ [53, 17, 42, 61, 35] | sort }}").render())
</syntaxhighlight>
Descending order:
<syntaxhighlight lang="jinja">
from jinja2 import Template
print(Template("{{ [53, 17, 42, 61, 35] | sort(reverse=true) }}").render())
</syntaxhighlight>
=={{header|jq}}==
jq's builtin <code>sort</code> filter sorts the elements of an array in ascending order:
<
=={{header|Julia}}==
Julia has both out-of-place (<code>sort</code>) and in-place (<code>sort!</code>) sorting functions in its standard-library:
<
4-element Int32 Array:
4
Line 939 ⟶ 1,434:
2
3
4</
=={{header|K}}==
<
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</
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// 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 = "]"))
}</syntaxhighlight>
{{out}}
<pre>
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
</pre>
=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
1) sorting digits in a number returns a new number of ordered digits
{W.sort < 51324}
-> 12345
2) sorting a sequence of numbers returns a new ordered sequence of these numbers
{S.sort < 51 111 33 2 41}
-> 2 33 41 51 111
3) sorting an array of numbers returns the same array ordered
{A.sort! < {A.new 51 111 33 2 41}}
-> [2,33,41,51,111]
</syntaxhighlight>
=={{header|Lasso}}==
<syntaxhighlight 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</syntaxhighlight>
=={{header|Liberty BASIC}}==
LB has an array-sort command. Parameters are arrayname, start term, finish term.
<
dim IntArray( N)
Line 966 ⟶ 1,499:
for i =1 to N
print IntArray( i)
next i</
=={{header|Lingo}}==
<
l.sort()
put l
-- [4, 7, 23]</
=={{header|LiveCode}}==
LiveCode can sort lines or items natively. The delimiter for items can be set to any single character, but defaults to comma.
<
sort items of X numeric
put X
-- outputs "1,2,3,4,5"</
=={{header|Lua}}==
<
table.sort(t)
print(unpack(t))</
=={{header|Maple}}==
<
sort(Array([5,7,8,3,6,1]))</
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang
=={{header|MATLAB}}==
<
[b,idx] = sort(a) % b contains a(idx)</
=={{header|Maxima}}==
<
=={{header|MAXScript}}==
<
arr = sort arr</
=={{header|Mercury}}==
<syntaxhighlight lang="text">:- module sort_int_list.
:- interface.
:- import_module io.
Line 1,018 ⟶ 1,551:
list.sort(Nums, Sorted),
io.write(Sorted, !IO),
io.nl(!IO).</
=={{header|min}}==
{{works with|min|0.19.3}}
<syntaxhighlight lang="min">(5 2 1 3 4) '> sort print</syntaxhighlight>
{{out}}
<pre>
(1 2 3 4 5)
</pre>
=={{header|Modula-3}}==
Modula-3 provides a generic <tt>ArraySort</tt> module, as well as an instance of that module for integers called <tt>IntArraySort</tt>.
<
IMPORT IntArraySort;
Line 1,031 ⟶ 1,571:
BEGIN
IntArraySort.Sort(arr);
END ArraySort.</
=={{header|MUMPS}}==
<
;X is the list of items to sort
;X1 is the temporary array
Line 1,044 ⟶ 1,585:
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:<pre>USER>W $$SORTARRAY^ROSETTA("3,5,1,99,27,16,0,-1",",")
-1,0,1,3,5,16,27,99
</pre>
=={{header|Nanoquery}}==
'sort' in the Nanoquery standard library has a Quicksort function.
<syntaxhighlight lang="nanoquery">% import sort
% println sort({2,4,3,1,2})
[1, 2, 2, 3, 4]</syntaxhighlight>
=={{header|Neko}}==
<syntaxhighlight lang="actionscript">/**
<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")</syntaxhighlight>
{{out}}
<pre>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]</pre>
=={{header|Nemerle}}==
<
module IntSort
Line 1,062 ⟶ 1,658:
WriteLine(sorted);
}
}</
Output:
<pre>[1, 5, 3, 7, 2, 8, 3, 9]
Line 1,068 ⟶ 1,664:
=={{header|NetRexx}}==
<
options replace format comments java crossref savelog symbols binary
Line 1,089 ⟶ 1,685:
say sorted.strip('t')
return</
'''Output'''
Line 1,099 ⟶ 1,695:
NetRexx reimplementations of the [[#REXX|Rexx]] samples from below:
<
options replace format comments java crossref savelog symbols
Line 1,170 ⟶ 1,766:
say
return</
'''Output'''
Line 1,221 ⟶ 1,817:
</pre>
<
options replace format comments java crossref savelog symbols
Line 1,274 ⟶ 1,870:
end
return</
'''Output'''
Line 1,283 ⟶ 1,879:
=={{header|Nial}}==
<
= 10 9 8 7 6 1</
=={{header|Nim}}==
<
var a: array[0..8, int] = [2, 3, 5, 8, 4, 1, 6, 9, 7]
a.sort(
for x in a:
{{out}}
<pre>1
Line 1,306 ⟶ 1,902:
=={{header|Niue}}==
'''Library'''
<
0 1 2 3 6 8</
=={{header|Objeck}}==
<
class Sort {
function : Main(args : System.String[]) ~ Nil {
Line 1,321 ⟶ 1,913:
}
}
}</
=={{header|Objective-C}}==
<syntaxhighlight lang="objc">NSArray *nums = @[@2, @4, @3, @1, @2];
NSArray *sorted = [nums sortedArrayUsingSelector:@selector(compare:)];</syntaxhighlight>
=={{header|OCaml}}==
===Array===
<
Array.sort compare nums</
===List===
<
let sorted = List.sort compare nums</
=={{header|Octave}}==
Line 1,336 ⟶ 1,932:
The variable <tt>v</tt> can be a vector or a matrix (columns will be sorted).
<
=={{header|Oforth}}==
<
=={{header|ooRexx}}==
<
say "The sorted numbers are"
say a~sortWith(.numericComparator~new)~makeString</
Output:
<pre>
Line 1,359 ⟶ 1,955:
=={{header|Order}}==
Passing the less-than operator to the built-in sequence (i.e. list) sort function:
<
ORDER_PP( 8seq_sort(8less, 8seq(2, 4, 3, 1, 2)) )</
=={{header|Oz}}==
<
Nums = [2 4 3 1 2]
Sorted = {List.sort Nums Value.'<'}
in
{Show Sorted}</
=={{header|PARI/GP}}==
<syntaxhighlight lang
=={{header|Peloton}}==
Sorting a list of numbers as strings and as numbers (from the manual.)
<
<@ LETCNSLSTLIT>L|65^84^1^25^77^4^47^2^42^44^41^25^69^3^51^45^4^39^</@>
Numbers sort as strings
Line 1,389 ⟶ 1,985:
<@ SAYDMPLST>list</@>
<@ ACTSRTENTLSTLIT>list|__NumericDescending</@>
<@ SAYDMPLST>list</@></
Output
<
Numbers sort as strings
Line 1,406 ⟶ 2,002:
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^</
=={{header|Perl}}==
{{works with|Perl|5.8.6}}
<
@sorted = sort {$a <=> $b} @nums;</
=={{header|
{{libheader|Phix/basics}}
<!--<syntaxhighlight lang="phix">-->
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">sort</span><span style="color: #0000FF;">({</span><span style="color: #000000;">9</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">10</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">4</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">5</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">8</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">7</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">6</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">})</span>
<!--</syntaxhighlight>-->
=={{header|Phixmonti}}==
<syntaxhighlight lang="phixmonti">include ..\Utilitys.pmt
( 9 10 3 1 4 5 8 7 6 2 ) sort print</syntaxhighlight>
=={{header|PHP}}==
{{works with|PHP|4.4.4 CLI}}
<
$nums = array(2,4,3,1,2);
sort($nums);
?></
=={{header|PicoLisp}}==
The [http://software-lab.de/doc/refS.html#sort sort] function in PicoLisp
returns already by default an ascending list (of any type, not only integers):
<
-> (1 2 2 3 4)</
=={{header|PL/I}}==
{{works with|IBM PL/I|7.5}}
<
MERGE: PROCEDURE (A,LA,B,LB,C);
Line 1,476 ⟶ 2,071:
CALL MERGE(T,M,AMP1,N-M,A);
RETURN;
END MERGESORT;</
=={{header|Pop11}}==
Pop11 library function sorts lists. So we first convert array to list, then sort and finally convert back:
<
;;; Convert array to list.
;;; destvector leaves its results and on the pop11 stack + an integer saying how many there were
Line 1,491 ⟶ 2,086:
;;; Convert list to array
destlist(ls);
consvector() -> ar;</
The above can be abbreviated to more economical, but possibly more opaque, syntax, using pop11 as a functional language:
<
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.)
Line 1,505 ⟶ 2,100:
Alternatively, using the datalist function, even more economically:
<
consvector(destlist(sort(datalist(ar)))) -> ar;</
or in Forth-like pop11 postfix syntax:
<
ar.datalist.sort.destlist.consvector -> ar;</
=={{header|Potion}}==
<
=={{header|PowerBASIC}}==
PowerBASIC has several options available for sorting. At its simplest, an array (of any type) is sorted using <code>ARRAY SORT</code>:
<syntaxhighlight lang
Options are available to limit sorting to only part of the array, collate string arrays, sort multiple arrays together, etc. (Details [http://www.powerbasic.com/support/help/pbwin/html/ARRAY_SORT_statement.htm here].)
=={{header|PowerShell}}==
<
=={{header|Prolog}}==
Line 1,532 ⟶ 2,127:
=={{header|PureBasic}}==
<
For i = 0 To 20
numbers(i) = Random(1000)
Next
SortArray(numbers(), #PB_Sort_Ascending)</
=={{header|Python}}==
{{works with|Python|2.3}}
<
nums.sort()</
'''Note:''' The array <tt>nums</tt> is sorted in place.
Line 1,550 ⟶ 2,145:
You could also use the built-in sorted() function
<
=={{header|Quackery}}==
As a dialogue in the Quackery shell.
<pre>/O> [] 20 times [ 10 random join ]
... dup echo cr
... sort
... echo cr
...
[ 5 2 5 0 4 5 1 5 1 1 0 3 7 2 0 9 6 1 8 7 ]
[ 0 0 0 1 1 1 1 2 2 3 4 5 5 5 5 6 7 7 8 9 ]
</pre>
=={{header|R}}==
<
sorted <- sort(nums)</
=={{header|Racket}}==
<syntaxhighlight lang="racket">
-> (sort '(1 9 2 8 3 7 4 6 5) <)
'(1 2 3 4 5 6 7 8 9)
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
If <code>@a</code> contains only numbers:
<syntaxhighlight lang="raku" line>my @sorted = sort @a;</syntaxhighlight>
For an in-place sort:
<syntaxhighlight lang="raku" line>@a .= sort;</syntaxhighlight>
=={{header|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 [http://tutor.rascal-mpl.org/Courses/Rascal/Rascal.html#/Courses/Rascal/Libraries/Prelude/List/sort/sort.html documentation]).
<
ok
Line 1,574 ⟶ 2,192:
rascal>sort(a, bool(int a, int b){return a >= b;})
list[int]: [5,4,3,2,1]</
=={{header|Raven}}==
Sort list in place:
<
=={{header|REBOL}}==
<
=={{header|Red}}==
<
== [3 2 6 4 1 9 0 5 7]
>> sort nums
== [0 1 2 3 4 5 6 7 9]</
=={{header|REXX}}==
===sort an array===
This REXX version creates an array with over a score of Euler numbers (integers), then sorts it.
<
numeric digits 30 /*enables handling larger Euler numbers*/
@. =
@.3 = -1; @.5 =
@.
@.
@.
@.
#= 21
call tell 'unsorted'
call eSort #
call tell ' sorted'
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
eSort: procedure expose @.; parse arg N; h=N /*an eXchange sort.*/
parse value @.j @.k with @.k @.j /*swap two
if h>=j then leave; j= j-h; k= k-h /*this part sorted?*/
end /*while @.k<@.j*/
end /*i*/
end
return
/*──────────────────────────────────────────────────────────────────────────────────────*/
tell: say
do j=1 for #; say
end /*j*/
return</syntaxhighlight>
{{out|output|text= when using the default internal input:}}
<pre>
─────────────────────────────────────────────────────────────────
─────────────────────────────────────────────────────────────────
sorted array element 1= -2404879675441
sorted array element
sorted array element
sorted array element
sorted array element
sorted array element
sorted array element
sorted array element
sorted array element
sorted array element
sorted array element
sorted array element
sorted array element
sorted array element
sorted array element
sorted array element
sorted array element
sorted array element
sorted array element
sorted array element 21= 370371188237525
</pre>
===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,
<br>it is then sorted, and then the list is re-constituted.
<syntaxhighlight lang="rexx">/*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
say 'unsorted =' list /*display what's being shown.*/
do j=1 for
@.j=word(list, j)
end /*j*/
call eSort
$=; do k=1 for #; $= $
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
return</
{{out|output|text= when using the default internal inputs:}}
(Shown at <big>'''<sup>5</sup>/<sub>6</sub>'''</big> size.)
<pre style="font-size:83%">
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
Line 1,718 ⟶ 2,329:
=={{header|Ring}}==
<
see sort(aArray)</
=={{header|RPL}}==
{{works with|HP|48G}}
{2 4 3 1 2} SORT
{{out}}
<pre>
1: { 1 2 2 3 4 }
</pre>
=={{header|Ruby}}==
<
sorted = nums.sort # returns a new sorted array. 'nums' is unchanged
p sorted #=> [1, 2, 2, 3, 4]
Line 1,728 ⟶ 2,346:
nums.sort! # sort 'nums' "in-place"
p nums #=> [1, 2, 2, 3, 4]</
=={{header|Rust}}==
Uses merge sort in place (undocumented), allocating ~2*n memory where n is a length of an array.
<
let mut a = vec!(9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
a.sort();
println!("{:?}", a);
}</
=={{header|Sather}}==
<syntaxhighlight lang="sather">class MAIN is
main is
arr: ARRAY{INT} := |4, 6, 7, 2, 1, 0, 100, 21, 34|;
#OUT+"unsorted: " + arr + "\n";
-- sort in place:
arr.sort;
#OUT+" sorted: " + arr + "\n";
end;
end;</syntaxhighlight>
Output:
<syntaxhighlight lang="text">unsorted: {4,6,7,2,1,0,100,21,34}
sorted: {0,1,2,4,6,7,21,34,100}</syntaxhighlight>
=={{header|Scala}}==
{{libheader|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.<
object Sort_an_integer_array extends App {
Line 1,756 ⟶ 2,391:
println(s"Array in sorted order.\nSuccessfully completed without errors. [total ${Platform.currentTime - executionStart} ms]")
}</
===List===
<
//--> List(-42, 2, 2, 5, 78, 578)</
=={{header|Scheme}}==
{{works with|Guile}}
Same as [[Common Lisp]]
<
{{libheader|Scheme/SRFIs}}
Line 1,770 ⟶ 2,405:
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))
Line 1,777 ⟶ 2,412:
> (vector-sort < #(9 -2 1 2 8 0 1 2))
#(-2 0 1 1 2 2 8 9)
</syntaxhighlight>
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) <)
Line 1,787 ⟶ 2,422:
> (sort #(9 -2 1 2 8 0 1 2) <)
#(-2 0 1 1 2 2 8 9)
</syntaxhighlight>
=={{header|Seed7}}==
<
nums := sort(nums);</
=={{header|Sidef}}==
<
var sorted = nums.sort; # returns a new sorted array.
nums.sort!; # sort 'nums' "in-place"</
=={{header|Slate}}==
<
=={{header|Smalltalk}}==
<
or destructive:
<
=={{header|SparForte}}==
As a structured script.
<syntaxhighlight lang="ada">#!/usr/local/bin/spar
pragma annotate( summary, "int_sort" )
@( description, "Sort an array (or list) of integers in ascending" )
@( description, "numerical order. Use a sorting facility provided by" )
@( description, "the language/library if possible." )
@( category, "tutorials" )
@( author, "Ken O. Burtch" )
@( see_also, "http://rosettacode.org/wiki/Sort_an_integer_array" );
pragma license( unrestricted );
pragma software_model( nonstandard );
pragma restriction( no_external_commands );
procedure int_sort is
type int_array is array (1..9) of integer;
int_values : int_array := (0,1,8,2,7,3,6,4,5);
begin
arrays.heap_sort( int_values );
for i in arrays.first( int_values )..arrays.last( int_values ) loop
? int_values(i);
end loop;
end int_sort;</syntaxhighlight>
=={{header|Sparkling}}==
<
sort(arr);</
=={{header|Standard ML}}==
Line 1,816 ⟶ 2,476:
===Array===
{{works with|SML/NJ}}
<
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}}
<
> val it = () : unit
- load "Int";
Line 1,833 ⟶ 2,493:
> 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] : int list
- val sorted = ListMergeSort.sort op> nums;
val sorted = [1,2,2,3,4] : int list</
{{works with|Moscow ML}}
<
> val it = () : unit
- load "Int";
Line 1,850 ⟶ 2,510:
> 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</
=={{header|Stata}}==
Line 1,856 ⟶ 2,516:
See '''[https://www.stata.com/help.cgi?sort sort]''' in Stata help.
<
. matrix a=(2,9,4,7,5,3,6,1,8)'
. qui svmat a
Line 1,875 ⟶ 2,535:
8. | 8 |
9. | 9 |
+----+</
=== Sort a macro list ===
See '''[https://www.stata.com/help.cgi?macrolists macrolists]''' in Stata help for other functions on lists stored in macros.
<
. di "`: list sort a'"
1 2 3 4 5 6 7 8 9</
=== Mata ===
See Mata's '''[http://www.stata.com/help.cgi?mf_sort sort]''' function.
<
: a=2\9\4\7\5\3\6\1\8
Line 1,903 ⟶ 2,563:
9 | 9 |
+-----+
end</
=={{header|Swift}}==
===Sort in place===
{{works with|Swift|2.x+}}
<
nums.sortInPlace()
print(nums)</
or
<
nums.sortInPlace(<)
print(nums)</
{{works with|Swift|1.x}}
<
nums.sort(<)
println(nums)</
or
<
sort(&nums)
println(nums)</
or
<
sort(&nums, <)
println(nums)</
===Return new array===
Line 1,933 ⟶ 2,593:
{{works with|Swift|2.x+}}
<
print(nums)</
or
<
print(nums)</
{{works with|Swift|1.x}}
<
println(nums)</
or
<
println(nums)</
=={{header|Tcl}}==
<
=={{header|TI-83 BASIC}}==
Line 1,958 ⟶ 2,618:
This can be done by using the bubble sort library:
<
arrayname number_elements bsort</
See the Toka entry on [[Bubble Sort]] for a full example.
Line 1,966 ⟶ 2,626:
Each shell parameter separates the integers using the default IFS whitespace (space, tab, newline).
<
sorted=`printf "%s\n" $nums | sort -n`
echo $sorted # prints 1 2 3 4 5</
Alternate solution: <tt>sorted=`for i in $nums; do echo $i; done | sort -n`</tt>
Line 1,976 ⟶ 2,636:
{{works with|pdksh|5.2.14}}
<
set -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 <tt>nums=(2 4 3 1 2)</tt> syntax.
=={{header|Ursa}}==
<
append 2 4 3 1 2 nums
sort nums</
=={{header|Ursala}}==
using the built in sort operator, -<, with the nleq library function
for comparing natural numbers
<
#cast %nL
example = nleq-< <39,47,40,53,14,23,88,52,78,62,41,92,88,66,5,40></
output:
<pre><5,14,23,39,40,40,41,47,52,53,62,66,78,88,88,92></pre>
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">fn main() {
mut nums := [3, 2, 4, 1, 6, 7, 5, 0]
nums.sort()
println(nums)
}</syntaxhighlight>
{{out}}
<pre>
[0, 1, 2, 3, 4, 5, 6, 7]
</pre>
=={{header|WDTE}}==
<syntaxhighlight lang="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;</syntaxhighlight>
=={{header|Wortel}}==
<
=={{header|Wren}}==
{{libheader|Wren-sort}}
<syntaxhighlight lang="wren">import "./sort" for Sort
var a = [7, 10, 2, 4, 6, 1, 8, 3, 9, 5]
Sort.quick(a)
System.print(a)</syntaxhighlight>
{{out}}
<pre>
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
</pre>
=={{header|XPL0}}==
<
proc SSort(A, N); \Shell sort array in ascending order
Line 2,028 ⟶ 2,717:
for I:= 0 to 10-1 do [IntOut(0, A(I)); ChOut(0, ^ )];
CrLf(0);
]</
Output:
Line 2,034 ⟶ 2,723:
1 1 2 3 4 4 5 5 6 9
</pre>
=={{header|Yabasic}}==
<syntaxhighlight lang="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
wend
end 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</syntaxhighlight>
=={{header|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));
</syntaxhighlight>
=={{header|zkl}}==
In place sorting read/write list:
<
Sort a read only list:
<
b.println(); //--> L(2,4,5,6)
a.println(); //--> L(4,5,2,6)</
=={{header|Zoea}}==
<syntaxhighlight lang="zoea">
program: sort_integer_array
input: [2,4,3,1]
output: [1,2,3,4]
</syntaxhighlight>
=={{header|Zoea Visual}}==
[http://zoea.co.uk/examples/zv-rc/Sort_integer_array.png Sort integer array]
|