Sort using a custom comparator: Difference between revisions

{{Sorting Algorithm}}

{{omit from|BBC BASIC}}

 

'''Note:'''   Lexicographic order is case-insensitive.

<br><br>

 

=={{header|Ada}}==

{{incorrect}}

{{works with|GNAT|}}

with Ada.Text_Io; use Ada.Text_Io;

with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;

Put_Line("Sorted list:");

Put(Strings);

{{out}}

<pre>Unsorted list:

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

The Algol 68 version of the Quicksort algorithm, modified to use a custom sort routine, as per this task.

MODE SITEM = STRING;

#--- Swap function ---#

quicksort(a, compare);

print(("After :"));FOR i FROM LWB a TO UPB a DO print((" ",a[i])) OD; print((newline))

{{out}}

<pre>

AppleScript is not itself well equipped with sorting functions, but from Yosemite onwards we can make some use of ObjC classes. While a classic comparator function can not readily be passed from AppleScript to ObjC, we can at least write a custom function which lifts atomic values into records (with keys to base and derivative values), and also passes a sequence of (key, bool) pairs, where the bool expresses the choice between ascending and descending order for the paired key:

 

 

-- SORTING LISTS OF ATOMIC (NON-RECORD) DATA WITH A CUSTOM SORT FUNCTION

sortBy(lengthDownAZup, xs)

{{Out}}

<pre>{"Sao Paulo", "Shanghai", "Beijing", "Karachi", "Delhi", "Dhaka", "Lagos"}</pre>

Putting values into records temporarily can sometimes be necessary with ASObjC sorts so that sorting can be done on the equivalent NSDictionaries' keys. But in fact NSStrings can be sorted on the keys <tt>"length"</tt> and <tt>"self"</tt>:

 

use framework "Foundation"

 

tell arrayOfStrings to sortUsingDescriptors:({descendingByLength, ascendingLexicographically})

 

 

{{output}}

 

===Vanilla===

 

script descendingByLengthThenAscendingLexicographically

on isGreater(a, b)

end isGreater

end script

 

 

{{output}}

<pre>{"party", "come", "good", "time", "aid", "all", "for", "men", "now", "the", "the", "the", "is", "of", "to", "to"}</pre>

 

=={{header|AutoHotkey}}==

strings = Here,are,some,sample,strings,to,be,sorted

Sort, numbers, F IntegerSort D,

StringLengthSort(a1, a2){

return strlen(a1) - strlen(a2)

 

=={{header|AWK}}==

For GAWK, this uses the inbuilt descending numeric ordering and a custom comparison routine for caseless string comparison.

May need modification for TAWK.

#

# sorting:

l2 = tolower( i2 );

return ( ( l1 < l2 ) ? -1 : ( ( l1 == l2 ) ? 0 : 1 ) );

{{out}}

<pre>

To sort ASCII strings, use the strsort or lexsort utilities to sort alphabetically and lexicographically, respectively.

 

( "Here" "are" "be" "sample" "some" "sorted" "strings" "to" )

babel> ("Here" "are" "some" "sample" "strings" "to" "be" "sorted") lexsort ! lsstr !

 

If you want to sort UTF-8 encoded Unicode strings, first convert to array-string form using the str2ar operator, then sort using the strcmp operator. To sort lexicographically, use the arcmp operator. The following examples illustrate each case:

 

( "Here" "are" "be" "some" "sample" "sorted" "strings" "to" )

babel> ("Here" "are" "some" "sample" "strings" "to" "be" "sorted") {str2ar} over ! {arcmp 0 lt?} lssort ! {ar2str} over ! lsstr !

 

You can sort a list of any kind of structure you like using the lssort utility. Use the lt? numerical comparison operator for sorting numerical lists:

 

 

You can even shuffle a list with lssort using the randlf operator (your results will probably differ):

 

 

To sort complex objects, you need to access the relevant field in each object, and then provide the result of comparing them. For example, to sort a list of pairs by first number:

 

babel> 20 lsrange ! {1 randlf 2 rem} lssort ! 2 group ! --> this creates a shuffled list of pairs

babel> dup {lsnum !} ... --> display the shuffled list, pair-by-pair

( 15 13 )

( 17 3 )

 

=={{header|Burlesque}}==

 

blsq ) {"acb" "Abc" "Acb" "acc" "ADD"}><

{"ADD" "Abc" "Acb" "acb" "acc"}

blsq ) {"acb" "Abc" "Acb" "acc" "ADD"}(zz)CMsb

{"Abc" "acb" "Acb" "acc" "ADD"}

 

=={{header|C}}==

{{works with|POSIX|.1-2001}}

 

#include <string.h> /* for strlen */

#include <strings.h> /* for strcasecmp */

qsort(strings, sizeof(strings)/sizeof(*strings), sizeof(*strings), mycmp);

return 0;

 

=={{header|C sharp|C#}}==

C# allows you to specify a custom compare to the built in sort method on a list

 

using System.Collections.Generic;

 

}

}

 

{{out}}

 

 

using System.Collections.Generic;

using System.Linq;

}

}

 

=={{header|C++}}==

{{works with|g++|4.1.2}}

#include <string>

#include <cctype>

std::sort(strings, strings+8, compare());

return 0;

 

=={{header|Ceylon}}==

 

value strings = [

sorted.each(print);

 

=={{header|Clean}}==

 

less s1 s2

lower s = {toLower c \\ c <-: s}

 

 

=={{header|Clojure}}==

Clojure's ''sort'' function has a 2-argument version where the first argument is a ''java.util.Comparator'', and the second is the collection to be sorted. Thus the heart of this version is a comparator function that satisfies the problem spec. What makes this work is that all Clojure functions (thus ''rosetta-code'' defined here) implement the ''java.util.Comparator'' interface.

(let [len1 (count s1), len2 (count s2)]

(if (= len1 len2)

(println

(sort rosetta-compare

 

{{out}}

 

An alternative, using <tt>sort-by</tt>:

 

=={{header|Common Lisp}}==

For example, to sort strings case-insensitively in ascending order:

 

(list "Cat" "apple" "Adam" "zero" "Xmas" "quit" "Level" "add" "Actor" "base" "butter"))

*STRINGS*

CL-USER> (sort *strings* #'string-lessp)

("Actor" "Adam" "add" "apple" "base" "butter" "Cat" "Level" "quit" "Xmas"

 

You can also provide an optional key function which maps each element to a key. The keys are then compared using the comparator. For example, to sort strings by length in descending order:

 

(list "Cat" "apple" "Adam" "zero" "Xmas" "quit" "Level" "add" "Actor" "base" "butter"))

*STRINGS*

CL-USER> (sort *strings* #'> :key #'length)

("butter" "apple" "Level" "Actor" "Adam" "zero" "Xmas" "quit" "base"

 

=={{header|D}}==

 

void main() {

.schwartzSort!q{ tuple(-a.length, a.toUpper) }

.writeln;

{{out}}

<pre>["strings", "sample", "sorted", "here", "Some", "are", "be", "to"]</pre>

The more natural and efficient way to solve this problem is to use <code>std.algorith.multiSort</code>.

But currently it's less convenient because it can't be used with the UFCSyntax (same output):

import std.stdio, std.string, std.algorithm;

 

parts.multiSort!(q{a.length > b.length}, q{a.toUpper < b.toUpper});

parts.writeln;

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Result := CompareText(Left, Right);

end));

 

=={{header|E}}==

def nonzeroOr(a, b) { return if (a.isZero()) { b() } else { a } }

 

nonzeroOr(b.size().op__cmp(a.size()),

fn { a.compareToIgnoreCase(b) })

 

=={{header|EGL}}==

 

{{works with|EDT|}}

function main()

end

 

{{out}}

 

=={{header|Elena}}==

import system'routines;

import system'culture;

console.printLine("Descending length: ", items.clone()

console.printLine("Ascending order: ", items.clone()

{{out}}

<pre>

 

=={{header|Elixir}}==

 

comparator = fn s1,s2 -> if String.length(s1)==String.length(s2),

 

# or

 

{{out}}

 

=={{header|Erlang}}==

-module( sort_using_custom_comparator ).

 

longest_first_case_insensitive( String1, String2 ) when erlang:length(String1) =< erlang:length(String2) -> false;

longest_first_case_insensitive( _String1, _String2 ) -> true.

{{out}}

<pre>

 

=={{header|Euphoria}}==

include wildcard.e

include misc.e

 

puts(1,"\n\nSorted:\n")

 

{{out}}

 

=={{header|F_Sharp|F#}}==

match compare s2.Length s1.Length with

| 0 -> compare (s1.ToLower()) (s2.ToLower())

let sortedStrings = List.sortWith myCompare strings

 

 

{{out}}

 

=={{header|Factor}}==

2dup [ length ] compare invert-comparison

dup +eq+ = [ drop [ >lower ] compare ] [ 2nip ] if ;

 

 

=={{header|Fantom}}==

The List's sort method can be customised using a custom comparator. This is a method which returns an Int: -1 for less than, 0 for equal, +1 for greater than.

 

class Main

{

}

}

 

{{out}}

Fortran does not have builtin to sort arrays (of numbers or strings), with or without custom comparator; so we need modifying e.g. [[Shell sort#Fortran|this code]] in order to handle strings and to accept a custom comparator.

 

implicit none

contains

end do

end subroutine a_sort

 

Then we have to put our custom comparator in a module (<tt>to_lower</tt> is defined [[Change string case|here]]):

 

implicit none

contains

end if

end function my_compare

 

At the end, we can test these:

 

use comparators

use sorts_with_custom_comparator

print *, trim(str(i))

end do

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>strings

be

to</pre>

 

=={{header|FunL}}==

 

 

{{out}}

["strings", "sample", "sorted", "here", "Some", "are", "be", "to"]

</pre>

 

=={{header|Go}}==

 

import (

sort.Sort(s)

fmt.Println(s, "(sorted)")

{{out}}

<pre>[To tell your name the livelong day To an admiring bog] (original)

=={{header|Groovy}}==

The "custom comparator" is just a closure attached to the sort method invocation.

strings.sort { x, y ->

y.length() <=> x.length() ?: x.compareToIgnoreCase(y)

}

 

{{out}}

=={{header|Haskell}}==

{{works with|GHC}}

import Data.List (sortBy)

 

lengthThenAZ :: String -> String -> Ordering

 

descLengthThenAZ :: String -> String -> Ordering

 

main :: IO ()

main =

mapM_

putStrLn

{{Out}}

<pre>be

 

=={{header|Icon}} and {{header|Unicon}}==

write("Sorting Demo for custom comparator")

L := ["Here", "are", "some", "sample", "strings", "to", "be", "sorted"]

procedure cmptask(a,b) # sort by descending length and ascending lexicographic order for strings of equal length

if (*a > *b) | ((*a = *b) & (map(a) << map(b))) then return b

 

Note(1): This example relies on [[Sorting_algorithms/Bubble_sort#Icon| the supporting procedures 'sortop', and 'demosort' in Bubble Sort]].

Standard utilities <tt>tolower</tt> or <tt>toupper</tt> may be substituted.

 

length_and_lex =: (-@:# ; lower)&>

strings=: 'Here';'are';'some';'sample';'strings';'to';'be';'sorted'

+-------+------+------+----+----+---+--+--+

|strings|sample|sorted|Here|some|are|be|to|

 

=={{header|Java}}==

{{works with|Java|1.5+}}

import java.util.Arrays;

 

System.out.print(s + " ");

}

 

Same thing as above

{{works with|Java|8+}}

import java.util.Arrays;

 

System.out.print(s + " ");

}

 

=={{header|JavaScript}}==

===ES5===

var result = b.length - a.length;

if (result == 0)

var test = ["Here", "are", "some", "sample", "strings", "to", "be", "sorted"];

test.sort(lengthSorter);

 

Or, abstracting a little for simpler composition of compound and derived searches (ASC and DESC, secondary sorts):

 

'use strict';

 

.sort(on(flip(compare), population))

});

 

===ES6===

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>be

 

As illustrated in the example, the comparator may be any jq filter, whether or not it is defined as a function.

if length < 2 then . # it is already sorted

else .[0] as $pivot

end )

| (.[0] | quicksort(cmp) ) + .[1] + (.[2] | quicksort(cmp) )

Example:

["z", "yz", "ab", "c"]

| quicksort( (.[0]|length) > (.[1]|length) or ( (.[0]|length) == (.[1]|length) and .[0] < .[1] ) )

{{Out}}

"ab",

"yz",

"c",

"z"

 

=={{header|Julia}}==

My word list source is the opening sentence of Shelly's [http://www.gutenberg.org/cache/epub/84/pg84.txt Frankenstein].

commencement of an enterprise which you have regarded with such evil

forebodings.""", r"\W+"))

sort!(wl; by=x -> (-length(x), lowercase(x)))

println("\nSorted list:\n - ", join(wl, "\n - "))

 

{{out}}

A translation from Java, also showing the seamless interop between Java and Kotlin code.

 

 

fun main(args: Array<String>) {

Arrays.sort(strings) { first, second ->

val lengthDifference = second.length - first.length

}

 

printArray("Sorted:", strings)

 

{{out}}

<pre>Unsorted: [Here, are, some, sample, strings, to, be, sorted]

Sorted: [strings, sample, sorted, Here, some, are, be, to]</pre>

 

=={{header|Lua}}==

 

function stringSorter(a, b)

 

-- print sorted table

 

{{out}}

 

 

Module Checkit {

Class Quick {

}

Checkit

 

ForStringsSpecial can be coded using a Compare(aj$, lx$). See the use of break to break cases in select cases.

Any case in Select case may have one statement (if then is one statement), or a block of code. We can leave a case with a blank line after, a one statement line, or a block of code, or a case statement. A break statement break cases, so all code executed, until a continue found, to exit from Select (next statement after End Select). We use a sub to make two statements as one.

 

Group Quick {

Module ForStringsSpecial {

}

}

 

{{out}}

</pre>

 

We define a new function to give true or false if two elements are in order.

After that we can simply use the built-in Sort with an ordering function:

If[StringLength[x] == StringLength[y],

OrderedQ[{x, y}],

]

words={"on","sunday","sander","sifted","and","sorted","sambaa","for","a","second"};

gives back:

<pre>{sambaa,sander,second,sifted,sorted,sunday,and,for,on,a}</pre>

 

=={{header|Maxima}}==

s: tokens("Lorem ipsum dolor sit amet consectetur adipiscing elit Sed non risus Suspendisse\

lectus tortor dignissim sit amet adipiscing nec ultricies sed dolor")$

["Suspendisse", "consectetur", "adipiscing", "adipiscing", "dignissim", "ultricies",

"lectus", "tortor", "Lorem", "dolor", "dolor", "ipsum", "risus", "amet", "amet",

 

=={{header|MAXScript}}==

(

case of

strList = #("Here", "are", "some", "sample", "strings", "to", "be", "sorted")

qSort strList myCmp

 

=={{header|min}}==

{{works with|min|0.19.3}}

{{out}}

<pre>

 

=={{header|Nemerle}}==

 

module CustomSort

WriteLine(strings2.Sort((x, y) => x.CompareTo(y)))

}

{{out}}

<pre>[different, strings, length, these, are, of]

=={{header|NetRexx}}==

{{trans|Java}}

options replace format comments java crossref symbols nobinary

 

else signal IllegalArgumentException('Arguments must be Strings')

return cRes

{{out}}

<pre>

 

=={{header|Nial}}==

=+-------+------+------+----+----+---+--+--+

=|strings|sample|sorted|Here|some|are|be|to|

 

=={{header|Nim}}==

 

var strings = "here are Some sample strings to be sorted".split(' ')

)

 

 

=={{header|Objeck}}==

 

class Test {

return @s;

}

 

<pre>

{{works with|Cocoa|Mac OS X 10.6+}}

Using blocks:

 

#define esign(X) (((X)>0)?1:(((X)<0)?-1:0))

}

return EXIT_SUCCESS;

 

 

 

{{works with|Cocoa}}

 

@interface NSString (CustomComp)

}

return EXIT_SUCCESS;

 

This example can also be written using sort descriptors:

{{works with|GNUstep}}

{{works with|Cocoa}}

 

int main()

 

return 0;

 

=={{header|OCaml}}==

if String.length s1 <> String.length s2 then

compare (String.length s2) (String.length s1)

else

 

List:

val strings : string list =

["Here"; "are"; "some"; "sample"; "strings"; "to"; "be"; "sorted"]

# List.sort mycmp strings;;

- : string list =

 

Array:

val strings : string array =

[|"Here"; "are"; "some"; "sample"; "strings"; "to"; "be"; "sorted"|]

# strings;;

- : string array =

 

=={{header|Oforth}}==

 

s size self size > ifTrue: [ true return ]

s size self size < ifTrue: [ false return ]

 

["this", "is", "a", "set", "of", "strings", "to", "sort", "This", "Is", "A", "Set", "Of", "Strings", "To", "Sort"]

 

{{out}}

[Strings, strings, Sort, sort, this, This, Set, set, is, Is, of, Of, To, to, A, a]

</pre>

 

=={{header|ooRexx}}==

say 'Sorted in order of descending length, and in ascending lexicographic order'

say A~sortWith(.DescLengthAscLexical~new)~makeString

if left~length==right~length

then return left~caselessCompareTo(right)

{{out}}

<pre>

Lust

</pre>

 

=={{header|Oz}}==

fun {LexicographicLessThan Xs Ys}

for

Strings = ["Here" "are" "some" "sample" "strings" "to" "be" "sorted"]

in

 

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

 

=={{header|Pascal}}==

{{works with|Free Pascal}}

 

=={{header|Perl}}==

 

 

 

map { [ $_, length, lc ] }

 

=={{header|Phix}}==

{{out}}

<pre>

=={{header|PHP}}==

{{works with|PHP|4.4.4 CLI}}

function mycmp($s1, $s2)

{

$strings = array("Here", "are", "some", "sample", "strings", "to", "be", "sorted");

usort($strings, "mycmp");

 

=={{header|PicoLisp}}==

PicoLisp returns an ascending list (of any type). To get a result in descending

order, the "greater than" function can be supplied

or simply the result reversed (which is, btw, the most efficient way)

 

=={{header|PL/I}}==

 

'''Platform:''' [[WIN]]

 

DCL (T(4)) CHAR(20) VAR; /* scratch space of length N/2 */

 

put skip;

 

=={{header|Pop11}}==

define compare(s1, s2);

lvars k = length(s2) - length(s1);

l2 = length(s2);

l1 > l2 or (l1 == l2 and alphabefore(uppertolower(s1), uppertolower(s2)))

 

=={{header|PowerBASIC}}==

{{works with|PB/CC|4}}

 

'if p1 should be first, returns -1

'if p2 should be first, returns 1

'pb's built-in sorting; "USING" tells it to use our custom comparator

ARRAY SORT x(), USING Sorter()

 

=={{header|PowerShell}}==

The <code>Sort-Object</code> cmdlet accepts script blocks as arguments as well as multiple criteria after which to sort.

The negated string length is the first sort criterion, the second is the string itself, resulting in descending length and ascending lexicographic order.

 

=={{header|Prolog}}==

Works with SWI-Prolog (Tested on Version 8.1.19). Duplicates (if any) are removed.

L = ["Here", "are", "some", "sample", "strings", "to", "be", "sorted" ],

predsort(my_comp, L, L1),

my_write(W) :-

format('~s ', [W]).

 

{{out}}

=={{header|Python}}==

Using a key function is usually more efficient than a comparator. We can take advantage of the fact that tuples are ordered first by the first element, then by the second, etc., to perform a sort on multiple criteria.

 

def mykey(x):

return -len(x), x.upper()

 

 

{{out}}

 

===Alternative method using cmp===

To technically comply with this task, we can also use an actual comparator (''cmp'') function which will be called every time members of the original list are to be compared. Note that this feature is worse than using the key argument and has been removed from Python 3, so should no longer be used in new code.

return cmp(len(s2), len(s1)) or cmp(s1.upper(), s2.upper())

 

 

=={{header|R}}==

 

 

=={{header|Racket}}==

 

#lang racket

 

(sort2 '("Some" "pile" "of" "words"))

;; -> '("words" "pile" "Some" "of")

 

=={{header|Raku}}==

 

=={{header|REXX}}==

/* using mycmp function for the sort order */

/**********************************************************************

Otherwise res=0

End

{{out}}

<pre>

 

=={{header|Ring}}==

load "stdlib.ring"

 

see oList[n] [1] + nl

next

Output:

<pre>

Since Ruby 1.8.6 Enumerables have a "sort_by" method, taking a key block, which is more efficient than a comparator. We can take advantage of the fact that Arrays are ordered first by the first element, then by the second, etc., to perform a sort on multiple criteria.

 

 

To technically comply with this task, we can also use an actual comparator block which will be called every time members of the original list are to be compared.

 

=={{header|Rust}}==

fn main() {

let mut words = ["Here", "are", "some", "sample", "strings", "to", "be", "sorted"];

println!("{:?}", words);

}

 

=={{header|Sather}}==

 

custom_comp(a, b:STR):BOOL is

loop #OUT + s.elt! + "\n"; end;

end;

 

=={{header|Scala}}==

val cmp=a.size-b.size

(if (cmp==0) -a.compareTo(b) else cmp) > 0

{{out}}

<pre>List(strings, sample, sorted, Here, some, are, be, to)</pre>

 

=={{header|Scheme}}==

;;a sort function may be predefined, or available through srfi 95

(define (mypred? a b)

(> len-a len-b))))

 

{{out}}

 

 

{{works with|Gauche Scheme}}

 

"This" "Is" "A" "Set" "Of" "Strings" "To" "Sort" "duplicated"

"this" "is" "a" "set" "of" "strings" "to" "sort" "duplicated"))

(apply string-ci<? two)

(apply > sizes)))))

{{out}}

<pre>

 

=={{header|Sidef}}==

var strings = %w(Here are some sample strings to be sorted);

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

sortBlock:

[:first :second | (second size = first size)

ifFalse: [second size < first size]

 

=={{header|Standard ML}}==

List:

{{works with|SML/NJ}}

if size s1 <> size s2 then

size s2 > size s1

else

 

val strings = ["Here","are","some","sample","strings","to","be","sorted"]

: string list

- ListMergeSort.sort mygt strings;

val it = ["strings","sample","sorted","Here","some","are","be","to"]

 

Array:

{{works with|SML/NJ}}

if size s1 <> size s2 then

Int.compare (size s2, size s1)

else

 

val strings = [|"Here","are","some","sample","strings","to","be","sorted"|]

: string array

- strings;

val it = [|"strings","sample","sorted","Here","some","are","be","to"|]

 

=={{header|Swift}}==

{{works with|Swift|2.x+}}

 

var list = ["this",

return lhsCount > rhsCount

{{works with|Swift|1.2}}

 

var list = ["this",

return lhsCount > rhsCount

 

=={{header|Tcl}}==

set la [string length $a]

set lb [string length $b]

 

set strings {here are Some sample strings to be sorted}

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

setofstrings="this is a set of strings to sort This Is A Set Of Strings To Sort"

PRINT "2. setofstrings sorted"

*{sorted}

{{out}}

<pre style='height:30ex;overflow:scroll'>

The less or equal length predicate (leql) and lexically less or equal predicate (lleq) are also standard library functions. This task is therefore easily dispatched as shown.

 

#show+

 

data = <'this','is','a','list','of','strings','to','be','sorted'>

 

The lleq library function is case sensitive, so it is composed with a function to convert the words to lower case on the fly (without destructively modifying them) in order to meet the task requirement of case insensitivity.

 

=={{header|Visual Basic .NET}}==

 

 

Module Sorting_Using_a_Custom_Comparator

Array.Sort(strings, New Comparison(Of String)(AddressOf CustomComparator))

End Sub

 

=={{header|zkl}}==

r:=s.sort(fcn(a,b){

an,bn := a.len(),b.len();

if(an==bn)(a.toLower() < b.toLower()) else (an > bn)

});

{{out}}

<pre>