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

# syntax: GAWK -f SORT_AN_INTEGER_ARRAY.AWK

BEGIN {

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

}

<p>output:</p>

<pre>

1234 200 99 10 9 3 2 1 0 -2 sorted descending

</pre>

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

 

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

</pre>

 

===sort a list===

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

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

</pre>

 

=={{header|Ruby}}==

 

=={{header|Rust}}==

let mut a = vec!(9, 8, 7, 6, 5, 4, 3, 2, 1, 0);

 

a.sort();

 

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

nums.sort(<)

or

sort(&nums)

or

sort(&nums, <)

 

You could also create a new sorted array without affecting the original one:

 

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