Sort an integer array: Difference between revisions

 

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

sort, numbers, N D%A_Space%

 

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

Also, adding elements to the end of the list 'sorted' is costly. Better is to prepend elements to a list, which will have inverted sorting order, and to invert this list in an extra loop.

 

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

{

int nums[] = {2,4,3,1,2};

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

begin

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

 

=={{header|E}}==

 

=={{header|Erlang}}==

 

=={{header|Euphoria}}==

 

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

 

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

table.sort(t)

 

 

=={{header|MATLAB}}==

 

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

say "The sorted numbers are"

Output:

<pre>

99

</pre>

 

=={{header|Oz}}==

Nums = [2 4 3 1 2]

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

in

 

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

 

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

This REXX version creates an array with over a score of Euler numbers (integers), then sorts it.

</pre>

 

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

 

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

</pre>

 

=={{header|Ruby}}==

 

=={{header|Scala}}==

 

=={{header|Scheme}}==

{{works with|Guile}}

Same as [[Common Lisp]]

 

=={{header|Seed7}}==

 

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

 

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