Sort using a custom comparator: Difference between revisions

 

 

 

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

this

is

To

a

 

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

#

# sorting:

PROCINFO["sorted_in"] = "@ind_num_desc" ; SORTTYPE = 9

for (i in arr) {

for (j in arr[i]) {

for (k=1; k<=arr[i][j]; k++) {

exit(0)

}

<pre>

unsorted:

Strings

strings

Sort

This

this

set

is

of

to

a

</pre>

 

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

 

 

 

 

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

 

using System.Collections.Generic;

 

}

}

 

<pre>Unsorted

********

 

=== Alternative using Linq (.NET 3.5) ===

using System.Collections.Generic;

using System.Linq;

}

}

 

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

 

<pre>

(strings sample sorted Here some are be to)

 

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

 

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

 

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

 

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

 

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

 

===Alternative Version===

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

 

auto parts = "here are Some sample strings to be sorted".split;

parts.writeln;

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

function(const Left, Right: string): Integer

begin

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

 

<pre>Unsorted:

{

"to"

}</pre>

 

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

match compare s2.Length s1.Length with

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

let sortedStrings = List.sortWith myCompare strings

 

 

<pre>["strings"; "sample"; "sorted"; "Here"; "some"; "are"; "be"; "to"]</pre>

 

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

{

}

}

 

<pre>

$ fan comparator-sort.fan

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

 

 

{{out}}

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

</pre>

 

=={{header|Go}}==

 

import (

sort.Sort(s)

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

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

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

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

}

 

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

 

=={{header|Haskell}}==

{{works with|GHC}}

 

 

 

 

 

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

 

Unsorted Input :

"Here"

 

=={{header|J}}==

 

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

var result = b.length - a.length;

if (result == 0)

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

test.sort(lengthSorter);

 

=={{header|Lua}}==

 

function stringSorter(a, b)

 

-- print sorted table

 

 

 

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

 

module CustomSort

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

}

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

[apple, chewy, House, Later, rises, Salty]</pre>

=={{header|NetRexx}}==

{{trans|Java}}

options replace format comments java crossref symbols nobinary

 

else signal IllegalArgumentException('Arguments must be Strings')

return cRes

<pre>

[Here,are,some,sample,strings,to,be,sorted]

 

=={{header|Nial}}==

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

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

 

 

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

 

 

 

=={{header|Objective-C}}==

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

 

 

 

<pre>

gluttony

avarice

sloth

envy

</pre>

 

=={{header|Oz}}==

fun {LexicographicLessThan Xs Ys}

for

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

in

 

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

 

=={{header|Perl}}==

 

 

 

map { [ $_, length, lc ] }

 

 

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

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

predsort(my_comp, L, L1),

 

my_comp(Comp, W1, W2) :-

( L1 < L2 -> Comp = '>'

; L1 > L2 -> Comp = '<'

my_write(W) :-

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

 

<pre> ?- rosetta_sort.

Input list :

true.

</pre>

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

 

 

 

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

/* using mycmp function for the sort order */

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

Otherwise res=0

End

<pre>

element 1 before sort: ---The seven deadly sins---

</pre>

 

 

 

=={{header|Ruby}}==

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

(define (mypred? a b)

(let ((len-a (string-length a))

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

 

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

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

1. setofstrings unsorted

 

=={{header|Ursala}}==

 

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

 

strings

sorted

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

 

 

Module Sorting_Using_a_Custom_Comparator

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

End Sub

 

=={{header|zkl}}==

{{out}}

<pre>