Sort an integer array: Difference between revisions

{{task|Sorting}}

 

;Task:

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

<br><br>

 

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

+1 +2 +2 +3 +4

</pre>

 

=={{header|APL}}==

{{works with|APL2}}

X[⍋X]

 

=={{header|AppleScript}}==

Later versions of AppleScript (OS X 10.10 onwards) do allow access to the ObjC NSArray library,

but while this approach can yield reasonably fast sorts, it is slow in terms of scripter time,

for which AppleScript was presumably designed.

 

 

 

on run

end run

 

 

 

-- map :: (a -> b) -> [a] -> [b]

on map(f, xs)

 

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

{{works with|BBC BASIC for Windows}}

Uses the supplied SORTLIB library.

sort% = FN_sortinit(0,0)

PRINT ; array(i%) ", ";

NEXT

Output:

<pre>

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

</pre>

 

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

 

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

 

{{out}}

 

 

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

 

=={{header|Fantom}}==

=={{header|Forth}}==

{{works with|Win32Forth|4.2}}

 

=={{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|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|Icon}} and {{header|Unicon}}==

 

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

 

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

 

=={{header|Java}}==

===Array===

 

public static void main(String[] args)

{

Arrays.sort(nums);

}

 

===List===

{{works with|Java|1.5+}}

import java.util.Collections;

import java.util.List;

 

public static void main(String[] args)

{

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

 

=={{header|Maxima}}==

 

=={{header|MAXScript}}==

 

=={{header|Mercury}}==

:- interface.

:- import_module io.

list.sort(Nums, Sorted),

io.write(Sorted, !IO),

 

 

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

</pre>

 

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

for x in a:

{{out}}

<pre>1

=={{header|Niue}}==

'''Library'''

 

=={{header|Objeck}}==

class Sort {

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

}

}

 

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

<pre> ?- msort([10,5,13,3, 85,3,1], L).

L = [1,3,3,5,10,13,85].</pre>

 

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

 

=={{header|Racket}}==

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

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

 

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

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

end /*while @.k<@.j*/

end /*i*/

return

/*──────────────────────────────────────────────────────────────────────────────────────*/

<pre>

</pre>

 

===sort a list===

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

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

say 'unsorted =' list /*display what's being shown.*/

end /*j*/

end /*k*/

say ' sorted =' space($) /*display the sorted list. */

exit /*stick a fork in it, we're all done.*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

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

 

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

 

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

 

=={{header|Wortel}}==

 

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

1 1 2 3 4 4 5 5 6 9

</pre>

 

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