Sort an integer array: Difference between revisions

{{trans|Python}}

 

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

 

=={{header|4D}}==

===English===

 

APPEND TO ARRAY($nums;2)

APPEND TO ARRAY($nums;4)

APPEND TO ARRAY($nums;2)

SORT ARRAY($nums) ` sort in ascending order

 

===Français===

 

AJOUTER A TABLEAU($nombres;2)

AJOUTER A TABLEAU($nombres;4)

AJOUTER A TABLEAU($nombres;2)

TRIER TABLEAU($nombres) ` pour effectuer un tri par ordre croissant

 

=={{header|8th}}==

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

Output is: [2,10,100]

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program integerSort64.s with selection sort */

.include "../includeARM64.inc"

 

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

 

PROC PrintArray(INT ARRAY a INT size)

Test(c,8,ASCENDING)

Test(d,12,ASCENDING)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sort_an_integer_array.png Screenshot from Atari 8-bit computer]

 

=={{header|ActionScript}}==

function compare(x:int, y:int):Number

{

}

var nums:Vector.<int> = Vector.<int>([5,12,3,612,31,523,1,234,2]);

 

=={{header|Ada}}==

{{works with|GNAT|GPL 2006}}

procedure Integer_Sort is

begin

Sort(Values);

 

=={{header|ALGOL 68}}==

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

 

in place shell sort(LOC[LWB seq: UPB seq]TYPE:=seq);

 

Output:

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

% use the quicksort procedure from the Sorting_Algorithms/Quicksort task %

% Quicksorts in-place the array of integers v, from lb to ub - external %

for i := 1 until 5 do writeon( i_w := 1, s_w := 1, t( i ) )

end

{{out}}

<pre>

=={{header|APL}}==

{{works with|APL2}}

X[⍋X]

 

=={{header|AppleScript}}==

for which AppleScript was presumably designed.

 

 

-- sort :: [a] -> [a]

end script

end if

{{Out}}

<pre>{{0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9},

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

/***************************************************/

.include "../affichage.inc"

=={{header|Arturo}}==

sort 'arr ; in-place

 

{{out}}

=={{header|AutoHotkey}}==

sort, numbers, N D%A_Space%

 

=={{header|AWK}}==

# syntax: GAWK -f SORT_AN_INTEGER_ARRAY.AWK

BEGIN {

printf("\t%s\n",description)

}

<p>output:</p>

<pre>

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}

2→{L₁+4}

 

 

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

 

( 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

 

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

 

babel> {lt?} lssort ! lsnum !

 

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

 

 

=={{header|BaCon}}==

DECLARE values[5] TYPE NUMBER

values[0] = 23

PRINT values[i], ", ";

NEXT

 

{{out}}

{{works with|BBC BASIC for Windows}}

Uses the supplied SORTLIB library.

sort% = FN_sortinit(0,0)

PRINT ; array(i%) ", ";

NEXT

Output:

<pre>

 

=={{header|Beads}}==

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

 

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

> 543** > :#v_ $&> :#v_ 1 > :0g > :#v_ $ 1+: 543** `! #v_ 25*,@

^-1p0\0:< ^-1 p0\+1 g0:&< ^-1\.:\<

 

=={{header|Bracmat}}==

{!} 21</pre>

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

(sort=

sum elem sorted n

& !sorted);

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

 

=={{header|Burlesque}}==

 

=={{header|C}}==

#include <stdio.h> /* printf() */

 

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

 

using System.Collections.Generic;

 

Array.Sort(unsorted);

}

 

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

 

===Simple Array===

 

int main()

std::sort(nums, nums+sizeof(nums)/sizeof(int));

return 0;

 

===<tt>std::vector</tt>===

#include <vector>

 

std::sort(nums.begin(), nums.end());

return 0;

 

===<tt>std::list</tt>===

 

int main()

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

 

Start :: {#Int}

 

=={{header|Clojure}}==

 

=={{header|COBOL}}==

{{works with|Visual COBOL}}

DATA DIVISION.

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:

 

=={{header|Crystal}}==

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

a = [5, 4, 3, 2, 1]

puts a.sort

puts a

# => [1, 2, 3, 4, 5]

 

=={{header|D}}==

 

void main() {

data.sort(); // in-place

assert(data == [1, 2, 2, 3, 4]);

 

=={{header|Delphi}}==

 

var

a := TIntegerDynArray.Create(5, 4, 3, 2, 1);

TArray.Sort<Integer>(a);

 

=={{header|DWScript}}==

a.Sort; // ascending natural sort

 

=={{header|Déjà Vu}}==

{{out}}

<pre>[ 1 2 3 4 5 ]</pre>

 

=={{header|E}}==

 

=={{header|EGL}}==

{{works with|EDT}}

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

 

function main()

end

{{works with|RBD}}

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

RUILib.sort(test1, sortFunction);

 

function sortFunction(a any in, b any in) returns (int)

return ((a as int) - (b as int));

 

=={{header|Eiffel}}==

The list can be easily sorted in reverse. There is a call for `sort' to manually initiate sorting.

 

local

l_array: SORTED_TWO_WAY_LIST [INTEGER]

create l_array.make_from_iterable (<<9,8,7,6,5,4,3,2,1,0>>)

end

 

=={{header|Elena}}==

ELENA 5.0 :

import extensions;

console.printLine(unsorted.clone().sort(ifOrdered).asEnumerable())

 

=={{header|Elixir}}==

IO.inspect Enum.sort(list)

 

{{out}}

 

=={{header|Erlang}}==

 

=={{header|Euphoria}}==

 

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

let nums = [| 2; 4; 3; 1; 2 |]

Array.sortInPlace nums

// create a sorted copy of a list

let nums2 = [2; 4; 3; 1; 2]

 

=={{header|Factor}}==

 

=={{header|Fantom}}==

{{works with|Win32Forth|4.2}}

===Win32Forth===

test-data 5 cell-sort

===ANS/ISO Forth===

{{works with|GForth}}

 

Standard Forth does not have a library sort

 

CREATE MYARRAY SIZE CELLS ALLOT

DUP 2 < IF 2DROP EXIT THEN 1- CELLS OVER + QSORT ;</LANG>

Test at the console

 

=={{header|Fortran}}==

{{works with|Silverfrost FTN95}}

! n = number of elements

! a = array to be sorted

 

=={{header|FreeBASIC}}==

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

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>unsorted array

=={{header|Frink}}==

The following sorts an array in-place.

 

=={{header|FunL}}==

println( sort(nums) ) // sort in ascending order

 

{{out}}

[-42, 2, 2, 5, 78, 578]

[578, 78, 5, 2, 2, -42]

</pre>

 

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

 

 

 

 

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

Print Left(sOutput, -2)

 

 

Output:

 

=={{header|GAP}}==

# Make a copy (with "b := a;", b and a would point to the same list)

b := ShallowCopy(a);

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

b;

 

=={{header|Go}}==

import "fmt"

import "sort"

sort.Ints(nums)

fmt.Println(nums)

 

=={{header|Golfscript}}==

 

=={{header|Groovy}}==

 

Output:

{{works with|GHC|GHCi|6.6}}

 

=={{header|HicEst}}==

 

array = INT( RAN(100) )

 

=={{header|Huginn}}==

nums = [2, 4, 3, 1, 2];

nums.sort();

 

=={{header|Icon}} and {{header|Unicon}}==

 

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

 

=={{header|IDL}}==

 

=={{header|Inform 7}}==

 

=={{header|Io}}==

sorted := nums sort # returns a new sorted array. 'nums' is unchanged

 

=={{header|J}}==

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

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.

 

=={{header|Java}}==

===Array===

 

public class Example {

Arrays.sort(nums);

}

 

===List===

{{works with|Java|1.5+}}

import java.util.Collections;

import java.util.List;

Collections.sort(nums);

}

 

=={{header|JavaScript}}==

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

 

=={{header|Jinja}}==

from jinja2 import Template

print(Template("{{ [53, 17, 42, 61, 35] | sort }}").render())

Descending order:

from jinja2 import Template

print(Template("{{ [53, 17, 42, 61, 35] | sort(reverse=true) }}").render())

 

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

2

3

 

=={{header|K}}==

5 9 4 2 0 3 6 1 8 7

 

srt: {x@<x} / Generalized sort ascending

srt num

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

ints.sort()

println(ints.joinToString(prefix = "[", postfix = "]"))

 

{{out}}

 

=={{header|Lambdatalk}}==

1) sorting digits in a number returns a new number of ordered digits

{W.sort < 51324}

{A.sort! < {A.new 51 111 33 2 41}}

-> [2,33,41,51,111]

 

=={{header|Lasso}}==

#array->sort

#array // 1, 2, 3, 4, 5, 6, 20

// Reverse the sort order

#array->sort(false)

 

=={{header|Liberty BASIC}}==

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

dim IntArray( N)

 

for i =1 to N

print IntArray( i)

 

=={{header|Lingo}}==

l.sort()

put l

 

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

 

=={{header|Lua}}==

table.sort(t)

 

=={{header|Maple}}==

 

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

 

=={{header|MATLAB}}==

 

=={{header|Maxima}}==

 

=={{header|MAXScript}}==

 

=={{header|Mercury}}==

:- interface.

:- import_module io.

list.sort(Nums, Sorted),

io.write(Sorted, !IO),

 

=={{header|min}}==

{{works with|min|0.19.3}}

{{out}}

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

BEGIN

IntArraySort.Sort(arr);

 

=={{header|MUMPS}}==

;X is the list of items to sort

;X1 is the temporary array

SET I="" FOR SET I=$O(X1(I)) Q:I="" SET Y=$SELECT($L(Y)=0:I,1:Y_SEP_I)

KILL I,X1

Output:<pre>USER>W $$SORTARRAY^ROSETTA("3,5,1,99,27,16,0,-1",",")

-1,0,1,3,5,16,27,99

=={{header|Nanoquery}}==

'sort' in the Nanoquery standard library has a Quicksort function.

% println sort({2,4,3,1,2})

 

=={{header|Neko}}==

<doc><h2>Sort integer array, in Neko</h2>

<p>Array sort function modified from Haxe codegen with -D neko-source</p>

 

/* Also returns the sorted array for chaining */

 

{{out}}

 

=={{header|Nemerle}}==

 

module IntSort

WriteLine(sorted);

}

Output:

<pre>[1, 5, 3, 7, 2, 8, 3, 9]

 

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols binary

 

say sorted.strip('t')

 

 

'''Output'''

NetRexx reimplementations of the [[#REXX|Rexx]] samples from below:

 

options replace format comments java crossref savelog symbols

 

say

 

 

'''Output'''

</pre>

 

options replace format comments java crossref savelog symbols

 

end

 

 

'''Output'''

 

=={{header|Nial}}==

 

=={{header|Nim}}==

var a: array[0..8, int] = [2, 3, 5, 8, 4, 1, 6, 9, 7]

a.sort(Ascending)

for x in a:

{{out}}

<pre>1

=={{header|Niue}}==

'''Library'''

 

=={{header|Objeck}}==

class Sort {

function : Main(args : System.String[]) ~ Nil {

}

}

 

=={{header|Objective-C}}==

 

=={{header|OCaml}}==

===Array===

 

===List===

 

=={{header|Octave}}==

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"

Output:

<pre>

=={{header|Order}}==

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

 

 

=={{header|Oz}}==

Nums = [2 4 3 1 2]

Sorted = {List.sort Nums Value.'<'}

in

 

=={{header|PARI/GP}}==

 

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

<@ SAYDMPLST>list</@>

<@ ACTSRTENTLSTLIT>list|__NumericDescending</@>

 

Output

Numbers sort as strings

1^2^3^4^4^25^25^39^41^42^44^45^47^51^65^69^77^84^

 

=={{header|Perl}}==

{{works with|Perl|5.8.6}}

 

=={{header|Phix}}==

{{libheader|Phix/basics}}

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

 

=={{header|Phixmonti}}==

 

 

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

 

=={{header|PL/I}}==

{{works with|IBM PL/I|7.5}}

 

MERGE: PROCEDURE (A,LA,B,LB,C);

CALL MERGE(T,M,AMP1,N-M,A);

RETURN;

 

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

;;; Convert list to array

destlist(ls);

 

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

 

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

Alternatively, using the datalist function, even more economically:

 

 

or in Forth-like pop11 postfix syntax:

 

 

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

 

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

 

=={{header|PureBasic}}==

For i = 0 To 20

numbers(i) = Random(1000)

Next

 

 

=={{header|Python}}==

{{works with|Python|2.3}}

 

'''Note:''' The array <tt>nums</tt> is sorted in place.

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

 

 

=={{header|Quackery}}==

 

=={{header|R}}==

 

=={{header|Racket}}==

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

'(1 2 3 4 5 6 7 8 9)

 

=={{header|Raku}}==

If <code>@a</code> contains only numbers:

 

 

For an in-place sort:

 

 

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

 

 

rascal>sort(a, bool(int a, int b){return a >= b;})

 

=={{header|Raven}}==

Sort list in place:

 

 

=={{header|REBOL}}==

 

=={{header|Red}}==

== [3 2 6 4 1 9 0 5 7]

>> sort nums

 

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

@. = 0; @.1 = 1

do j=1 for #; say _ arg(1) 'array element' right(j, w)"="right(@.j, 20)

end /*j*/

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

<pre>

Because it so much more efficient to sort an array, &nbsp; an array is built from the list,

<br>it is then sorted, &nbsp; and then the list is re-constituted.

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

end /*i*/

end /*while h>1*/

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

 

 

=={{header|Ring}}==

 

=={{header|Ruby}}==

sorted = nums.sort # returns a new sorted array. 'nums' is unchanged

p sorted #=> [1, 2, 2, 3, 4]

 

nums.sort! # sort 'nums' "in-place"

 

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

main is

arr: ARRAY{INT} := |4, 6, 7, 2, 1, 0, 100, 21, 34|;

#OUT+" sorted: " + arr + "\n";

end;

 

Output:

 

=={{header|Scala}}==

{{libheader|Scala}}

===Array===

 

object Sort_an_integer_array extends App {

 

println(s"Array in sorted order.\nSuccessfully completed without errors. [total ${Platform.currentTime - executionStart} ms]")

===List===

 

=={{header|Scheme}}==

{{works with|Guile}}

Same as [[Common Lisp]]

 

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

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

> (sort #(9 -2 1 2 8 0 1 2) <)

#(-2 0 1 1 2 2 8 9)

 

=={{header|Seed7}}==

 

 

=={{header|Sidef}}==

var sorted = nums.sort; # returns a new sorted array.

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

or destructive:

 

=={{header|Sparkling}}==

 

=={{header|Standard ML}}==

===Array===

{{works with|SML/NJ}}

val nums = [|2,4,3,1,2|] : int array

- ArrayQSort.sort Int.compare nums;

val it = () : unit

- nums;

 

{{works with|Moscow ML}}

> val it = () : unit

- load "Int";

> val it = () : unit

- Array.foldr op:: [] nums;

 

===List===

{{works with|SML/NJ}}

val nums = [2,4,3,1,2] : int list

- val sorted = ListMergeSort.sort op> nums;

 

{{works with|Moscow ML}}

> val it = () : unit

- load "Int";

> val nums = [2, 4, 3, 1, 2] : int list

- val sorted = Listsort.sort Int.compare nums;

 

=={{header|Stata}}==

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

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

 

=== Mata ===

See Mata's '''[http://www.stata.com/help.cgi?mf_sort sort]''' function.

 

: a=2\9\4\7\5\3\6\1\8

 

9 | 9 |

+-----+

 

=={{header|Swift}}==

===Sort in place===

{{works with|Swift|2.x+}}

nums.sortInPlace()

or

nums.sortInPlace(<)

 

{{works with|Swift|1.x}}

nums.sort(<)

or

sort(&nums)

or

sort(&nums, <)

 

===Return new array===

 

{{works with|Swift|2.x+}}

or

 

{{works with|Swift|1.x}}

or

 

=={{header|Tcl}}==

 

=={{header|TI-83 BASIC}}==

This can be done by using the bubble sort library:

 

 

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

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

 

sorted=`printf "%s\n" $nums | sort -n`

 

Alternate solution: <tt>sorted=`for i in $nums; do echo $i; done | sort -n`</tt>

 

{{works with|pdksh|5.2.14}}

set -A sorted $(printf "%s\n" ${nums[*]} | sort -n)

 

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

 

=={{header|Ursala}}==

using the built in sort operator, -<, with the nleq library function

for comparing natural numbers

 

#cast %nL

 

output:

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

 

mut nums := [3, 2, 4, 1, 6, 7, 5, 0]

nums.sort()

println(nums)

 

{{out}}

 

=={{header|WDTE}}==

 

=={{header|Wortel}}==

 

=={{header|Wren}}==

{{libheader|Wren-sort}}

 

var a = [7, 10, 2, 4, 6, 1, 8, 3, 9, 5]

Sort.quick(a)

 

{{out}}

 

=={{header|XPL0}}==

 

proc SSort(A, N); \Shell sort array in ascending order

for I:= 0 to 10-1 do [IntOut(0, A(I)); ChOut(0, ^ )];

CrLf(0);

 

Output:

 

=={{header|Yabasic}}==

// Shell sort based on insertion sort

 

next n

 

 

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

 

=={{header|zkl}}==

In place sorting read/write list:

Sort a read only list:

b.println(); //--> L(2,4,5,6)

 

=={{header|Zoea}}==

program: sort_integer_array

input: [2,4,3,1]

output: [1,2,3,4]

 

=={{header|Zoea Visual}}==