Sort numbers lexicographically: Difference between revisions
m
syntax highlighting fixup automation
Drkameleon (talk | contribs) |
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
||
Line 18:
{{trans|Python}}
<
print(sorted(Array(1..n), key' i -> String(i)))</
{{out}}
Line 27:
=={{header|Action!}}==
<
INT i
Line 86:
Test(a,COUNT_A)
Test(b,COUNT_B)
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sort_numbers_lexicographically.png Screenshot from Atari 8-bit computer]
Line 102:
=={{header|Ada}}==
<
USE Ada.Text_IO;
PROCEDURE Main IS
Line 121:
Show (21);
END Main;
</syntaxhighlight>
{{out}}
Line 143:
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 167:
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.
<
on sortLexicographically(integerList) -- Sorts integerList in place.
Line 188:
sortLexicographically(someIntegers)
return someIntegers
--> {-1, -10, -2, -3, -4, -5, -6, 0, 1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9}</
=={{header|Arturo}}==
<
print sort map arr => [to :string &]</
{{out}}
Line 200:
=={{header|AutoHotkey}}==
<
Arr := [], list := ""
loop % n
Line 208:
Arr.Push(v)
return Arr
}</
Examples:<
x := n2lexicog(n)
for k, v in x
output .= v ", "
MsgBox % "[" Trim(output, ", ") "]" ; show output
return</
{{out}}
<pre>[1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]</pre>
Line 220:
=={{header|AWK}}==
===Robust with checks===
<syntaxhighlight lang="awk">
# syntax: GAWK -f SORT_NUMBERS_LEXICOGRAPHICALLY.AWK
#
Line 265:
return(str)
}
</syntaxhighlight>
{{out}}
<pre>
Line 279:
===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 286:
for (k in a)
printf "%d ", a[k]
}</
{{out}}
<pre>
Line 293:
=={{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$)</
{{out}}
<pre>1 10 11 12 13 2 3 4 5 6 7 8 9</pre>
Line 303:
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<
PRINT "[" LEFT$(FNLexOrder(0)) "]"
END
Line 312:
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|C}}==
<
#include <stdio.h>
#include <stdlib.h>
Line 367:
}
return 0;
}</
{{out}}
Line 382:
=={{header|C sharp}}==
{{works with|C sharp|7}}
<
using static System.Linq.Enumerable;
Line 392:
public static IEnumerable<int> LexOrder(int n) => (n < 1 ? Range(n, 2 - n) : Range(1, n)).OrderBy(i => i.ToString());
}</
{{out}}
<pre>
Line 403:
=={{header|C++}}==
<
#include <iostream>
#include <numeric>
Line 443:
}
return 0;
}</
{{out}}
Line 455:
=={{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 462:
=={{header|COBOL}}==
{{works with|GnuCOBOL}}
<
program-id. LexicographicalNumbers.
Line 497:
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}}
Line 512:
=={{header|Factor}}==
<
sorting ;
IN: rosetta-code.lexicographical-numbers
Line 520:
[ string>number ] map ;
{ 13 21 -22 } [ dup lex-order "%3d: %[%d, %]\n" printf ] each</
{{out}}
<pre>
Line 537:
=={{header|FreeBASIC}}==
<
if str(n)<=str(m) then return true else return false
end function
Line 577:
if i<n-1 then print ", ";
next i
print "]"</
{{out}}<pre>
? 13
Line 584:
=={{header|Go}}==
<
import (
Line 614:
fmt.Printf("%3d: %v\n", n, lexOrder(n))
}
}</
{{out}}
Line 628:
=={{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 643:
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 658:
{{works with|Isabelle|2020}}
<
imports
Main
Line 680:
value ‹sort (map ascii_of (upt 1 13))›
end</
{{out}}
Line 688:
=={{header|J}}==
<
task 13</
{{out}}
Line 698:
<br>
Requires Java 8 or later.
<
import java.util.stream.*;
Line 723:
}
}
}</
{{out}}
Line 737:
=={{header|Ksh}}==
<
#!/bin/ksh
Line 773:
_fillarray arr ${N}
print -- ${arr[*]}</
{{out}}<pre>
1 10 11 12 13 2 3 4 5 6 7 8 9</pre>
Line 780:
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
<
# Example
# jq's index origin is 0, so ...
sort_range(1;14)</
{{out}}
<pre>
Line 791:
=={{header|Julia}}==
<
for i in [0, 5, 13, 21, -32]
println(lexorderedsequence(i))
end
</
<pre>
[0, 1]
Line 806:
=={{header|Kotlin}}==
<
fun lexOrder(n: Int): List<Int> {
Line 823:
println("${"%3d".format(n)}: ${lexOrder(n)}")
}
}</
{{output}}
Line 837:
=={{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 845:
{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 859:
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 917:
}
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 926:
=={{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 959:
EndFor
TextWindow.WriteLine(nn+":"+Text.GetSubTextToEnd(x,2))
EndFor </
{{out}}
5:1,2,3,4,5
Line 975:
- The condensed version shows that there are no reserved keywords
<syntaxhighlight lang="mumps">
SortLexographically(n)
new array,i,j
Line 981:
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 1,001:
=={{header|Nim}}==
<
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)</
{{out}}
Line 1,015:
=={{header|Perl}}==
<
{{out}}
<pre> 13: [1,10,11,12,13,2,3,4,5,6,7,8,9]
Line 1,023:
=={{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.
<!--<
<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>
Line 1,035:
<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>
<!--</
{{out}}
<pre>
Line 1,047:
=={{header|PicoLisp}}==
<
(by
format
sort
(range 1 13) ) )</
{{out}}
<pre>
Line 1,059:
=={{header|Prolog}}==
{{works with|SWI Prolog}}
<
number_strings(Numbers, Strings),
sort(Strings, Sorted_strings),
Line 1,093:
test(13),
test(21),
test(-22).</
{{out}}
Line 1,106:
=={{header|PureBasic}}==
{{trans|Go}}
<
Procedure lexOrder(n, Array ints(1))
Line 1,149:
Data.i 0, 5, 13, 21, -22
EndDataSection
EndIf</
{{out}}
Line 1,163:
=={{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]
Line 1,171:
=={{header|Quackery}}==
<
[ i^ 1+ number$
nested join ]
Line 1,179:
[ $->n drop join ] ] is task ( n --> [ )
13 task echo</
{{out}}
Line 1,188:
=={{header|Racket}}==
<
(define (lex-sort n) (sort (if (< 0 n) (range 1 (add1 n)) (range n 2))
Line 1,200:
(show 13)
(show 21)
(show -22)</
{{out}}
Line 1,216:
{{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 1,225:
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 1,237:
This REXX version allows the starting and ending numbers to be specified via the command line (CL),
<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,260:
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,283:
=={{header|Ring}}==
<
# Project : Lexicographical numbers
Line 1,303:
svect = left(svect, len(svect) - 1)
see svect + "]" + nl
</syntaxhighlight>
Output:
<pre>
Line 1,310:
=={{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,318:
=={{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,329:
println!("{}: {:?}", n, lex_sorted_vector(*n));
}
}</
{{out}}
Line 1,342:
=={{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,349:
for (n <- ints) println(f"$n%3d: ${lexOrder(n).mkString("[",", ", "]")}%s")
}</
=={{header|Sidef}}==
<
[range(1, n, n.sgn)...].sort_by { Str(_) }
}
Line 1,358:
[13, 21, -22].each {|n|
printf("%4s: %s\n", n, lex_order(n))
}</
{{out}}
<pre>
Line 1,369:
=={{header|Swift}}==
<
return stride(from: 1, through: n, by: n.signum()).map({ String($0) }).sorted().compactMap(Int.init)
}
Line 1,375:
print("13: \(lex(n: 13))")
print("21: \(lex(n: 21))")
print("-22: \(lex(n: -22))")</
{{out}}
Line 1,384:
=={{header|Tcl}}==
<
set res {}
set end [+ $start [* $step $num]]
Line 1,393:
}
puts [lsort [iota 13 1]]</
{{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,413:
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,419:
=={{header|Wren}}==
{{libheader|Wren-sort}}
<
var a = (1..13).map { |i| "%(i)" }.toList
Sort.quick(a)
System.print(a)</
{{out}}
Line 1,431:
=={{header|zkl}}==
<
<
{{out}}
<pre>
|