Sort the letters of string in alphabetical order: Difference between revisions
Sort the letters of string in alphabetical order (view source)
Revision as of 11:10, 8 February 2024
, 3 months ago→{{header|Wren}}: Changed to Wren S/H
(Ada version) |
m (→{{header|Wren}}: Changed to Wren S/H) |
||
| (40 intermediate revisions by 21 users not shown) | |||
Line 14:
Write the function even if your language has a built-in function for it.
<br><br>
=={{header|11l}}==
<syntaxhighlight lang="11l">F sorted_str(s)
DefaultDict[Char, Int] d
L(c) s
d[c]++
V r = ‘’
L(k) sorted(d.keys())
r ‘’= k * d[k]
R r
print(sorted_str(‘The quick brown fox jumps over the lazy dog, apparently’))
print(sorted_str(‘Is this misspelling of alphabetical as alphabitical a joke ?’))</syntaxhighlight>
{{out}}
<pre>
,Taaabcdeeeefghhijkllmnnoooopppqrrrsttuuvwxyyz
?Iaaaaaaaabbcceeefghhhiiiiiijkllllllmnoopppsssssttt
</pre>
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
<syntaxhighlight lang="action!">INCLUDE "D2:SORT.ACT" ;from the Action! Tool Kit
PROC Test(CHAR ARRAY s)
PrintF("Original:%E""%S""%E%E",s)
SortB(s+1,s(0),0)
PrintF("Sorted:%E""%S""%E%E",s)
RETURN
PROC Main()
Put(125) PutE() ;clear the screen
Test("The quick brown fox jumps over the lazy dog, apparently")
Test("Now is the time for all good men to come to the aid of their country.")
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sort_the_letters_of_string_in_alphabetical_order.png Screenshot from Atari 8-bit computer]
<pre>
Original:
"The quick brown fox jumps over the lazy dog, apparently"
Sorted:
" ,Taaabcdeeeefghhijkllmnnoooopppqrrrsttuuvwxyyz"
Original:
"Now is the time for all good men to come to the aid of their country."
Sorted:
" .Naaccddeeeeeeffghhhiiiillmmmnnooooooooorrrstttttttuwy"
</pre>
=={{header|Ada}}==
<
with Ada.Containers.Generic_Array_Sort;
Line 35 ⟶ 85:
begin
Put_Line (B); Sort (B); Put_Line (B);
end Sort_Letters;</
{{out}}
<pre>When Roman engineers built a bridge, they had to stand under it while the first legion marched across. If programmers today worked under similar ground rules, they might well find themselves getting much more interested in Ada!
Line 42 ⟶ 92:
=={{header|ALGOL 68}}==
As with the Wren, Go and probably other samples, this defines a bubble sort to sort the text. Non-alphabetic characters are retained.
<
# returns s with the characters sorted into lexicographic order #
OP LSORT = ( STRING s )STRING:
Line 64 ⟶ 114:
print( ( LSORT "The quick brown fox jumps over the lazy dog, apparently", newline ) )
print( ( LSORT "Now is the time for all good men to come to the aid of their country.", newline ) )
END</
{{out}}
<pre>
Line 70 ⟶ 120:
.Naaccddeeeeeeffghhhiiiillmmmnnooooooooorrrstttttttuwy
</pre>
=={{header|ALGOL W}}==
Sorts the letters, leaving the non-letters unsorted.
<syntaxhighlight lang="algolw">
begin
% returns s with the letters sorted %
% as Algol W doesn't have variable length strings, %
% the number of characters to sort must be specified %
% in len %
string(256) procedure lSort( string(256) value s; integer value len ) ;
begin
string(256) letters, sortedS;
integer lLen, lPos, u;
sortedS := s;
% get the letters %
letters := "";
lLen := -1;
for i := 0 until len - 1 do begin
string(1) c;
c := s( i // 1 );
if ( c >= "a" and c <= "z" ) or ( c >= "A" and c <= "Z" ) then begin
lLen := lLen + 1;
letters( lLen // 1 ) := c
end if_we_have_a_letter
end for_i ;
% bubble sort the letters %
u := lLen;
while begin
logical sorted;
sorted := true;
u := u - 1;
for p := 0 until u do begin
string(1) c, d;
c := letters( p // 1 );
d := letters( p + 1 // 1 );
if c > d then begin
letters( p // 1 ) := d;
letters( p + 1 // 1 ) := c;
sorted := false
end if_c_gt_d
end for_p ;
not sorted
end do begin end;
% put the sorted letters into the result string %
lPos := -1;
for i := 0 until len - 1 do begin
string(1) c;
c := s( i // 1 );
if ( c >= "a" and c <= "z" ) or ( c >= "A" and c <= "Z" ) then begin
lpos := lPos + 1;
sortedS( i // 1 ) := letters( lPos // 1 )
end if_we_have_a_letter
end for_i ;
sortedS
end lSort ;
% prints the first len characters of s %
procedure writeOnString( string(256) value s; integer value len ) ;
for i := 0 until len - 1 do writeon( s_w := 0, s( i // 1 ) );
% tests the lSort procedure %
procedure testSort( string(256) value s; integer value len ) ;
begin
writeon( s_w := 0, " [" );writeOnString( s, len ); writeon( "]" );write();
writeon( s_w := 0, " -> [" );writeOnString( lSort( s, len ), len ); writeon( "]" );write()
end testSort ;
testSort( "The quick brown fox jumps over the lazy dog, apparently", 55 );
testSort( "Now is the time for all good men to come to the aid of their country.", 69 );
testSort( "Stop! In the name of Wuv!", 25 )
end.
</syntaxhighlight>
{{out}}
<pre>
[The quick brown fox jumps over the lazy dog, apparently]
-> [Taa abcde eeefg hhi jkllm nnoo oop ppqr rrs, ttuuvwxyyz]
[Now is the time for all good men to come to the aid of their country.]
-> [Naa cc dde eeee eff ghh hiii ill mm mnno oo ooo ooo rr rsttt ttttuwy.]
[Stop! In the name of Wuv!]
-> [ISWa! ee fhm nnoo pt tuv!]</pre>
=={{header|APL}}==
{{works with|Dyalog APL}}
<syntaxhighlight lang
{{out}}
<pre> sort 'Now is the time for all good men to come to the aid of their country.'
.Naaccddeeeeeeffghhhiiiillmmmnnooooooooorrrstttttttuwy</pre>
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">sortLetters(str, RemoveSpace := 1){
oChar := []
for i, v in StrSplit(str)
if (v <> " ") && RemoveSpace
oChar[Asc(v), i] := v
else if !RemoveSpace
oChar[Asc(v), i] := v
for ascii, obj in oChar
for i, letter in obj
result .= letter
return result
}</syntaxhighlight>
Examples:<syntaxhighlight lang="autohotkey">str1 := "The quick brown fox jumps over the lazy dog, apparently"
str2 := "Now is the time for all good men to come to the aid of their country."
MsgBox, 262144, , % result := str1 " ->`n" sortLetters(str1)
. "`n`n" str2 " ->`n" sortLetters(str2, 0)</syntaxhighlight>
{{out}}
<pre>The quick brown fox jumps over the lazy dog, apparently ->
,Taaabcdeeeefghhijkllmnnoooopppqrrrsttuuvwxyyz
Now is the time for all good men to come to the aid of their country. ->
.Naaccddeeeeeeffghhhiiiillmmmnnooooooooorrrstttttttuwy</pre>
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax GAWK -f SORT_THE_LETTERS_OF_STRING_IN_ALPHABETICAL_ORDER.AWK
BEGIN {
Line 95 ⟶ 250:
return(str)
}
</syntaxhighlight>
{{out}}
<pre>
Line 103 ⟶ 258:
=={{header|BCPL}}==
<
let sortchars(str) be
Line 123 ⟶ 278:
sortchars(string)
writef("%S*N", string)
$)</
{{out}}
<pre>Now is the time for all good men to come to the aid of their country.
.Naaccddeeeeeeffghhhiiiillmmmnnooooooooorrrstttttttuwy</pre>
=={{header|C}}==
<syntaxhighlight lang="c">#include <stdio.h>
/* Sort a character string in place */
void strsort(char *s) {
unsigned int n[256] = {0};
unsigned char i = 0;
char *t = s;
while (*s) ++n[(unsigned char) *s++];
while (++i) while (n[i]--) *t++ = (char) i;
}
int main() {
char s[] = "Now is the time for all good men "
"to come to the aid of their country.";
puts(s);
strsort(s);
puts(s);
return 0;
}</syntaxhighlight>
{{out}}
<pre>Now is the time for all good men to come to the aid of their country.
.Naaccddeeeeeeffghhhiiiillmmmnnooooooooorrrstttttttuwy</pre>
=={{header|C++}}==
<syntaxhighlight lang="cpp">#include <algorithm>
#include <iostream>
int main() {
std::string s = "Now is the time for all good men "
"to come to the aid of our country.";
std::cout << s << std::endl;
std::sort(s.begin(), s.end());
std::cout << s << std::endl;
return 0;
}</syntaxhighlight>
{{out}}
<pre>Now is the time for all good men to come to the aid of our country.
.Naaccddeeeeeffghhiiillmmmnnoooooooooorrrsttttttuuwy</pre>
=={{header|C#|CSharp}}==
Dubbing the following sorting method as "Slacksort". This "Slacksort" method can easily be adapted for reverse sorting, or removing other characters besides space. Not recommended for larger strings though.
<
class Program {
static void Main(string[] args) {
Line 145 ⟶ 341:
Write( nl + "done..." );
}
}</
Note: this is a bit of a tribute to the original task description and initial Ring entry, so the typographical errors have intentionally not been corrected.
{{out}}
Line 155 ⟶ 351:
done...
</pre>
=={{header|CLU}}==
<syntaxhighlight lang="clu">% Unicode is explicitly not supported, the standard says
% that "every implementation must provide at least 128,
% but no more than 512, characters".
% That means we can do it in O(N) using a counting sort.
sort_string = proc (s: string) returns (string)
char_count: array[int] := array[int]$fill(0,512,0)
for c: char in string$chars(s) do
i: int := char$c2i(c)
char_count[i] := char_count[i]+1
end
sorted_chars: array[char] := array[char]$predict(1,string$size(s))
for i: int in array[int]$indexes(char_count) do
for j: int in int$from_to(1,char_count[i]) do
array[char]$addh(sorted_chars, char$i2c(i))
end
end
return(string$ac2s(sorted_chars))
end sort_string
start_up = proc ()
po: stream := stream$primary_output()
str: string := "Now is the time for all good men to come to the aid of their country."
stream$putl(po, str)
stream$putl(po, sort_string(str))
end start_up</syntaxhighlight>
{{out}}
<pre>Now is the time for all good men to come to the aid of their country.
.Naaccddeeeeeeffghhhiiiillmmmnnooooooooorrrstttttttuwy</pre>
=={{header|Comal}}==
<syntaxhighlight lang="comal">0010 PROC strsort(REF s$) CLOSED
0020 DIM count#(0:255)
0030 FOR i#:=1 TO LEN(s$) DO count#(ORD(s$(i#))):+1
0040 i#:=1
0050 FOR j#:=0 TO 255 DO
0060 IF count#(j#)>0 THEN
0070 s$(i#:i#+count#(j#)-1):=CHR$(j#)*count#(j#)
0080 i#:+count#(j#)
0090 ENDIF
0100 ENDFOR j#
0110 ENDPROC strsort
0120 //
0130 test$:="Now is the time for all good men "
0140 test$:+"to come to the aid of their country."
0150 PRINT test$
0160 strsort(test$)
0170 PRINT test$
0180 END</syntaxhighlight>
{{out}}
<pre>Now is the time for all good men to come to the aid of their country.
.Naaccddeeeeeeffghhhiiiillmmmnnooooooooorrrstttttttuwy</pre>
=={{header|Common Lisp}}==
<syntaxhighlight lang="lisp">
(sort "Now is the time for all good men to come to the aid of their country." #'char<=)
</syntaxhighlight>
{{out}}
<pre>
" .Naaccddeeeeeeffghhhiiiillmmmnnooooooooorrrstttttttuwy"
</pre>
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
Uses Delphi TStringList component to do most of the heavy lifting. The TStringList is designed to hold and maniputlate strings. In the strings are one character long so it sorts characters from the strings.
<syntaxhighlight lang="Delphi">
function SortStringLetters(S: string): string;
{Extract letters from string and sort them}
{Uses string list component to hold and sort chars}
var SL: TStringList;
var I: integer;
begin
SL:=TStringList.Create;
try
for I:=1 to Length(S) do SL.Add(S[I]);
SL.Sort;
SetLength(Result,SL.Count);
for I:=0 to SL.Count-1 do
Result[I+1]:=SL[I][1];
finally SL.Free; end;
end;
const S1 = 'Now is the time for all good men to come to the aid of the party.';
const S2 = 'See the quick brown fox jump over the lazy dog.';
procedure ShowSortedLetters(Memo: TMemo);
var S: string;
begin
Memo.Lines.Add('Unsorted = '+S1);
Memo.Lines.Add('Sorted = '+SortStringLetters(S1));
Memo.Lines.Add('Unsorted = '+S2);
Memo.Lines.Add('Sorted = '+SortStringLetters(S2));
end;
</syntaxhighlight>
{{out}}
<pre>
Unsorted = Now is the time for all good men to come to the aid of the party.
Sorted = .aaacddeeeeeeffghhhiiillmmmNnooooooooprrstttttttwy
Unsorted = See the quick brown fox jump over the lazy dog.
Sorted = .abcdeeeeefghhijklmnoooopqrrSttuuvwxyz
Elapsed Time: 5.996 ms.
</pre>
=={{header|Draco}}==
<syntaxhighlight lang="draco">/* Sort a string in place, using a counting sort. */
proc nonrec stringsort(*char str) void:
[256] word counts;
byte i;
word j;
char c;
channel input text chi;
channel output text cho;
/* zero array */
for i from 0 upto 255 do counts[i] := 0 od;
/* count all characters */
open(chi, str);
while read(chi; c) do counts[c] := counts[c] + 1 od;
close(chi);
/* write the characters back in order */
open(cho, str);
for i from 0 upto 255 do
for j from 1 upto counts[i] do
write(cho; pretend(i, char))
od
od;
close(cho)
corp
/* Test */
proc nonrec main() void:
*char s;
s := "Now is the time for all good men to come to the aid of their country.";
writeln(s);
stringsort(s);
writeln(s)
corp</syntaxhighlight>
{{out}}
<pre>Now is the time for all good men to come to the aid of their country.
.Naaccddeeeeeeffghhhiiiillmmmnnooooooooorrrstttttttuwy</pre>
=={{header|Eiffel}}==
[https://github.com/ljr1981/rosettacode_answers/blob/main/src/sort_string_letters/sort_string_letters.e Example Code]
<syntaxhighlight lang="eiffel">
class
SORT_STRING_LETTERS
feature -- Basic Ops
sort_string (s: STRING): STRING
-- Perform `sort_string' on `s' such that
-- each letter is in ascending alphabetical order.
note
deviation: "[
This Eiffel example deviates from the task requirement for this
Rosetta Code task in that we reuse Eiffel Base library code for
the {SORTED_TWO_WAY_LIST [G]}. We do this for two very good reasons:
1. Reuse is king. Never code what is already coded and tested.
2. The library code is readily available for examination
(i.e. the library code is not hidden and unaccessible).
Based on #1 and #2 above, examine the code in: {SORTED_TWO_WAY_LIST}.make_from_iterable
Specifically, look at the `extend' routine and the routines it calls (i.e. `search_after',
`put_left', and `back'). These routines will tell you the story of how sorting can
be coded in Eiffel. There is no need to rehash that code here.
]"
local
l_list: SORTED_TWO_WAY_LIST [CHARACTER]
do
create l_list.make_from_iterable (s) -- Add & Auto-sort string by chars
create Result.make_empty -- Create the Result STRING
⟳ c:l_list ¦ Result.append_character (c) ⟲ -- Populate it with the sorted chars
Result.adjust -- Remove the leading white space
ensure
no_spaces: ∀ c:Result ¦ c /= ' ' -- All spaces removed.
has_all: ∀ c:Result ¦ s.has (c) -- All non-space chars present.
valid_count: Result.count =
(s.count - s.occurrences (' ')) -- Every character (even repeating).
end
end
</syntaxhighlight>
Notice the use of Design-by-Contract in the "ensure" at the end of `sort_string'. At testing runtime, we want the routine itself to ensure that the resulting string has no space character and that every character that we passed in the `s' argument is represented in the result string. We even go so far as to ensure that repeating characters are all represented. We could go further, but we felt these contracts
were sufficient to get the point of Design-by-Contract across to you as the reader.
Also note the unicode characters of ⟳ .. ⟲ and ∀. These are called across-loops and we have used the "symbolic form" of them. The first one simply says, "Across all items in l_list as c, perform the code between the ¦ and closing ⟲. In the case of the ∀, this is a loop stating that every member of the Result STRING must hold true for the Boolean expression. For example, in the "no_spaces" contract, we are saying that each character "c" must not be equal to a space (e.g. ' ').
And the Test Code to operate it.
[https://github.com/ljr1981/rosettacode_answers/blob/main/testing/rc_sort_string_letters/rc_sort_string_letters_test_set.e Test Code]
<syntaxhighlight lang="eiffel">
class
RC_SORT_STRING_LETTERS_TEST_SET
inherit
TEST_SET_SUPPORT
feature -- Test routines
rc_sort_string_letters_test
-- Test {SORT_STRING_LETTERS}.
note
testing:
"covers/{SORT_STRING_LETTERS}",
"execution/isolated",
"execution/serial"
do
assert_strings_equal ("sorted", now_is_string, item.sort_string ("Now is the time for all good men to come to the aid of their country."))
end
feature {NONE} -- Test Support
now_is_string: STRING = "[
.Naaccddeeeeeeffghhhiiiillmmmnnooooooooorrrstttttttuwy
]"
item: SORT_STRING_LETTERS
-- An `item' for testing.
once
create Result
end
end
</syntaxhighlight>
=={{header|F_Sharp|F#}}==
<
// Alphabetic sort. Nigel Galloway: July 27th., 2021
let fG n g=let g=g|>Seq.countBy id|>Map.ofSeq in [for n in n->if Map.containsKey n g then [|for g in 1..g.[n]->n|]|>System.String else ""]|>String.concat ""
Line 166 ⟶ 605:
n.WriteLine(Turkish (String.filter((<>)' ') "Meseleyi anlamağa başladı"))
</syntaxhighlight>
{{out}}
<pre>
Line 172 ⟶ 611:
aaaaaabdeeeğıilllmMnsşy
</pre>
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">
function value( s as string ) as integer
'maps a=A=0, b=B=1, etc
return asc(ucase(s))-65
end function
sub sortstr( ins as string, outs as string )
dim as string c
dim as integer cv, i, j
outs = ""
for i = 1 to len(ins)
c = mid(ins,i,1)
cv = value(c)
if cv > 25 or cv < 0 then continue for 'this isn't a letter so don't output it
for j = 1 to len(outs)
if value(mid(outs,j,1))>cv then exit for
next j
outs = left(outs,j-1) + c + right(outs,len(outs)-j+1)
next i
end sub
dim as string example = "Once upon a midnight dreary as I pondered weak and weary over many a dumb and buggy line of irritating code"
dim as string sorted
sortstr( example, sorted )
print sorted</syntaxhighlight>
{{out}}<pre>aaaaaaaaaabbccddddddddeeeeeeeeefgggghiiIiiiiklmmmnnnnnnnnnOooooopprrrrrrrstttuuuvwwyyyy</pre>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
local fn AlphabetizeString( string as CFStringRef, deleteSpaces as BOOL ) as CFStringRef
NSUInteger i, count
CFStringRef tempStr, alphaStr = NULL
CFArrayRef array
if deleteSpaces then tempStr = fn StringByReplacingOccurrencesOfString( string, @" ", @"" ) else tempStr = string
count = fn StringLength( tempStr )
CFMutableArrayRef mutArr = fn MutableArrayWithCapacity(count)
for i = 0 to count -1
CFStringRef chr = fn StringWithFormat( @"%C", fn StringCharacterAtIndex( tempStr, i ) )
MutableArrayInsertObjectAtIndex( mutArr, chr, i )
next
array = fn ArraySortedArrayUsingSelector( mutArr, @"localizedCaseInsensitiveCompare:" )
alphaStr = fn ArrayComponentsJoinedByString( array, @"" )
end fn = alphaStr
CFStringRef testStr
testStr = @"The quick brown fox jumped over the lazy dog's back."
print testStr
print "String alphabetized with spaces included:"
print fn AlphabetizeString( testStr, NO )
print
testStr = @"Now is the time for all good men to come to the aid of their country."
print testStr
print "String alphabetized with spaces deleted:"
print fn AlphabetizeString( testStr, YES )
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
The quick brown fox jumped over the lazy dog's back.
String alphabetized with spaces included:
.'aabbccddeeeefghhijkklmnoooopqrrsTtuuvwxyz
Now is the time for all good men to come to the aid of their country.
String alphabetized with spaces deleted:
.aaccddeeeeeeffghhhiiiillmmmNnnooooooooorrrstttttttuwy
</pre>
=={{header|Go}}==
As in the case of the Wren entry, we write a function to bubble sort the characters of a string since this method is not, of course, used in Go's standard 'sort' package.
<
import (
Line 218 ⟶ 732:
fmt.Printf("Sorted ->%s\n\n", res)
}
}</
{{out}}
Line 230 ⟶ 744:
=={{header|Haskell}}==
<
main :: IO ()
Line 236 ⟶ 750:
print $
sort
"Is this misspelling of alphabetical as alphabitical a joke ?"</
{{Out}}
<pre>" ?Iaaaaaaaabbcceeefghhhiiiiiijkllllllmnoopppsssssttt"</pre>
Line 242 ⟶ 756:
Or, sketching a rough re-phrase of the question:
<
main :: IO ()
Line 254 ⟶ 768:
qSort (x : xs) = qSort below <> (x : qSort above)
where
(below, above) = partition (<= x) xs</
{{Out}}
<pre>" ?Iaaaaaaaabbcceeefghhhiiiiiijkllllllmnoopppsssssttt"</pre>
Line 261 ⟶ 775:
Or, just constructing a sorted string from the character counts:
<
----------------- MAP OF CHARACTER COUNTS ----------------
Line 278 ⟶ 792:
. charCounts
)
"Was the misspelling of alphabetical as alphabitical a joke ?"</
{{Out}}
<pre>" ?Waaaaaaaaabbcceeeefghhhiiiiijkllllllmnoopppssssttt"</pre>
=={{header|J}}==
J's builtin is 'grade' and sort is a derived function whose domain includes sequences of characters, so:<syntaxhighlight lang="j"> text0=: 'This is a test'
text1=: 'The sentence "The quick brown fox jumps over the lazy dog" uses every letter in the alphabet.'
/:~ text0
Taehiissstt
/:~ text1
"".TTaaabbccdeeeeeeeeeeeeeefghhhhhiijklllmnnnnooooppqrrrrssssttttttuuuvvwxyyz</syntaxhighlight>
However, sorting characters is easy to implement using [[wp:Bucket_sort|bucket sort]]:<syntaxhighlight lang="j"> {{a.#~<:#/.~a.,y}} text0
Taehiissstt
{{a.#~<:#/.~a.,y}} text1
"".TTaaabbccdeeeeeeeeeeeeeefghhhhhiijklllmnnnnooooppqrrrrssssttttttuuuvvwxyyz</syntaxhighlight>
(Since there's no comparison between pairs in bucket sort, performance here is O(n) rather than O(n log n).)
=={{header|jq}}==
Line 287 ⟶ 816:
An efficient way to sort an arbitrary JSON string is to use the code points of the constituent characters:
<syntaxhighlight lang="jq">
def sort_by_codepoints:
explode | sort | implode;</
For example:
<
| sort_by_codepoints</
<syntaxhighlight lang="text">def sort_by_characters:
explode | map([.]|implode) | sort | add;</
"✁✂✃✄✆✇✈✉✌✍✎✏✐✑✒✓✔✕✖✗✘✙✚✛✜✝✞✟✠✡✢✣✤✥✦✧✩✪✫✬✭✮✯✰✱✲✳✴✵✶✷✸✹✺✻✼✽✾✿❀❁❂❃❄❅❆❇❈❉❊❋❍❏❐❑❒❖❘❙❚❛❜❝❞❡❢❣❤❥❦❧❶❷❸❹❺❻❼❽❾❿➀➁➂➃➄➅➆➇➈➉➊➋➌➍➎➏➐➑➒➓➔➘➙➚➛➜➝";
Line 302 ⟶ 831:
dingbats
| (sort_by_codepoints==sort_by_characters)
</
<pre>
true
Line 310 ⟶ 839:
=={{header|Julia}}==
<
high <= low && return array
middle = low + div(high - low, 2)
Line 354 ⟶ 883:
testmergesort("forever julia programming language")
testmergesort("Now is the time for all good men to come to the aid of their country.", false)
</
<pre>
Unsorted -> forever julia programming language
Line 363 ⟶ 892:
=== case insensitive quicksort ===
<
length(array) < 2 && return array
mid, left, right = first(array), eltype(array)[], eltype(array)[]
Line 381 ⟶ 910:
testqsort("forever julia programming language")
testqsort("Now is the time for all good men to come to the aid of their country.")
</
<pre>
Unsorted -> forever julia programming language
Line 388 ⟶ 917:
Sorted -> .aaccddeeeeeeffghhhiiiillmmmNnnooooooooorrrstttttttuwy
</pre>
=== alphabet-only counting version ===
<syntaxhighlight lang="julia">
const alphabets = "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz"
function lettercountingsort(s)
sorted = Char[]
for l in alphabets
append!(sorted, fill(l, count(==(l), s)))
end
return String(sorted)
end
println(lettercountingsort("Now is the time for all good men to come to the aid of their country."))
</syntaxhighlight>{{out}}
<pre>
aaccddeeeeeeffghhhiiiillmmmNnnooooooooorrrstttttttuwy
</pre>
=={{header|K}}==
{{works with|ngn/k}}<syntaxhighlight lang=K>{x@<_x}"This is a test"
" aehiisssTtt"
{x@<_x}"The sentence \"The quick brown fox jumps over the lazy dog\" uses every letter of the alphabet."
" \"\".aaabbccdeeeeeeeeeeeeeeffghhhhhijklllmnnnoooooppqrrrrssssTtTtttttuuuvvwxyyz"
{x@<x}"This is a test" / remove the _ to sort in ascii order rather than alphabetic order
" Taehiissstt"</syntaxhighlight>
=={{header|Lua}}==
<syntaxhighlight lang="lua">fcoll = {} -- forward collation
sl = string.lower -- for case insensitivity
for i=0,255 do fcoll[i]=string.char(i) end -- initially just ASCII (for non-letters)
table.sort(fcoll, function(a,b) return sl(a)==sl(b) and a<b or sl(a)<sl(b) end) -- interleave upper/lower letters
rcoll = {} for i,v in ipairs(fcoll) do rcoll[v]=i end -- reverse collation
function sort(s) -- Latin letters lexicographically, uppercase first, anything else by ASCII
local t={} s:gsub("(%S)", function(c) t[#t+1]=c end) -- use "(.)" as pattern to preserve whitespace
table.sort(t, function(a,b) return rcoll[a]<rcoll[b] end)
return table.concat(t)
end
print(sort("Now is the time for all good men to come to the aid of their country."))</syntaxhighlight>
{{out}}
<pre>.aaccddeeeeeeffghhhiiiillmmmNnnooooooooorrrstttttttuwy</pre>
Concise version, implicit rather than explicit collation sequence table, adequate for this use, same output:
<syntaxhighlight lang="lua">function sort(s) -- Latin letters lexicographically, uppercase first, anything else by ASCII
local sl,t=string.lower,{} s:gsub("(%S)", function(c) t[#t+1]=c end) -- use "(.)" as pattern to preserve whitespace
table.sort(t, function(a,b) return sl(a)==sl(b) and a<b or sl(a)<sl(b) end) -- implicitly
return table.concat(t)
end
print(sort("Now is the time for all good men to come to the aid of their country."))</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
sortstring["Now is the time for all good men to come to the aid of their country."]</
{{out}}
<pre>". aaccddeeeeeeffghhhiiiillmmmnnNooooooooorrrstttttttuwy"</pre>
=={{header|Nim}}==
<
func sorted(text: string; omitSpaces = false): string =
Line 405 ⟶ 984:
echo sorted("The quick brown fox jumps over the lazy dog, apparently", false)
echo sorted("Now is the time for all good men to come to the aid of their country.", true)</
{{out}}
<pre> ,Taaabcdeeeefghhijkllmnnoooopppqrrrsttuuvwxyyz
.Naaccddeeeeeeffghhhiiiillmmmnnooooooooorrrstttttttuwy</pre>
=={{header|Pascal}}==
{{works with|Extended Pascal}}
In Pascal it is guaranteed that all letters of the Modern English alphabet, <tt>'A'</tt> through <tt>'Z'</tt> and <tt>'a'</tt> through <tt>'z'</tt>, are in alphabetical order.
That means <tt>ord('A') < ord('B')</tt>.
However, uppercase and lowercase letters may be separate (like in ASCII), fully or partially interspersed.
The output of this program may differ in that regard.
<syntaxhighlight lang="pascal">program sortTheLettersOfStringInAlphabeticalOrder(input, output);
type
line = string(80);
{
sort characters in a string
\param sample the string to sort
\return \param sample so for all n < m: sample[n] <= sample[m]
}
function alphabeticallySorted(sample: line): line;
var
c: char;
{ `sample.capacity` refers to 80 in this program. }
i: 0..sample.capacity;
{ `… value [otherwise 0]` is an initial state specification. }
tab: array[char] of 0..sample.capacity value [otherwise 0];
begin
{ analyze: how many occurrences of every character? }
for i := 1 to length(sample) do
begin
tab[sample[i]] := tab[sample[i]] + 1
end;
{ process: rebuild string but in alphabetical order }
sample := '';
for c := chr(0) to maxChar do
begin
for i := 1 to tab[c] do
begin
sample := sample + c
end
end;
{ finish: set result variable }
alphabeticallySorted := sample
end;
{ === MAIN =================================================== }
var
s: line;
begin
while not EOF do
begin
readLn(s);
writeLn(alphabeticallySorted(s))
end
end.</syntaxhighlight>
=={{header|Perl}}==
<
use strict; # https://rosettacode.org/wiki/Sort_the_letters_of_string_in_alphabitical_order
Line 448 ⟶ 1,084:
1 while s/(.)(.)(??{$1 le $2 && '(*FAIL)'})/$2$1/g;
return $_;
}</
{{out}}
<pre>
Line 475 ⟶ 1,111:
=={{header|Phix}}==
Not sure this algorithm actually ''has'' a name, but it certainly ain't the fastest, though it possibly ''is'' just about the shortest...<br><small>(If pressed I would dub this "Unoptimised bubble sort without the swapped flag")</small>
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">string_sort</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
Line 492 ⟶ 1,128:
<span style="color: #004080;">string</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"Now is the time for all good men to come to the aid of their country."</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Original:\"%s\",\n Sorted:\"%s\"\n Builtin:\"%s\"\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">string_sort</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">sort</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)})</span>
<!--</
{{out}}
<pre>
Line 501 ⟶ 1,137:
===case insensitive===
You can make this case insensitive by applying lower() on each internal comparison, whereas with the builtins that is done (more efficiently) by extracting a custom tagsort.<br><small>(Just to keep you on your toes I've also replaced the algorithm with a fractionaly saner insertion sort, and just to be awkward I've added the baNAnaBAnaNA case.)</small>
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">string_sort</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
Line 521 ⟶ 1,157:
<span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Now is the time for all good men to come to the aid of their country."</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"baNAnaBAnaNA"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (just to be awkward)</span>
<!--</
{{out}}
<pre>
Line 532 ⟶ 1,168:
</pre>
Should you want/prefer the output of baNAnaBAnaNA to be AAAaaaBaNNnn, change the test (leaving the builtin/cia as an exercise) to
<!--<
<span style="color: #008080;">while</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">>=</span><span style="color: #000000;">2</span> <span style="color: #008080;">and</span> <span style="color: #0000FF;">(</span><span style="color: #7060A8;">lower</span><span style="color: #0000FF;">(</span><span style="color: #000000;">sj</span><span style="color: #0000FF;">)<</span><span style="color: #7060A8;">lower</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">])</span> <span style="color: #008080;">or</span> <span style="color: #000000;">sj</span><span style="color: #0000FF;">=</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]-</span><span style="color: #000000;">32</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<!--</
Or of course for aaaAAAbBnnNN use
<!--<
<span style="color: #008080;">while</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">>=</span><span style="color: #000000;">2</span> <span style="color: #008080;">and</span> <span style="color: #0000FF;">(</span><span style="color: #7060A8;">lower</span><span style="color: #0000FF;">(</span><span style="color: #000000;">sj</span><span style="color: #0000FF;">)<</span><span style="color: #7060A8;">lower</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">])</span> <span style="color: #008080;">or</span> <span style="color: #000000;">sj</span><span style="color: #0000FF;">-</span><span style="color: #000000;">32</span><span style="color: #0000FF;">=</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">])</span> <span style="color: #008080;">do</span>
<!--</
=={{header|Python}}==
<
from functools import reduce
Line 597 ⟶ 1,233:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre>" ?Iaaaaaaaabbcceeefghhhiiiiiijkllllllmnoopppsssssttt"</pre>
=={{header|Quackery}}==
With regard to the [[Talk:Sort the letters of string in alphabetical order|discussion]] regarding the nature of the task, I am construing the phrases "alphabetical order" and "lexicographical order" to mean QACSFOT order. ('''''Q'''uackery '''A'''rbitrary '''C'''haracter '''S'''equence '''F'''or '''O'''rdered '''T'''ext'')
We take the 96 printable characters that Quackery recognises in their native (ASCII/Unicode) order, and sort them into QACSFOT order using a word <code>qacsort</code> that we have defined to do that.
<syntaxhighlight lang="Quackery"> [ sortwith [ qacsfot dip qacsfot > ] ] is qacsort ( $ --> $ )
[] 94 times [ i^ 1+ space + join ]
say "Native order:" cr
dup echo$ cr cr
say "QACSFOT order:" cr
qacsort echo$</syntaxhighlight>
{{out}}
<pre>Native order:
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
QACSFOT order:
0123456789AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz()[]{}<>~=+-*/^\|_.,:;?!'"`%@&#$</pre>
=={{header|Raku}}==
===Semi-realistic version===
<syntaxhighlight lang="raku"
constant @lexographic_order = sort *.fc, map &chr, 1..255;
Line 616 ⟶ 1,275:
Now is the time for all good men to come to the aid of their country.
END
</syntaxhighlight>
{{out}}
<pre>
Line 631 ⟶ 1,290:
Sorted output is wrapped in double guillemots to make it easier to see where it starts and ends.
<syntaxhighlight lang="raku"
my $chars = $string.chars;
loop {
Line 658 ⟶ 1,317:
say "\nExtended test string:\n" ~ my $test = (32..126)».chr.pick(*).join;
say wrap moronic-sort $test;</
{{out}}
Line 678 ⟶ 1,337:
The particular string used is from a typing drill devised by Charles E. Weller in the early 20th century.
<
parse arg y /*generate the array elements (items).*/
if y='' then y= "Now is the time for all good men to come to the aid of their country."
Line 696 ⟶ 1,355:
/*──────────────────────────────────────────────────────────────────────────────────────*/
make@: parse arg z; #= length(z); do j=1 for #; @.j= substr(z, j, 1); end; return
makeS: parse arg a; $=; do j=1 for #; $= $ || @.j; end; return</
{{out|output|text= when using the default input:}}
<pre>
Line 704 ⟶ 1,363:
=={{header|Ring}}==
<
see "working..." + nl
see "Sort the letters of string in alphabitical order:" + nl
Line 723 ⟶ 1,382:
see "Output: " + str + nl
see "done..." + nl
</syntaxhighlight>
{{out}}
<pre>
Line 731 ⟶ 1,390:
Output: aaaeeefgggggiilmmnnnooprrrrruv
done...
</pre>
=={{header|RPL}}==
{{works with|HP|48G}}
≪ { }
1 3 PICK SIZE '''FOR''' j
OVER j DUP SUB + '''NEXT'''
SWAP DROP
SORT ∑LIST
≫ '<span style="color:blue">STRORT</span>' STO
"The quick brown fox jumps over the lazy dog, apparently" <span style="color:blue">STRORT</span>
{{out}}
<pre>
1: " ,Taaabcdeeeefghhijkllmnnoooopppqrrrsttuuvwxyyz"
</pre>
=={{header|VBScript}}==
VBScript can't index a string so first we convert the string to an array of chars, then use join to get back a string
<syntaxhighlight lang="vb">
sub bubble(arr)
n = UBound(arr)
Do
nn = -1
For j = 0 to n - 1
If arr(j) > arr(j + 1) Then
temp= arr(j):arr(j)=arr(j+1):arr(j+1)=temp
nn = j
End If
Next
n = nn
Loop Until nn = -1
end sub
s="The quick brown fox jumps over the lazy dog, apparently"
redim a(len(s)-1)
for i=1 to len(s)
a(i-1)=mid(s,i,1)
next
bubble a
s1=join(a,"")
wscript.echo s1
</syntaxhighlight>
{{out}}
<pre>
,Taaabcdeeeefghhijkllmnnoooopppqrrrsttuuvwxyyz
</pre>
=={{header|Wren}}==
Well, we'll write a function for a bubble sort which we don't have in Wren-sort because it's normally much slower than the other methods. However, it's fast enough here.
<
var chars = s.toList
var n = chars.count
Line 760 ⟶ 1,466:
System.print(["Unsorted->" + str[0], "Sorted ->" + bubbleSort.call(str[0], str[1])].join("\n"))
System.print()
}</
{{out}}
Line 772 ⟶ 1,478:
=={{header|XPL0}}==
<
func StrLen(Str); \Return number of characters in an ASCIIZ string
Line 794 ⟶ 1,500:
Text(0, Sort("Pack my box with five dozen liquor jugs."));
CrLf(0);
]</
{{out}}
Line 801 ⟶ 1,507:
.Pabcdeefghiiijklmnoooqrstuuvwxyz
</pre>
=={{header|Yabasic}}==
<syntaxhighlight lang="yabasic">// Rosetta Code problem: http://rosettacode.org/wiki/Sort_the_letters_of_string_in_alphabetical_order
// by Galileo, 04/2022
sub Sorted$(t$)
local chars(255), c, i, j, r$
for i = 1 to len(t$)
c = asc(mid$(t$, i, 1))
chars(c) = chars(c) + 1
next
for i = 32 to 126
c = chars(i)
if c then
for j = 1 to c
r$ = r$ + chr$(i)
next
end if
next
return r$
end sub
text$ = "Sort the letters of string in alphabitical order."
print text$
print Sorted$(text$)</syntaxhighlight>
{{out}}
<pre>Sort the letters of string in alphabitical order.
.Saaabcdeeeefghhiiiilllnnoooprrrrrsstttttt
---Program done, press RETURN---</pre>
| |||