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

Evaluating the list sorts the list, but also adds like terms.

To illustrate, this is what happens when entering our list at the prompt:

The use of a computationally inert operator like the dot <code>.</code> is essential:

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

(sort=

sum elem sorted n

& !sorted);

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

 

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

Sort list in place:

 

 

=={{header|REBOL}}==

 

=={{header|REXX}}==

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

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