Sort numbers lexicographically: Difference between revisions
Added Easylang
(Added Easylang) |
|||
(32 intermediate revisions by 23 users not shown) | |||
Line 1:
{{task|Sorting Algorithms}}
[[Category:Sorting]]
{{Sorting Algorithm}}
;Task:
Line 14:
<br>return: '''[1,10,11,12,13,2,3,4,5,6,7,8,9].'''
<br><br>
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">V n = 13
print(sorted(Array(1..n), key' i -> String(i)))</syntaxhighlight>
{{out}}
<pre>
[1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]
</pre>
=={{header|Action!}}==
<syntaxhighlight lang="action!">PROC PrintArray(INT ARRAY a INT size)
INT i
Put('[)
FOR i=0 TO size-1
DO
IF i>0 THEN Put(' ) FI
PrintI(a(i))
OD
Put(']) PutE()
RETURN
INT FUNC Compare(INT a1,a2)
CHAR ARRAY s1(10),s2(10)
INT res
StrI(a1,s1) StrI(a2,s2)
res=SCompare(s1,s2)
RETURN (res)
PROC InsertionSort(INT ARRAY a INT size)
INT i,j,value
FOR i=1 TO size-1
DO
value=a(i)
j=i-1
WHILE j>=0 AND Compare(a(j),value)>0
DO
a(j+1)=a(j)
j==-1
OD
a(j+1)=value
OD
RETURN
PROC Test(INT ARRAY a INT size)
PrintE("Array before sort:")
PrintArray(a,size)
InsertionSort(a,size)
PrintE("Array after sort:")
PrintArray(a,size)
PutE()
RETURN
PROC Main()
DEFINE COUNT_A="13"
DEFINE COUNT_B="50"
INT ARRAY a(COUNT_A),b(COUNT_B)
BYTE i
FOR i=1 TO COUNT_A
DO a(i-1)=i OD
FOR i=1 TO COUNT_B
DO b(i-1)=i OD
Test(a,COUNT_A)
Test(b,COUNT_B)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sort_numbers_lexicographically.png Screenshot from Atari 8-bit computer]
<pre>
Array before sort:
[1 2 3 4 5 6 7 8 9 10 11 12 13]
Array after sort:
[1 10 11 12 13 2 3 4 5 6 7 8 9]
Array before sort:
[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50]
Array after sort:
[1 10 11 12 13 14 15 16 17 18 19 2 20 21 22 23 24 25 26 27 28 29 3 30 31 32 33 34 35 36 37 38 39 4 40 41 42 43 44 45 46 47 48 49 5 50 6 7 8 9]
</pre>
=={{header|Ada}}==
<
USE Ada.Text_IO;
PROCEDURE Main IS
Line 35 ⟶ 121:
Show (21);
END Main;
</syntaxhighlight>
{{out}}
Line 43 ⟶ 129:
</pre>
{{out}}
=={{header|ALGOL 68}}==
Uses code from the [[Sorting algorithms/Insertion sort]] tasl - included here for convenience.<br>
<syntaxhighlight lang="algol68">
BEGIN # sort numbers lexicographically #
# code from the Sorting algorithms/Insertion sort task #
MODE DATA = STRING;
PROC in place insertion sort = (REF[]DATA item)VOID:
BEGIN
INT first := LWB item;
INT last := UPB item;
INT j;
DATA value;
FOR i FROM first + 1 TO last DO
value := item[i];
j := i - 1;
WHILE ( j >= LWB item AND j <= UPB item | item[j]>value | FALSE ) DO
item[j + 1] := item[j];
j -:= 1
OD;
item[j + 1] := value
OD
END # in place insertion sort #;
# end code from the Sorting algorithms/Insertion sort task #
# returns s converted to an integer, NB: no error checking #
OP TOINT = ( STRING s )INT:
BEGIN
INT result := 0;
FOR i FROM LWB s TO UPB s DO
result *:= 10 +:= ( ABS s[ i ] - ABS "0" )
OD;
result
END # TOINT # ;
# returns a array of integers 1..n sorted lexicographically #
PROC lexicographic order = ( INT n )[]INT:
BEGIN
[ 1 : n ]STRING v; FOR i TO n DO v[ i ] := whole( i, 0 ) OD;
in place insertion sort( v );
[ 1 : n ]INT result;
FOR i TO n DO result[ i ] := TOINT v[ i ] OD;
result
END # lexicographic order # ;
# prints the elements of a #
PROC show int array = ( []INT a )VOID:
BEGIN
print( ( "[" ) );
FOR i FROM LWB a TO UPB a DO print( ( " ", whole( a[ i ], 0 ) ) ) OD;
print( ( " ]", newline ) )
END # show int array # ;
# test cases #
show int array( lexicographic order( 13 ) );
show int array( lexicographic order( 21 ) )
END
</syntaxhighlight>
{{out}}
<pre>
[ 1 10 11 12 13 2 3 4 5 6 7 8 9 ]
[ 1 10 11 12 13 14 15 16 17 18 19 2 20 21 3 4 5 6 7 8 9 ]
</pre>
=={{header|APL}}==
Line 57 ⟶ 210:
For fast execution of the task as specified, this take on the [https://www.rosettacode.org/wiki/Sort_numbers_lexicographically#BBC_BASIC BBC BASIC] method below generates the integers in the required order:
<
script o
property output : {}
Line 81 ⟶ 234:
oneToNLexicographically(123)
--> {1, 10, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 11, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 12, 120, 121, 122, 123, 13, 14, 15, 16, 17, 18, 19, 2, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 3, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 4, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 5, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 6, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 7, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 8, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 9, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99}</
In the unlikely event of it ever being necessary to sort a ''given'' list of integers in this fashion, one possibility is to create another list containing text versions of the integers and to sort this while rearranging the integer versions in parallel.
<syntaxhighlight lang="applescript">use AppleScript version "2.3.1" -- Mac OS X 10.9 (Mavericks) or later.
use sorter : script ¬
"Custom Iterative Ternary Merge Sort" -- <www.macscripter.net/t/timsort-and-nigsort/71383/3>
on join(lst, delim)
set astid to AppleScript's text item delimiters
set AppleScript's text item delimiters to
set
set AppleScript's text item delimiters to astid
return txt
end join
on sortLexicographically(integerList)
set textList to paragraphs of join(integerList, linefeed)
-- Sort textList, echoing the moves in integerList.
considering hyphens but ignoring numeric strings
tell sorter to sort(textList, 1, -1, {slave:{integerList}})
Line 99 ⟶ 259:
-- Test code:
local someIntegers
set someIntegers to {1, 2, -6, 3, 4, 5, -10, 6, 7, 8, 9, 10, 11, 12, 13, -2, -5, -1, -4, -3, 0}
sortLexicographically(someIntegers)
return someIntegers</syntaxhighlight>
{{output}}
<syntaxhighlight lang="applescript">{-1, -10, -2, -3, -4, -5, -6, 0, 1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9}</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">arr: 1..13
print sort map arr => [to :string &]</syntaxhighlight>
{{out}}
<pre>1 10 11 12 13 2 3 4 5 6 7 8 9</pre>
=={{header|ATS}}==
The program converts the integers to strings, sorts the strings, then converts the strings back to integers.
The method can be used to sort any sequence of non-negative integers.
(Radix sorting the numbers in their original form is another possible approach.)
<syntaxhighlight lang="ats">
(* The Rosetta Code lexicographic sort task. *)
#include "share/atspre_staload.hats"
staload UN = "prelude/SATS/unsafe.sats"
#define NIL list_nil ()
#define :: list_cons
fn
uint_to_digit (n : uint)
: char =
int2char0 (g0u2i n + char2int0 '0')
fn
int_to_string {n : nat}
(n : int n)
: string =
if iseqz n then
"0"
else
let
fun
loop {i : nat | i <= 20}
.<i>.
(buf : &array (char, 21),
i : int i,
n : uint)
: [j : nat | j <= 20]
int j =
if (i = 0) + (iseqz n) then
i
else
let
val i1 = pred i
in
buf[i1] := uint_to_digit (n mod 10u);
loop (buf, i1, n / 10u)
end
var buf = @[char][21] ('\0')
val j = loop (buf, 20, g0i2u n)
val p = ptr_add<char> (addr@ buf, j)
in
strptr2string (string0_copy ($UN.cast{string} p))
end
fn
iota1 {n : pos}
(n : int n)
: list ([i : pos | i <= n] int i, n) =
let
typedef t = [i : pos | i <= n] int i
fun
loop {i : nat | i <= n}
.<i>.
(i : int i,
accum : list (t, n - i))
: list (t, n) =
if i = 0 then
accum
else
loop (pred i, i :: accum)
in
loop (n, NIL)
end
fn
reverse_map_numbers_to_strings
{n : int}
(nums : list ([i : nat] int i, n))
: list (string, n) =
let
typedef t = [i : nat] int i
fun
loop {i : nat | i <= n}
.<n - i>.
(nums : list (t, n - i),
accum : list (string, i))
: list (string, n) =
case+ nums of
| NIL => accum
| head :: tail =>
loop {i + 1} (tail, int_to_string head :: accum)
prval () = lemma_list_param nums
in
loop {0} (nums, NIL)
end
fn
reverse_map_strings_to_numbers
{n : int}
(strings : list (string, n))
: list (int, n) =
let
macdef string_to_int (s) =
$extfcall (int, "atoi", ,(s))
fun
loop {i : nat | i <= n}
.<n - i>.
(strings : list (string, n - i),
accum : list (int, i))
: list (int, n) =
case+ strings of
| NIL => accum
| head :: tail =>
loop {i + 1} (tail, string_to_int head :: accum)
prval () = lemma_list_param strings
in
loop {0} (strings, NIL)
end
fn
lexicographic_iota1
{n : pos}
(n : int n)
: list (int, n) =
let
val numstrings =
reverse_map_numbers_to_strings (iota1 n)
(* One could use a MSB-first radix sort here, but I will use what
is readily available. *)
implement
list_mergesort$cmp<string> (x, y) =
~compare (x, y)
in
reverse_map_strings_to_numbers
(list_vt2t (list_mergesort<string> numstrings))
end
implement
main0 () =
begin
println! (lexicographic_iota1 13);
println! (lexicographic_iota1 100)
end
</syntaxhighlight>
{{out}}
<pre>$ patscc -DATS_MEMALLOC_GCBDW lexicographic_sort.dats -lgc && ./a.out
1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9
1, 10, 100, 11, 12, 13, 14, 15, 16, 17, 18, 19, 2, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 3, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 4, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 5, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 6, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 7, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 8, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 9, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99</pre>
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">n2lexicog(n){
Arr := [], list := ""
loop % n
list .= A_Index "`n"
Sort, list
for k, v in StrSplit(Trim(list, "`n"), "`n")
Arr.Push(v)
return Arr
}</syntaxhighlight>
Examples:<syntaxhighlight lang="autohotkey">n := 13
x := n2lexicog(n)
for k, v in x
output .= v ", "
MsgBox % "[" Trim(output, ", ") "]" ; show output
return</syntaxhighlight>
{{out}}
<pre>[1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]</pre>
=={{header|AWK}}==
===Robust with checks===
<syntaxhighlight lang="awk">
# syntax: GAWK -f SORT_NUMBERS_LEXICOGRAPHICALLY.AWK
#
Line 151 ⟶ 498:
return(str)
}
</syntaxhighlight>
{{out}}
<pre>
Line 165 ⟶ 512:
===Alternative, using GAWK's builtin sort===
This version explicitly casts integers as strings during list generation and uses the builtin sort available in GAWK on element values.
<
n=13
for (i=1; i<=n; i++)
Line 172 ⟶ 519:
for (k in a)
printf "%d ", a[k]
}</
{{out}}
<pre>
Line 179 ⟶ 526:
=={{header|BaCon}}==
Create a delimited string with numbers and use SORT$.
<
FOR x = 1 TO n
result$ = APPEND$(result$, 0, STR$(x))
NEXT
PRINT SORT$(result$)</syntaxhighlight>
{{out}}
<pre>1 10 11 12 13 2 3 4 5 6 7 8 9</pre>
Line 190 ⟶ 536:
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<
PRINT "[" LEFT$(FNLexOrder(0)) "]"
END
Line 199 ⟶ 545:
IF i% > 0 s$+=STR$i% + "," + FNLexOrder(i% * 10)
NEXT
=s$</
{{out}}
<pre>[1,10,11,12,13,2,3,4,5,6,7,8,9]</pre>
=={{header|BQN}}==
<syntaxhighlight lang="bqn">Task ← ⍋∘(•Fmt¨)⊸⊏1+↕
Task 13</syntaxhighlight>
{{out}}
<pre>⟨ 1 10 11 12 13 2 3 4 5 6 7 8 9 ⟩</pre>
=={{header|C}}==
<
#include <stdio.h>
#include <stdlib.h>
Line 254 ⟶ 607:
}
return 0;
}</
{{out}}
<pre>
Line 269 ⟶ 621:
=={{header|C sharp}}==
{{works with|C sharp|7}}
<
using static System.Linq.Enumerable;
Line 279 ⟶ 631:
public static IEnumerable<int> LexOrder(int n) => (n < 1 ? Range(n, 2 - n) : Range(1, n)).OrderBy(i => i.ToString());
}</
{{out}}
<pre>
Line 290 ⟶ 642:
=={{header|C++}}==
<
#include <iostream>
#include <numeric>
Line 330 ⟶ 682:
}
return 0;
}</
{{out}}
Line 342 ⟶ 694:
=={{header|Clojure}}==
<
(sort-by str (range 1 (inc n)))</
{{out}}
<pre>(1 10 11 12 13 2 3 4 5 6 7 8 9)</pre>
Line 349 ⟶ 701:
=={{header|COBOL}}==
{{works with|GnuCOBOL}}
<
program-id. LexicographicalNumbers.
Line 384 ⟶ 736:
display "]"
stop run
.</
{{out}}
<pre>[1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 2, 20, 21, 3, 4, 5, 6, 7, 8, 9]</pre>
=={{header|Common Lisp}}==
<
(defun lexicographic-sort (n)
(sort (alexandria:iota n :start 1) #'string<= :key #'write-to-string))
(lexicographic-sort 13)
</syntaxhighlight>
{{out}}
<pre>(1 10 11 12 13 2 3 4 5 6 7 8 9)</pre>
=={{header|EasyLang}}==
<syntaxhighlight>
func[] numlexsort n .
for i to n
d[] &= i
.
for i = 1 to len d[] - 1
for j = i + 1 to len d[]
if strcmp d[j] d[i] < 0
swap d[j] d[i]
.
.
.
return d[]
.
print numlexsort 13
</syntaxhighlight>
{{out}}
<pre>
[ 1 10 11 12 13 2 3 4 5 6 7 8 9 ]
</pre>
=={{header|Factor}}==
<
sorting ;
IN: rosetta-code.lexicographical-numbers
Line 407 ⟶ 781:
[ string>number ] map ;
{ 13 21 -22 } [ dup lex-order "%3d: %[%d, %]\n" printf ] each</
{{out}}
<pre>
Line 413 ⟶ 787:
21: { 1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 2, 20, 21, 3, 4, 5, 6, 7, 8, 9 }
-22: { -1, -10, -11, -12, -13, -14, -15, -16, -17, -18, -19, -2, -20, -21, -22, -3, -4, -5, -6, -7, -8, -9, 0, 1 }
</pre>
=={{header|Fōrmulæ}}==
{{FormulaeEntry|page=https://formulae.org/?script=examples/Sort_numbers_lexicographically}}
'''Solution'''
[[File:Fōrmulæ - Sort numbers lexicographically 01.png]]
'''Test case'''
[[File:Fōrmulæ - Sort numbers lexicographically 02.png]]
[[File:Fōrmulæ - Sort numbers lexicographically 03.png]]
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">function leq( n as integer, m as integer ) as boolean
if str(n)<=str(m) then return true else return false
end function
sub shellsort(s() as integer)
dim as integer n = ubound(s)
dim as integer i, inc = n
dim as boolean done
do
inc\=2.2
if inc = 0 then inc = 1
do
done = false
for i = 0 to n - inc
if leq(s(i+inc), s(i)) then
swap s(i), s(i + inc)
done = true
end if
next
loop until done = 0
loop until inc = 1
end sub
dim as integer n, i
input n
dim as integer s(0 to n-1)
for i = 0 to n-1
s(i) = i+1
next i
shellsort(s())
print "[";
for i = 0 to n-1
print s(i);
if i<n-1 then print ", ";
next i
print "]"</syntaxhighlight>
{{out}}<pre>
? 13
[ 1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]
</pre>
=={{header|Go}}==
<
import (
Line 446 ⟶ 881:
fmt.Printf("%3d: %v\n", n, lexOrder(n))
}
}</
{{out}}
Line 460 ⟶ 895:
=={{header|Haskell}}==
<
task :: (Ord b, Show b) => [b] -> [b]
task = map snd . sort . map (\i -> (show i, i))
main = print $ task [1 .. 13]</
Which we could also write, in a point-free style as:
<
task
Line 475 ⟶ 910:
task = map snd . sort . map (show >>= (,))
main = print $ task [1 .. 13]</
and the simplest approach might be ''sortOn show'' (which only evaluates ''show'' once for each item).
<
main :: IO ()
main = print $ sortOn show [1 .. 13]</
{{out}}
Line 490 ⟶ 925:
{{works with|Isabelle|2020}}
<
imports
Main
Line 512 ⟶ 947:
value ‹sort (map ascii_of (upt 1 13))›
end</
{{out}}
Line 520 ⟶ 955:
=={{header|J}}==
<
task 13</
{{out}}
Line 530 ⟶ 965:
<br>
Requires Java 8 or later.
<
import java.util.stream.*;
Line 555 ⟶ 990:
}
}
}</
{{out}}
Line 566 ⟶ 1,001:
21: [1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 2, 20, 21, 3, 4, 5, 6, 7, 8, 9]
-22: [-1, -10, -11, -12, -13, -14, -15, -16, -17, -18, -19, -2, -20, -21, -22, -3, -4, -5, -6, -7, -8, -9, 0, 1]
</pre>
=={{header|K}}==
<syntaxhighlight lang="k">task: 1+<$1+!:
task 13</syntaxhighlight>
{{out}}
<pre>1 10 11 12 13 2 3 4 5 6 7 8 9</pre>
=={{header|Ksh}}==
<syntaxhighlight lang="ksh">
#!/bin/ksh
# Sort numbers lexicographically
# # Variables:
#
integer N=${1:-13}
# # Functions:
#
# # Function _fillarray(arr, N) - fill assoc. array 1 -> N
#
function _fillarray {
typeset _arr ; nameref _arr="$1"
typeset _N ; integer _N=$2
typeset _i _st _en ; integer _i _st _en
(( ! _N )) && _arr=0 && return
(( _N<0 )) && _st=${_N} && _en=1
(( _N>0 )) && _st=1 && _en=${_N}
for ((_i=_st; _i<=_en; _i++)); do
_arr[${_i}]=${_i}
done
}
######
# main #
######
set -a -s -A arr
typeset -A arr
_fillarray arr ${N}
print -- ${arr[*]}</syntaxhighlight>
{{out}}
<pre>1 10 11 12 13 2 3 4 5 6 7 8 9</pre>
=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
<syntaxhighlight lang="jq">def sort_range($a;$b): [range($a;$b)] | sort_by(tostring);
# Example
# jq's index origin is 0, so ...
sort_range(1;14)</syntaxhighlight>
{{out}}
<pre>
[1,10,11,12,13,2,3,4,5,6,7,8,9]
</pre>
=={{header|Julia}}==
<
for i in [0, 5, 13, 21, -32]
println(lexorderedsequence(i))
end
</
<pre>
[0, 1]
Line 584 ⟶ 1,080:
=={{header|Kotlin}}==
<
fun lexOrder(n: Int): List<Int> {
Line 601 ⟶ 1,097:
println("${"%3d".format(n)}: ${lexOrder(n)}")
}
}</
{{output}}
Line 615 ⟶ 1,111:
=={{header|Lambdatalk}}==
<
1) lexicographically sorting a sequence of numbers
{S.sort before 1 2 3 4 5 6 7 8 9 10 11 12 13}
Line 623 ⟶ 1,119:
{A.sort! before {A.new 1 2 3 4 5 6 7 8 9 10 11 12 13}}
-> [1,10,11,12,13,2,3,4,5,6,7,8,9]
</syntaxhighlight>
=={{header|Lua}}==
Lua's in-built table.sort function will sort a table of strings into lexicographical order by default. This task therefore becomes trivial by converting each number to a string before adding it to the table.
<
local numbers = {}
for i = 1, limit do
Line 637 ⟶ 1,133:
local numList = lexNums(13)
print(table.concat(numList, " "))</
{{out}}
<pre>1 10 11 12 13 2 3 4 5 6 7 8 9</pre>
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
Module Checkit {
Function lexicographical(N) {
Line 695 ⟶ 1,191:
}
Checkit
</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang
{{out}}
<pre>{1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9}</pre>
Line 704 ⟶ 1,200:
=={{header|Microsoft Small Basic}}==
In Small Basic there is no string comparison: “a”>”b” the result is “False”, “b”>”a” the result is also “False”. It doesn’t help at all.
<
xx="000000000000000"
For n=1 To 3
Line 737 ⟶ 1,233:
EndFor
TextWindow.WriteLine(nn+":"+Text.GetSubTextToEnd(x,2))
EndFor </
{{out}}
5:1,2,3,4,5
13:1,10,11,12,13,2,3,4,5,6,7,8,9
21:1,10,11,12,13,14,15,16,17,18,19,2,20,21,3,4,5,6,7,8,9
=={{header|MiniScript}}==
Output from REPL.
{{out}}
<pre>
> n = 13
> rng = range(1, 13)
> rng.join(" ").split(" ").sort
["1", "10", "11", "12", "13", "2", "3", "4", "5", "6", "7", "8", "9"]
</pre>
=={{header|MUMPS}}==
Line 753 ⟶ 1,259:
- The condensed version shows that there are no reserved keywords
<syntaxhighlight lang="mumps">
SortLexographically(n)
new array,i,j
Line 759 ⟶ 1,265:
for set j=$order(array(j)) quit:j="" write j
quit
</syntaxhighlight>
This could also be written:
<syntaxhighlight lang="mumps">
SortLexographically(n) n a,i,j f i=1:1:n s a(i_" ")=""
f s j=$o(a(j)) q:j="" w j
q
</syntaxhighlight>
;Usage
<syntaxhighlight lang
{{out}}
Line 777 ⟶ 1,283:
1 10 11 12 13 2 3 4 5 6 7 8 9
</pre>
=={{header|Nim}}==
<syntaxhighlight lang="nim">import algorithm, sequtils
for n in [0, 5, 13, 21, -22]:
let s = if n > 1: toSeq(1..n) else: toSeq(countdown(1, n))
echo s.sortedByIt($it)</syntaxhighlight>
{{out}}
<pre>@[0, 1]
@[1, 2, 3, 4, 5]
@[1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]
@[1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 2, 20, 21, 3, 4, 5, 6, 7, 8, 9]
@[-1, -10, -11, -12, -13, -14, -15, -16, -17, -18, -19, -2, -20, -21, -22, -3, -4, -5, -6, -7, -8, -9, 0, 1]</pre>
=={{header|Perl}}==
<
{{out}}
<pre> 13: [1,10,11,12,13,2,3,4,5,6,7,8,9]
Line 786 ⟶ 1,306:
=={{header|Phix}}==
Accepts a proper sequence, in preference to guessing what say a lone 13 actually means, and/or wanting start/stop/step that'd probably just get passed on to tagset() anyway.
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">lexicographic_order</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #7060A8;">extract</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">custom_sort</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sprint</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">))))</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">lexicographic_order</span><span style="color: #0000FF;">({</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">})</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">lexicographic_order</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">5</span><span style="color: #0000FF;">))</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">lexicographic_order</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">13</span><span style="color: #0000FF;">))</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">lexicographic_order</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">21</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">))</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">lexicographic_order</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">11</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">21</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">))</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">lexicographic_order</span><span style="color: #0000FF;">({</span><span style="color: #000000;">1.25</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">6</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">9</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">11.3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">13</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">})</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
{0,1}
{1,2,3,4,5}
{1,10,11,12,13,2,3,4,5,6,7,8,9}
{1,11,13,15,17,19,21,3,5,7,9}
{-1,-13,-17,-21,-5,-9,11,3,7}
{-10,-11.3,-3,-6,0,1.25,13,9}
</pre>
=={{header|PicoLisp}}==
<
(by
format
sort
(range 1 13) ) )</
{{out}}
<pre>
Line 833 ⟶ 1,343:
=={{header|Prolog}}==
{{works with|SWI Prolog}}
<
number_strings(Numbers, Strings),
sort(Strings, Sorted_strings),
Line 867 ⟶ 1,377:
test(13),
test(21),
test(-22).</
{{out}}
Line 880 ⟶ 1,390:
=={{header|PureBasic}}==
{{trans|Go}}
<
Procedure lexOrder(n, Array ints(1))
Line 923 ⟶ 1,433:
Data.i 0, 5, 13, 21, -22
EndDataSection
EndIf</
{{out}}
Line 937 ⟶ 1,447:
=={{header|Python}}==
<
print(sorted(range(1,n+1), key=str))</
{{out}}
<pre>[1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]
</pre>
=={{header|Quackery}}==
<syntaxhighlight lang="quackery"> [ [] swap times
[ i^ 1+ number$
nested join ]
sort$
[] swap
witheach
[ $->n drop join ] ] is task ( n --> [ )
13 task echo</syntaxhighlight>
{{out}}
<pre>[ 1 10 11 12 13 2 3 4 5 6 7 8 9 ]</pre>
=={{header|Racket}}==
<
(define (lex-sort n) (sort (if (< 0 n) (range 1 (add1 n)) (range n 2))
Line 957 ⟶ 1,484:
(show 13)
(show 21)
(show -22)</
{{out}}
Line 973 ⟶ 1,500:
{{works with|Rakudo|2018.06}}
It is somewhat odd that the task name is sort '''numbers''' lexicographically but immediately backtracks in the task header to sorting '''integers''' lexicographically. Why only integers? This will sort ANY real numbers lexicographically. For a non-integer, assumes that the given number is a hard boundary and 1 is a "soft" boundary. E.G. The given number is definitely included; 1 is only a threshold, it is included if it matches exactly. (Could be the other way around, this it the way I choose.)
<syntaxhighlight lang="raku"
($n < 1 ?? ($n, * + $step …^ * > 1)
!! ($n, * - $step …^ * < 1)).sort: ~*
Line 982 ⟶ 1,509:
my ($bound, $step) = |$_, 1;
say "Boundary:$bound, Step:$step >> ", lex($bound, $step).join: ', ';
}</
{{Out}}
<pre>Boundary:13, Step:1 >> 1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9
Line 992 ⟶ 1,519:
=={{header|REXX}}==
This REXX version allows the starting and ending
<br>as well as the increment. Negative numbers are supported and need not be integers.
<
parse arg LO HI INC . /*obtain optional arguments from the CL*/
if LO=='' | LO=="," then LO= 1 /*Not specified? Then use the default.*/
Line 1,017 ⟶ 1,544:
do j=1 for m; k= j+1; if @.j>>@.k then parse value @.j @.k 0 with @.k @.j ok
end /*j*/ /* [↑] swap 2 elements, flag as ¬done.*/
end /*m*/; return</
{{out|output|text= when using the default inputs:}}
<pre>
Line 1,040 ⟶ 1,567:
=={{header|Ring}}==
<
# Project : Lexicographical numbers
Line 1,060 ⟶ 1,587:
svect = left(svect, len(svect) - 1)
see svect + "]" + nl
</syntaxhighlight>
Output:
<pre>
Lexicographical numbers = [1,10,11,12,13,2,3,4,5,6,7,8,9]
</pre>
=={{header|RPL}}==
{{works with|HP|48}}
≪ ≪ n →STR ≫ 'n' 1 4 ROLL 1 SEQ
SORT ≪ STR→ ≫ DOLIST
≫ '<span style="color:blue">LEXICON</span>' STO
13 <span style="color:blue">LEXICON</span>
{{out}}
<pre>
1: { 1 10 11 12 13 2 3 4 5 6 7 8 9 }
</pre>
=={{header|Ruby}}==
<
p (1..n).sort_by(&:to_s)
</syntaxhighlight>
{{out}}
<pre>[1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]
Line 1,075 ⟶ 1,614:
=={{header|Rust}}==
<
let (min, max) = if num >= 1 { (1, num) } else { (num, 1) };
let mut str: Vec<String> = (min..=max).map(|i| i.to_string()).collect();
Line 1,086 ⟶ 1,625:
println!("{}: {:?}", n, lex_sorted_vector(*n));
}
}</
{{out}}
Line 1,099 ⟶ 1,638:
=={{header|Scala}}==
{{Out}}Best seen in running your browser either by [https://scalafiddle.io/sf/KpWHYNR/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/BnxJXLjCRvObdOv3VKTtYA Scastie (remote JVM)].
<
def lexOrder(n: Int): Seq[Int] = (if (n < 1) n to 1 else 1 to n).sortBy(_.toString)
Line 1,106 ⟶ 1,645:
for (n <- ints) println(f"$n%3d: ${lexOrder(n).mkString("[",", ", "]")}%s")
}</
=={{header|Sidef}}==
<
[range(1, n, n.sgn)...].sort_by { Str(_) }
}
Line 1,115 ⟶ 1,654:
[13, 21, -22].each {|n|
printf("%4s: %s\n", n, lex_order(n))
}</
{{out}}
<pre>
Line 1,126 ⟶ 1,665:
=={{header|Swift}}==
<
return stride(from: 1, through: n, by: n.signum()).map({ String($0) }).sorted().compactMap(Int.init)
}
Line 1,132 ⟶ 1,671:
print("13: \(lex(n: 13))")
print("21: \(lex(n: 21))")
print("-22: \(lex(n: -22))")</
{{out}}
Line 1,139 ⟶ 1,678:
21: [1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 2, 20, 21, 3, 4, 5, 6, 7, 8, 9]
-22: [-1, -10, -11, -12, -13, -14, -15, -16, -17, -18, -19, -2, -20, -21, -22, -3, -4, -5, -6, -7, -8, -9, 0, 1]</pre>
=={{header|Tcl}}==
<syntaxhighlight lang="tcl">proc iota {num {start 0} {step 1}} {
set res {}
set end [+ $start [* $step $num]]
for {set n $start} {$n != $end} {incr n $step} {
lappend res $n
}
return $res
}
puts [lsort [iota 13 1]]</syntaxhighlight>
{{out}}
<pre>1 10 11 12 13 2 3 4 5 6 7 8 9</pre>
=={{header|VBA}}==
<
Dim arrList As Object
Set arrList = CreateObject("System.Collections.ArrayList")
Line 1,156 ⟶ 1,709:
Public Sub main()
Call sortlexicographically(13)
End Sub</
{{out}}
<pre>1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9, </pre>
Line 1,162 ⟶ 1,715:
=={{header|Wren}}==
{{libheader|Wren-sort}}
<
var a = (1..13).map { |i| "%(i)" }.toList
Sort.quick(a)
System.print(a)</
{{out}}
Line 1,174 ⟶ 1,727:
=={{header|zkl}}==
<
<
{{out}}
<pre>
|