Sort the letters of string in alphabetical order: Difference between revisions

=={{header|11l}}==

DefaultDict[Char, Int] d

L(c) s

print(sorted_str(‘The quick brown fox jumps over the lazy dog, apparently’))

{{out}}

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

{{libheader|Action! Tool Kit}}

PROC Test(CHAR ARRAY s)

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

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

=={{header|Ada}}==

with Ada.Containers.Generic_Array_Sort;

begin

Put_Line (B); Sort (B); Put_Line (B);

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

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

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

{{out}}

<pre>

=={{header|APL}}==

{{works with|Dyalog APL}}

{{out}}

<pre> sort 'Now is the time for all good men to come to the aid of their country.'

=={{header|AutoHotkey}}==

oChar := []

for i, v in StrSplit(str)

result .= letter

return result

str2 := "Now is the time for all good men to come to the aid of their country."

MsgBox, 262144, , % result := str1 " ->`n" sortLetters(str1)

{{out}}

<pre>The quick brown fox jumps over the lazy dog, apparently ->

=={{header|AWK}}==

# syntax GAWK -f SORT_THE_LETTERS_OF_STRING_IN_ALPHABETICAL_ORDER.AWK

BEGIN {

return(str)

}

{{out}}

<pre>

=={{header|BCPL}}==

let sortchars(str) be

sortchars(string)

writef("%S*N", string)

{{out}}

<pre>Now is the time for all good men to come to the aid of their country.

=={{header|C}}==

/* Sort a character string in place */

puts(s);

return 0;

{{out}}

<pre>Now is the time for all good men to come to the aid of their country.

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

#include <iostream>

std::cout << s << std::endl;

return 0;

{{out}}

<pre>Now is the time for all good men to come to the aid of our country.

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

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

=={{header|CLU}}==

% that "every implementation must provide at least 128,

% but no more than 512, characters".

stream$putl(po, str)

stream$putl(po, sort_string(str))

{{out}}

<pre>Now is the time for all good men to come to the aid of their country.

=={{header|Comal}}==

0020 DIM count#(0:255)

0030 FOR i#:=1 TO LEN(s$) DO count#(ORD(s$(i#))):+1

0160 strsort(test$)

0170 PRINT test$

{{out}}

<pre>Now is the time for all good men to come to the aid of their country.

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

(sort "Now is the time for all good men to come to the aid of their country." #'char<=)

{{out}}

<pre>

=={{header|Draco}}==

proc nonrec stringsort(*char str) void:

[256] word counts;

stringsort(s);

writeln(s)

{{out}}

<pre>Now is the time for all good men to come to the aid of their country.

[https://github.com/ljr1981/rosettacode_answers/blob/main/src/sort_string_letters/sort_string_letters.e Example Code]

class

SORT_STRING_LETTERS

end

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

[https://github.com/ljr1981/rosettacode_answers/blob/main/testing/rc_sort_string_letters/rc_sort_string_letters_test_set.e Test Code]

class

RC_SORT_STRING_LETTERS_TEST_SET

end

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

n.WriteLine(Turkish (String.filter((<>)' ') "Meseleyi anlamağa başladı"))

{{out}}

<pre>

=={{header|FreeBASIC}}==

function value( s as string ) as integer

'maps a=A=0, b=B=1, etc

sortstr( example, sorted )

{{out}}<pre>aaaaaaaaaabbccddddddddeeeeeeeeefgggghiiIiiiiklmmmnnnnnnnnnOooooopprrrrrrrstttuuuvwwyyyy</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 (

fmt.Printf("Sorted ->%s\n\n", res)

}

{{out}}

=={{header|Haskell}}==

main :: IO ()

print $

sort

{{Out}}

<pre>" ?Iaaaaaaaabbcceeefghhhiiiiiijkllllllmnoopppsssssttt"</pre>

Or, sketching a rough re-phrase of the question:

main :: IO ()

qSort (x : xs) = qSort below <> (x : qSort above)

where

{{Out}}

<pre>" ?Iaaaaaaaabbcceeefghhhiiiiiijkllllllmnoopppsssssttt"</pre>

Or, just constructing a sorted string from the character counts:

----------------- MAP OF CHARACTER COUNTS ----------------

. charCounts

)

{{Out}}

<pre>" ?Waaaaaaaaabbcceeeefghhhiiiiijkllllllmnoopppssssttt"</pre>

=={{header|J}}==

text1=: 'The sentence "The quick brown fox jumps over the lazy dog" uses every letter in the alphabet.'

/:~ text0

Taehiissstt

/:~ text1

Taehiissstt

{{a.#~<:#/.~a.,y}} text1

(Since there's no comparison between pairs in bucket sort, performance here is O(n) rather than O(n log n).)

An efficient way to sort an arbitrary JSON string is to use the code points of the constituent characters:

def sort_by_codepoints:

For example:

"✁✂✃✄✆✇✈✉✌✍✎✏✐✑✒✓✔✕✖✗✘✙✚✛✜✝✞✟✠✡✢✣✤✥✦✧✩✪✫✬✭✮✯✰✱✲✳✴✵✶✷✸✹✺✻✼✽✾✿❀❁❂❃❄❅❆❇❈❉❊❋❍❏❐❑❒❖❘❙❚❛❜❝❞❡❢❣❤❥❦❧❶❷❸❹❺❻❼❽❾❿➀➁➂➃➄➅➆➇➈➉➊➋➌➍➎➏➐➑➒➓➔➘➙➚➛➜➝";

dingbats

| (sort_by_codepoints==sort_by_characters)

<pre>

true

=={{header|Julia}}==

high <= low && return array

middle = low + div(high - low, 2)

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

=== case insensitive quicksort ===

length(array) < 2 && return array

mid, left, right = first(array), eltype(array)[], eltype(array)[]

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

=== alphabet-only counting version ===

const alphabets = "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz"

println(lettercountingsort("Now is the time for all good men to come to the aid of their country."))

<pre>

aaccddeeeeeeffghhhiiiillmmmNnnooooooooorrrstttttttuwy

=={{header|Lua}}==

sl = string.lower -- for case insensitivity

for i=0,255 do fcoll[i]=string.char(i) end -- initially just ASCII (for non-letters)

end

{{out}}

<pre>.aaccddeeeeeeffghhhiiiillmmmNnnooooooooorrrstttttttuwy</pre>

Concise version, implicit rather than explicit collation sequence table, adequate for this use, same output:

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

end

=={{header|Mathematica}}/{{header|Wolfram Language}}==

{{out}}

<pre>". aaccddeeeeeeffghhhiiiillmmmnnNooooooooorrrstttttttuwy"</pre>

=={{header|Nim}}==

func sorted(text: string; omitSpaces = false): string =

echo sorted("The quick brown fox jumps over the lazy dog, apparently", false)

{{out}}

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.

type

writeLn(alphabeticallySorted(s))

end

=={{header|Perl}}==

use strict; # https://rosettacode.org/wiki/Sort_the_letters_of_string_in_alphabitical_order

1 while s/(.)(.)(??{$1 le $2 && '(*FAIL)'})/$2$1/g;

return $_;

{{out}}

<pre>

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

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

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

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

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

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>" ?Iaaaaaaaabbcceeefghhhiiiiiijkllllllmnoopppsssssttt"</pre>

=={{header|Raku}}==

===Semi-realistic version===

constant @lexographic_order = sort *.fc, map &chr, 1..255;

Now is the time for all good men to come to the aid of their country.

END

{{out}}

<pre>

Sorted output is wrapped in double guillemots to make it easier to see where it starts and ends.

my $chars = $string.chars;

loop {

say "\nExtended test string:\n" ~ my $test = (32..126)».chr.pick(*).join;

{{out}}

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

/*──────────────────────────────────────────────────────────────────────────────────────*/

make@: parse arg z; #= length(z); do j=1 for #; @.j= substr(z, j, 1); end; return

{{out|output|text=&nbsp; when using the default input:}}

<pre>

=={{header|Ring}}==

see "working..." + nl

see "Sort the letters of string in alphabitical order:" + nl

see "Output: " + str + nl

see "done..." + nl

{{out}}

<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

sub bubble(arr)

n = UBound(arr)

s1=join(a,"")

wscript.echo s1

{{out}}

<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

System.print(["Unsorted->" + str[0], "Sorted ->" + bubbleSort.call(str[0], str[1])].join("\n"))

System.print()

{{out}}

=={{header|XPL0}}==

func StrLen(Str); \Return number of characters in an ASCIIZ string

Text(0, Sort("Pack my box with five dozen liquor jugs."));

CrLf(0);

{{out}}

=={{header|Yabasic}}==

// by Galileo, 04/2022

print text$

{{out}}

<pre>Sort the letters of string in alphabitical order.