Sort numbers lexicographically: Difference between revisions

{{trans|Python}}

{{out}}

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

INT i

Test(a,COUNT_A)

Test(b,COUNT_B)

{{out}}

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

=={{header|Ada}}==

USE Ada.Text_IO;

PROCEDURE Main IS

Show (21);

END Main;

{{out}}

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

oneToNLexicographically(123)

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.

sortLexicographically(someIntegers)

return someIntegers

=={{header|Arturo}}==

{{out}}

=={{header|AutoHotkey}}==

Arr := [], list := ""

loop % n

Arr.Push(v)

return Arr

x := n2lexicog(n)

for k, v in x

output .= v ", "

MsgBox % "[" Trim(output, ", ") "]" ; show output

{{out}}

<pre>[1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]</pre>

=={{header|AWK}}==

===Robust with checks===

# syntax: GAWK -f SORT_NUMBERS_LEXICOGRAPHICALLY.AWK

#

return(str)

}

{{out}}

<pre>

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

for (k in a)

printf "%d ", a[k]

{{out}}

<pre>

=={{header|BaCon}}==

Create a delimited string with numbers and use SORT$.

FOR x = 1 TO n

result$ = APPEND$(result$, 0, STR$(x))

NEXT

{{out}}

<pre>1 10 11 12 13 2 3 4 5 6 7 8 9</pre>

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

PRINT "[" LEFT$(FNLexOrder(0)) "]"

END

IF i% > 0 s$+=STR$i% + "," + FNLexOrder(i% * 10)

NEXT

{{out}}

<pre>[1,10,11,12,13,2,3,4,5,6,7,8,9]</pre>

=={{header|C}}==

#include <stdio.h>

#include <stdlib.h>

}

return 0;

{{out}}

=={{header|C sharp}}==

{{works with|C sharp|7}}

using static System.Linq.Enumerable;

public static IEnumerable<int> LexOrder(int n) => (n < 1 ? Range(n, 2 - n) : Range(1, n)).OrderBy(i => i.ToString());

{{out}}

<pre>

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

#include <iostream>

#include <numeric>

}

return 0;

{{out}}

=={{header|Clojure}}==

{{out}}

<pre>(1 10 11 12 13 2 3 4 5 6 7 8 9)</pre>

=={{header|COBOL}}==

{{works with|GnuCOBOL}}

program-id. LexicographicalNumbers.

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)

{{out}}

=={{header|Factor}}==

sorting ;

IN: rosetta-code.lexicographical-numbers

[ string>number ] map ;

{{out}}

<pre>

=={{header|FreeBASIC}}==

if str(n)<=str(m) then return true else return false

end function

if i<n-1 then print ", ";

next i

{{out}}<pre>

? 13

=={{header|Go}}==

import (

fmt.Printf("%3d: %v\n", n, lexOrder(n))

}

{{out}}

=={{header|Haskell}}==

task :: (Ord b, Show b) => [b] -> [b]

task = map snd . sort . map (\i -> (show i, i))

Which we could also write, in a point-free style as:

task

task = map snd . sort . map (show >>= (,))

and the simplest approach might be ''sortOn show'' (which only evaluates ''show'' once for each item).

main :: IO ()

{{out}}

{{works with|Isabelle|2020}}

imports

Main

value ‹sort (map ascii_of (upt 1 13))›

{{out}}

=={{header|J}}==

{{out}}

<br>

Requires Java 8 or later.

import java.util.stream.*;

}

}

{{out}}

=={{header|Ksh}}==

#!/bin/ksh

_fillarray arr ${N}

{{out}}<pre>

1 10 11 12 13 2 3 4 5 6 7 8 9</pre>

{{works with|jq}}

'''Works with gojq, the Go implementation of jq'''

# Example

# jq's index origin is 0, so ...

{{out}}

<pre>

=={{header|Julia}}==

for i in [0, 5, 13, 21, -32]

println(lexorderedsequence(i))

end

<pre>

[0, 1]

=={{header|Kotlin}}==

fun lexOrder(n: Int): List<Int> {

println("${"%3d".format(n)}: ${lexOrder(n)}")

}

{{output}}

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

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

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

local numList = lexNums(13)

{{out}}

<pre>1 10 11 12 13 2 3 4 5 6 7 8 9</pre>

=={{header|M2000 Interpreter}}==

Module Checkit {

Function lexicographical(N) {

}

Checkit

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

{{out}}

<pre>{1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9}</pre>

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

EndFor

TextWindow.WriteLine(nn+":"+Text.GetSubTextToEnd(x,2))

{{out}}

5:1,2,3,4,5

- The condensed version shows that there are no reserved keywords

SortLexographically(n)

new array,i,j

for set j=$order(array(j)) quit:j="" write j

quit

This could also be written:

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

;Usage

{{out}}

=={{header|Nim}}==

for n in [0, 5, 13, 21, -22]:

let s = if n > 1: toSeq(1..n) else: toSeq(countdown(1, n))

{{out}}

=={{header|Perl}}==

{{out}}

<pre> 13: [1,10,11,12,13,2,3,4,5,6,7,8,9]

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

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

=={{header|PicoLisp}}==

(by

format

sort

{{out}}

<pre>

=={{header|Prolog}}==

{{works with|SWI Prolog}}

number_strings(Numbers, Strings),

sort(Strings, Sorted_strings),

test(13),

test(21),

{{out}}

=={{header|PureBasic}}==

{{trans|Go}}

Procedure lexOrder(n, Array ints(1))

Data.i 0, 5, 13, 21, -22

EndDataSection

{{out}}

=={{header|Python}}==

{{out}}

<pre>[1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]

=={{header|Quackery}}==

[ i^ 1+ number$

nested join ]

[ $->n drop join ] ] is task ( n --> [ )

{{out}}

=={{header|Racket}}==

(define (lex-sort n) (sort (if (< 0 n) (range 1 (add1 n)) (range n 2))

(show 13)

(show 21)

{{out}}

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

($n < 1 ?? ($n, * + $step …^ * > 1)

!! ($n, * - $step …^ * < 1)).sort: ~*

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

This REXX version allows the starting and ending numbers to be specified via the command line (CL),

<br>as well as the increment. &nbsp; 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.*/

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

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

<pre>

=={{header|Ring}}==

# Project : Lexicographical numbers

svect = left(svect, len(svect) - 1)

see svect + "]" + nl

Output:

<pre>

=={{header|Ruby}}==

p (1..n).sort_by(&:to_s)

{{out}}

<pre>[1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]

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

println!("{}: {:?}", n, lex_sorted_vector(*n));

}

{{out}}

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

for (n <- ints) println(f"$n%3d: ${lexOrder(n).mkString("[",", ", "]")}%s")

=={{header|Sidef}}==

[range(1, n, n.sgn)...].sort_by { Str(_) }

}

[13, 21, -22].each {|n|

printf("%4s: %s\n", n, lex_order(n))

{{out}}

<pre>

=={{header|Swift}}==

return stride(from: 1, through: n, by: n.signum()).map({ String($0) }).sorted().compactMap(Int.init)

}

print("13: \(lex(n: 13))")

print("21: \(lex(n: 21))")

{{out}}

=={{header|Tcl}}==

set res {}

set end [+ $start [* $step $num]]

}

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

Public Sub main()

Call sortlexicographically(13)

{{out}}

<pre>1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9, </pre>

=={{header|Wren}}==

{{libheader|Wren-sort}}

var a = (1..13).map { |i| "%(i)" }.toList

Sort.quick(a)

{{out}}

=={{header|zkl}}==

{{out}}

<pre>