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

Output:

<pre>-2 0 1 1 2 2 8 9</pre>

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

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