Sort using a custom comparator: Difference between revisions

{{trans|Python}}

{{out}}

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program customSort64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

<pre>

Name : London country : UK

=={{header|Action!}}==

PROC PrintArray(PTR ARRAY a INT size)

Test(a,24,CustomComparator)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sort_using_a_custom_comparator.png Screenshot from Atari 8-bit computer]

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

While vanilla AppleScript doesn't have sort facilities of its own, a customisable sort written in vanilla, such as [https://macscripter.net/viewtopic.php?pid=194430#p194430 this one on MacScripter], can be fed user-defined comparison handlers to do practically any kind of sorting. The following assumes that the customisable sort just mentioned has been compiled and saved in a suitable "Script Libraries" folder as "Custom Iterative Ternary Merge Sort.scpt":

use sorter : script "Custom Iterative Ternary Merge Sort"

-- Sort the whole list using the above customiser.

tell sorter to sort(listOfText, 1, -1, {comparer:descendingByLengthThenAscendingLexicographically})

{{output}}

=={{header|ATS}}==

comparator. *)

println! sorted4;

println! sorted5

{{out}}

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

ELENA 5.0 :

import system'routines;

import system'culture;

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

.sort:(p,n => p.toUpper(invariantLocale) < n.toUpper(invariantLocale)).asEnumerable())

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

=={{header|Frink}}==

The program statement is somewhat naive in saying "lexicographic order" as if it a single, well-defined thing. Lexicographic sorting rules and alphabetization rules vary widely from human language to human language and require a great deal of knowledge of those rules and of Unicode to perform correctly. Frink, however, has knowledge of alphabetization (collation) rules for a large number of human languages and will make you look smart. These are encapsulated in the <CODE>lexicalCompare</CODE> and <CODE>lexicalSort</CODE> functions. By default, these compare based on the language settings defined by your Java Virtual Machine (which should be those for your human language.) The following sorts Unicode correctly according to your human language's conventions. However, see below for a more flexible example that sorts for many of the world's languages!

len = length[b] <=> length[a]

if len != 0

words = split[%r/\s+/, "Here are some sample strings to be sorted"]

{{out}}

<pre>

Alternately, here is a surprisingly powerful version of the sorter above that can sort based on the alphabetization rules of a very wide number of human languages. The language for the lexicographic comparison can be specified to the <CODE>lexicalCompare</CODE> function as an ISO 639-1 two-letter language code, or can be even more specific. For example, the following sorts a list of words based on the alphabetization rules for Danish.

words = ["Ærø", "Aalborg", "Tårnby", "Vejen", "Thisted", "Stevns", "Sønderborg", "Eliasen"]

{{out}}

<pre>

=={{header|FunL}}==

{{out}}

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

import Data.Ord (comparing)

]

)

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

Generally speaking, J uses the concept of sorting against a normalized content (which is what <code>length_and_lex</code> provided in the above example). This eliminates a class of errors (which might be conceptualized by using a custom comparator which generates a random number: order would be non-deterministic and sorted order would depend on details of the sorting algorithm) and supports O(n) sorting algorithms such as bin sort (which cannot use comparators).

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

printArray("Sorted:", strings)

{{out}}

A more idiomatic version (1.3):

val strings = listOf("Here", "are", "some", "sample", "strings", "to", "be", "sorted")

println("Unsorted: $strings")

println("Sorted: $sorted")

Using a custom comparator as requested by task description:

val strings = listOf("Here", "are", "some", "sample", "strings", "to", "be", "sorted")

println("Unsorted: $strings")

println("Sorted: $sorted")

Faster when computing length and lowercase only once per value ([[wp:Schwartzian transform|Schwartzian transform]]):

val strings = listOf("Here", "are", "some", "sample", "strings", "to", "be", "sorted")

println("Unsorted: $strings")

println("Sorted: $sorted")

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

=={{header|Maple}}==

local len1, len2;

len1 := StringTools:-Length(s1);

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

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

)

{{out}}

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

=={{header|Ol}}==

(import (scheme char))

"hendrerit" "viverra" "turpis" "ac" "sagittis"

"arcu" "pharetra" "id")))

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

=={{header|OxygenBasic}}==

uses generics 'containing sort macros

uses console

next

pause

=={{header|Oz}}==

fun {LexicographicLessThan Xs Ys}

for

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

in

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

=={{header|Pascal}}==

=={{header|Perl}}==

@strings = qw/Here are some sample strings to be sorted/;

sort { $b->[1] <=> $a->[1] || $a->[2] cmp $b->[2] }

map { [ $_, length, lc ] }

{{out}}

<pre>strings sample sorted Here some are be to

=={{header|Phix}}==

{{libheader|Phix/basics}}

<span style="color: #008080;">function</span> <span style="color: #000000;">my_compare</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">integer</span> <span style="color: #000000;">c</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">-</span><span style="color: #7060A8;">compare</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">b</span><span style="color: #0000FF;">))</span> <span style="color: #000080;font-style:italic;">-- descending length</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">custom_sort</span><span style="color: #0000FF;">(</span><span style="color: #000000;">my_compare</span><span style="color: #0000FF;">,{</span><span style="color: #008000;">"Here"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"are"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"some"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"sample"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"strings"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"to"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"be"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"sorted"</span><span style="color: #0000FF;">})</span>

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

witheach

[ upper join ] ] is upper$ ( $ --> )

$ "sharna pax and hed on a poal when the ardship of Cambry come out of his hoal"

nest$ sortwith comparator

{{out}}

=={{header|R}}==

=={{header|Racket}}==

#lang racket

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

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

=={{header|Raku}}==

(formerly Perl 6)<br>

Primary sort by length of string, then break ties by sorting alphabetically (ignoring case).

put @strings.sort:{.chars, .lc};

{{out}}

<pre>be to are Here some sample sorted strings

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