Sort using a custom comparator: Difference between revisions

 

 

 

 

begin

Strings(To) := Strings(From);

begin

begin

end Lt;

begin

end loop;

begin

New_Line;

New_Line;

 

 

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

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

 

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

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

int mycmp(const void *s1, const void *s2)

{

const char *l = *(const char **)s1, *r = *(const char **)s2;

return strcasecmp(l, r);

}

int main()

{

return 0;

 

 

 

 

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

 

using System.Collections.Generic;

 

// Custom compare

public int CustomCompare(String x, String y) {

if (result == 0) {

result = x.ToLower().CompareTo(y.ToLower());

}

}

 

<pre>Unsorted

********

to

</pre>

 

=={{header|Clean}}==

 

less s1 s2

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

 

 

=={{header|Clojure}}==

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

(if (= len1 len2)

(compare (.toLowerCase s1) (.toLowerCase s2))

 

 

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

 

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

2dup [ length ] compare invert-comparison

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

 

 

=={{header|Fortran}}==

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

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

 

 

=={{header|Haskell}}==

{{works with|GHC}}

 

 

 

 

 

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

}

 

=={{header|JavaScript}}==

var result = b.length - a.length;

if (result == 0)

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

test.sort(lengthSorter);

 

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

gives back:

 

=={{header|MAXScript}}==

(

case of

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

qSort strList myCmp

 

=={{header|Nial}}==

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

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

 

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

{{works with|GNUstep}}

 

{{works with|Cocoa}}

 

@interface NSString (CustomComp)

- (NSComparisonResult)my_compare: (id)obj

{

}

@end

int main()

{

 

 

 

}

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