Sort numbers lexicographically

From Rosetta Code
Task
Sort numbers lexicographically
You are encouraged to solve this task according to the task description, using any language you may know.
Task

Given an integer   n,   return   1──►n   (inclusive)   in lexicographical order.


Show all output here on this page.


Example

Given   13,
return:   [1,10,11,12,13,2,3,4,5,6,7,8,9].

11l[edit]

Translation of: Python
V n = 13
print(sorted(Array(1..n), key' i -> String(i)))
Output:
[1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]

Action![edit]

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

Screenshot from Atari 8-bit computer

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]

Ada[edit]

WITH Ada.Containers.Generic_Array_Sort, Ada.Text_IO;
USE  Ada.Text_IO;
PROCEDURE Main IS
   TYPE Natural_Array IS ARRAY (Positive RANGE <>) OF Natural;
   FUNCTION Less (L, R : Natural) RETURN Boolean IS (L'Img < R'Img);
   PROCEDURE Sort_Naturals IS NEW Ada.Containers.Generic_Array_Sort
     (Positive, Natural, Natural_Array, Less);
   PROCEDURE Show (Last : Natural) IS
      A : Natural_Array (1 .. Last);
   BEGIN
      FOR I IN A'Range LOOP A (I) := I; END LOOP;
      Sort_Naturals (A);
      FOR I IN  A'Range LOOP Put (A (I)'Img); END LOOP;
      New_Line;
   END Show;
BEGIN
   Show (13);
   Show (21);
END Main;
Output:
 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
Output:

APL[edit]

Dyalog APL (with origin 0, ⎕IO←0)

     {⍎¨{⍵[⍋⍵]}⍕¨1+⍳⍵} 13
 1  10  11  12  13  2  3  4  5  6  7  8  9
     {⍎¨{⍵[⍋⍵]}⍕¨1+⍳⍵} 21 
 1  10  11  12  13  14  15  16  17  18  19  2  20  21  3  4  5  6  7  8  9

AppleScript[edit]

For fast execution of the task as specified, this take on the BBC BASIC method below generates the integers in the required order:

on oneToNLexicographically(n)
    script o
        property output : {}
        
        on otnl(i)
            set j to i + 9 - i mod 10
            if (j > n) then set j to n
            repeat with i from i to j
                set end of my output to i
                tell i * 10 to if (it  n) then my otnl(it)
            end repeat
        end otnl
    end script
    
    o's otnl(1)
    
    return o's output
end oneToNLexicographically

-- Test code:
oneToNLexicographically(13)
--> {1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9}

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.

use sorter : script "Custom Iterative Ternary Merge Sort" -- <https://macscripter.net/viewtopic.php?pid=194430#p194430>

on sortLexicographically(integerList) -- Sorts integerList in place.
    set astid to AppleScript's text item delimiters
    set AppleScript's text item delimiters to linefeed
    set textList to paragraphs of (integerList as text)
    set AppleScript's text item delimiters to astid
    
    considering hyphens but ignoring numeric strings
        tell sorter to sort(textList, 1, -1, {slave:{integerList}})
    end considering
end sortLexicographically

-- Test code:
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
--> {-1, -10, -2, -3, -4, -5, -6, 0, 1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9}

Arturo[edit]

arr: 1..13
print sort map arr => [to :string &]
Output:
1 10 11 12 13 2 3 4 5 6 7 8 9

AutoHotkey[edit]

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
}
Examples:
n := 13
x := n2lexicog(n)
for k, v in x
    output .= v ", "
MsgBox % "[" Trim(output, ", ") "]"					; show output
return
Output:
[1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]

AWK[edit]

Robust with checks[edit]

# syntax: GAWK -f SORT_NUMBERS_LEXICOGRAPHICALLY.AWK
#
# sorting:
#   PROCINFO["sorted_in"] is used by GAWK
#   SORTTYPE is used by Thompson Automation's TAWK
#
BEGIN {
    prn(0)
    prn(1)
    prn(13)
    prn(9,10)
    prn(-11,+11)
    prn(-21)
    prn("",1)
    prn(+1,-1)
    exit(0)
}
function prn(n1,n2) {
    if (n1 <= 0 && n2 == "") {
      n2 = 1
    }
    if (n2 == "") {
      n2 = n1
      n1 = 1
    }
    printf("%d to %d: %s\n",n1,n2,snl(n1,n2))
}
function snl(start,stop,  arr,i,str) {
    if (start == "") {
      return("error: start=blank")
    }
    if (start > stop) {
      return("error: start>stop")
    }
    for (i=start; i<=stop; i++) {
      arr[i]
    }
    PROCINFO["sorted_in"] = "@ind_str_asc" ; SORTTYPE = 2
    for (i in arr) {
      str = sprintf("%s%s ",str,i)
    }
    sub(/ $/,"",str)
    return(str)
}
Output:
0 to 1: 0 1
1 to 1: 1
1 to 13: 1 10 11 12 13 2 3 4 5 6 7 8 9
9 to 10: 10 9
-11 to 11: -1 -10 -11 -2 -3 -4 -5 -6 -7 -8 -9 0 1 10 11 2 3 4 5 6 7 8 9
-21 to 1: -1 -10 -11 -12 -13 -14 -15 -16 -17 -18 -19 -2 -20 -21 -3 -4 -5 -6 -7 -8 -9 0 1
0 to 1: error: start=blank
1 to -1: error: start>stop

Alternative, using GAWK's builtin sort[edit]

This version explicitly casts integers as strings during list generation and uses the builtin sort available in GAWK on element values.

BEGIN {
    n=13
    for (i=1; i<=n; i++) 
        a[i]=i""
    asort(a)
    for (k in a)
        printf "%d ", a[k]
}
Output:
1 10 11 12 13 2 3 4 5 6 7 8 9 

BaCon[edit]

Create a delimited string with numbers and use SORT$.

CONST n = 13
FOR x = 1 TO n
    result$ = APPEND$(result$, 0, STR$(x))
NEXT
PRINT SORT$(result$)
Output:
1 10 11 12 13 2 3 4 5 6 7 8 9

BBC BASIC[edit]

      N%=13
      PRINT "[" LEFT$(FNLexOrder(0)) "]"
      END

      DEF FNLexOrder(nr%) : LOCAL i%, s$
      FOR i%=nr% TO nr% + 9
        IF i% > N% EXIT FOR
        IF i% > 0 s$+=STR$i% + "," + FNLexOrder(i% * 10)
      NEXT
      =s$
Output:
[1,10,11,12,13,2,3,4,5,6,7,8,9]

C[edit]

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int compareStrings(const void *a, const void *b) {
    const char **aa = (const char **)a;
    const char **bb = (const char **)b;
    return strcmp(*aa, *bb);
}

void lexOrder(int n, int *ints) {
    char **strs;
    int i, first = 1, last = n, k = n, len;
    if (n < 1) {
        first = n; last = 1; k = 2 - n;
    } 
    strs = malloc(k * sizeof(char *));
    for (i = first; i <= last; ++i) {
        if (i >= 1) len = (int)log10(i) + 2;
        else if (i == 0) len = 2;
        else len = (int)log10(-i) + 3; 
        strs[i-first] = malloc(len);
        sprintf(strs[i-first], "%d", i);
    }
    qsort(strs, k, sizeof(char *), compareStrings);
    for (i = 0; i < k; ++i) {
        ints[i] = atoi(strs[i]);
        free(strs[i]);
    }
    free(strs);
}

int main() {
    int i, j, k, n,  *ints;
    int numbers[5] = {0, 5, 13, 21, -22};
    printf("In lexicographical order:\n\n");
    for (i = 0; i < 5; ++i) {
        k = n = numbers[i];
        if (k < 1) k = 2 - k;
        ints = malloc(k * sizeof(int));
        lexOrder(n, ints);
        printf("%3d: [", n);
        for (j = 0; j < k; ++j) {
            printf("%d ", ints[j]);
        }
        printf("\b]\n");
        free(ints);
    }
    return 0;
}
Output:
In lexicographical order:

  0: [0 1]
  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]
-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]

C#[edit]

Works with: C sharp version 7
using static System.Console;
using static System.Linq.Enumerable;

public class Program
{
    public static void Main() {
        foreach (int n in new [] { 0, 5, 13, 21, -22 }) WriteLine($"{n}: {string.Join(", ", LexOrder(n))}");
    }

    public static IEnumerable<int> LexOrder(int n) => (n < 1 ? Range(n, 2 - n) : Range(1, n)).OrderBy(i => i.ToString());
}
Output:
0: 0, 1
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
-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

C++[edit]

#include <algorithm>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>

void lexicographical_sort(std::vector<int>& numbers) {
    std::vector<std::string> strings(numbers.size());
    std::transform(numbers.begin(), numbers.end(), strings.begin(),
                   [](int i) { return std::to_string(i); });
    std::sort(strings.begin(), strings.end());
    std::transform(strings.begin(), strings.end(), numbers.begin(),
                   [](const std::string& s) { return std::stoi(s); });
}

std::vector<int> lexicographically_sorted_vector(int n) {
    std::vector<int> numbers(n >= 1 ? n : 2 - n);
    std::iota(numbers.begin(), numbers.end(), std::min(1, n));
    lexicographical_sort(numbers);
    return numbers;
}

template <typename T>
void print_vector(std::ostream& out, const std::vector<T>& v) {
    out << '[';
    if (!v.empty()) {
        auto i = v.begin();
        out << *i++;
        for (; i != v.end(); ++i)
            out << ',' << *i;
    }
    out << "]\n";
}

int main(int argc, char** argv) {
    for (int i : { 0, 5, 13, 21, -22 }) {
        std::cout << i << ": ";
        print_vector(std::cout, lexicographically_sorted_vector(i));
    }
    return 0;
}
Output:
0: [0,1]
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]
-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]

Clojure[edit]

(def n 13)
(sort-by str (range 1 (inc n)))
Output:
(1 10 11 12 13 2 3 4 5 6 7 8 9)

COBOL[edit]

Works with: GnuCOBOL
       identification division.
       program-id. LexicographicalNumbers.

       data division.
       working-storage section.
       78  MAX-NUMBERS            value 21.
       77  i                      pic 9(2).
       77  edited-number          pic z(2).
       
       01  lex-table.
           05 table-itms occurs MAX-NUMBERS.
              10 number-lex       pic x(2).

       procedure division.
       main.
      *>-> Load numbers
           perform varying i from 1 by 1 until i > MAX-NUMBERS
              move i to edited-number
              move edited-number to number-lex(i)
              call "C$JUSTIFY" using number-lex(i), "Left"
           end-perform

      *>-> Sort in lexicographic order
           sort table-itms ascending number-lex

      *>-> Show ordered numbers
           display "[" no advancing
           perform varying i from 1 by 1 until i > MAX-NUMBERS
              display function trim(number-lex(i)) no advancing
              if i < MAX-NUMBERS
                 display ", " no advancing
              end-if
           end-perform
           display "]"
           stop run
           .
Output:
[1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 2, 20, 21, 3, 4, 5, 6, 7, 8, 9]

Common Lisp[edit]

(defun lexicographic-sort (n)
  (sort (alexandria:iota n :start 1) #'string<= :key #'write-to-string))
(lexicographic-sort 13)
Output:
(1 10 11 12 13 2 3 4 5 6 7 8 9)

Factor[edit]

USING: formatting kernel math.parser math.ranges sequences
sorting ;
IN: rosetta-code.lexicographical-numbers

: lex-order ( n -- seq )
    [1,b] [ number>string ] map natural-sort
    [ string>number ] map ;
    
{ 13 21 -22 } [ dup lex-order "%3d: %[%d, %]\n" printf ] each
Output:
 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 }
-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 }

Fōrmulæ[edit]

Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.

Programs in Fōrmulæ are created/edited online in its website, However they run on execution servers. By default remote servers are used, but they are limited in memory and processing power, since they are intended for demonstration and casual use. A local server can be downloaded and installed, it has no limitations (it runs in your own computer). Because of that, example programs can be fully visualized and edited, but some of them will not run if they require a moderate or heavy computation/memory resources, and no local server is being used.

In this page you can see the program(s) related to this task and their results.

FreeBASIC[edit]

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 "]"
Output:

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

Go[edit]

package main

import (
    "fmt"
    "sort"
    "strconv"
)

func lexOrder(n int) []int {
    first, last, k := 1, n, n
    if n < 1 {
        first, last, k = n, 1, 2-n
    }
    strs := make([]string, k)
    for i := first; i <= last; i++ {
        strs[i-first] = strconv.Itoa(i)
    }
    sort.Strings(strs)
    ints := make([]int, k)
    for i := 0; i < k; i++ {
        ints[i], _ = strconv.Atoi(strs[i])
    }
    return ints
}

func main() {
    fmt.Println("In lexicographical order:\n")
    for _, n := range []int{0, 5, 13, 21, -22} {
        fmt.Printf("%3d: %v\n", n, lexOrder(n))
    }
}
Output:
In lexicographical order:

  0: [0 1]
  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]
-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]

Haskell[edit]

import Data.List (sort)

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:

import Data.List (sort)

task
  :: (Ord b, Show b)
  => [b] -> [b]
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).

import Data.List (sortOn)

main :: IO ()
main = print $ sortOn show [1 .. 13]
Output:
[1,10,11,12,13,2,3,4,5,6,7,8,9]

Isabelle[edit]

Works with: Isabelle version 2020
theory LexList
  imports
    Main 
    "~~/src/HOL/Library/Char_ord" 
    "~~/src/HOL/Library/List_Lexorder"
begin

definition ord_ascii_zero :: nat where
  "ord_ascii_zero == of_char (CHR ''0'')"

textGet the string representation for a single digit.
definition ascii_of_digit :: "nat ⇒ string" where
  "ascii_of_digit n ≡ if n ≥ 10 then undefined else [char_of (n + ord_ascii_zero)]"

fun ascii_of :: "nat ⇒ string" where
  "ascii_of n = (if n < 10
                  then ascii_of_digit n
                  else ascii_of (n div 10) @ ascii_of_digit (n mod 10))"

lemma ascii_of 123 = ''123''› by code_simp

value sort (map ascii_of (upt 1 13))
end
Output:
"[''1'', ''10'', ''11'', ''12'', ''2'', ''3'', ''4'', ''5'', ''6'', ''7'', ''8'', ''9'']"
  :: "char list list"

J[edit]

task=: [: (/: ":"0) 1 + i.
task 13
Output:
1 10 11 12 13 2 3 4 5 6 7 8 9

Java[edit]

Translation of: Kotlin


Requires Java 8 or later.

import java.util.List;
import java.util.stream.*;

public class LexicographicalNumbers {

    static List<Integer> lexOrder(int n) {
        int first = 1, last = n;
        if (n < 1) {
            first = n;
            last = 1;
        }
        return IntStream.rangeClosed(first, last)
                        .mapToObj(Integer::toString)
                        .sorted()
                        .map(Integer::valueOf)
                        .collect(Collectors.toList());
    }

    public static void main(String[] args) {
        System.out.println("In lexicographical order:\n");
        int[] ints = {0, 5, 13, 21, -22};
        for (int n : ints) {
           System.out.printf("%3d: %s\n", n, lexOrder(n));
        }
    }
}
Output:
In lexicographical order:

  0: [0, 1]
  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]
-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]

Ksh[edit]

#!/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[*]}
Output:

1 10 11 12 13 2 3 4 5 6 7 8 9

jq[edit]

Works with: jq

Works with gojq, the Go implementation of jq

def sort_range($a;$b): [range($a;$b)] | sort_by(tostring);

# Example
# jq's index origin is 0, so ...
sort_range(1;14)
Output:
[1,10,11,12,13,2,3,4,5,6,7,8,9]

Julia[edit]

lexorderedsequence(n) = sort(collect(n > 0 ? (1:n) : n:1), lt=(a,b) -> string(a) < string(b))

for i in [0, 5, 13, 21, -32]
    println(lexorderedsequence(i))
end
Output:
[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, -23, -24, -25, -26, -27, -28, -29, -3, -30, -31, -32, -4, -5, -6, -7, -8, -9, 0, 1]

Kotlin[edit]

// Version 1.2.51

fun lexOrder(n: Int): List<Int> {
    var first = 1
    var last = n
    if (n < 1) {
        first = n
        last = 1
    }
    return (first..last).map { it.toString() }.sorted().map { it.toInt() }
}

fun main(args: Array<String>) {
    println("In lexicographical order:\n")
    for (n in listOf(0, 5, 13, 21, -22)) {
        println("${"%3d".format(n)}: ${lexOrder(n)}")
    }
}
Output:
In lexicographical order:

  0: [0, 1]
  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]
-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]

Lambdatalk[edit]

1) lexicographically sorting a sequence of numbers
{S.sort before 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

2) lexicographically sorting an array of numbers
{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]

Lua[edit]

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.

function lexNums (limit)
  local numbers = {}
  for i = 1, limit do
    table.insert(numbers, tostring(i))
  end
  table.sort(numbers)
  return numbers
end

local numList = lexNums(13)
print(table.concat(numList, " "))
Output:
1 10 11 12 13 2 3 4 5 6 7 8 9

M2000 Interpreter[edit]

Module Checkit {
      Function lexicographical(N) {
            const nl$=Chr$(13)+Chr$(10)
            If N<>0 then {
                  if N=1 then =(1,) : Exit
                  Document A$
                  For k=1 to N-1 
                        A$=Str$(k,"")+{
                        }
                  Next k
                  A$=Str$(N,"")
                  Method A$, "SetBinaryCompare"
                  Sort A$
                  Flush
                  \\ convert strings to numbers in one statement
                  \\ in stack of values
                  Data Param(Replace$(nl$,",", a$))
                  \\ return stack as array 
                  =Array([])
            }  else =(0,)   ' empty array
      }
      Print lexicographical(5)  ' 1 2 3 4 5
      Print lexicographical(13) ' 1 10 11 12 13 2 3 4 5 6 7 8 9
      Print lexicographical(21) ' 1 10 11 12 13 14 15 16 17 18 19 2 20 21 3 4 5 6 7 8 9
      Print lexicographical(-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
}
Checkit
Module Checkit {
      Function lexicographical$(N) {
            const nl$=Chr$(13)+Chr$(10)
            If N<>0 then {
                  if N=1 then =(1,) : Exit
                  Document A$
                  For k=1 to N-1 
                        A$=Str$(k,"")+{
                        }
                  Next k
                  A$=Str$(N,"")
                  \\ by default id TextCompare, so 0 an 1 comes first in -22
                  Method A$, "SetBinaryCompare"
                  Sort A$
                  Flush
                  ="["+Replace$(nl$," ", a$)+"]"
                  
            }  else =("",)   ' empty array
      }
      Print lexicographical$(5)  ' [1 2 3 4 5]
      Print lexicographical$(13) ' [1 10 11 12 13 2 3 4 5 6 7 8 9]
      Print lexicographical$(21) '[1 10 11 12 13 14 15 16 17 18 19 2 20 21 3 4 5 6 7 8 9]
      Print lexicographical$(-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]
}
Checkit

Mathematica/Wolfram Language[edit]

SortBy[Range[13],ToString]
Output:
{1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9}

Microsoft Small Basic[edit]

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.

' Lexicographical numbers - 25/07/2018
xx="000000000000000"
For n=1 To 3
  nn=Text.GetSubText("   5  13  21",n*4-3,4)
  ll=Text.GetLength(nn)
  For i=1 To nn
    t[i]=i
  EndFor
  i=nn-1
  k=0
  For i=i To 1 Step -1
    ok=1
    For j=1 To i
      k=j+1
      tj=Text.GetSubText(Text.Append(t[j],xx),1,ll)
      tk=Text.GetSubText(Text.Append(t[k],xx),1,ll)
      If tj>tk Then 
        w=t[j]
        t[j]=t[k]
        t[k]=w
        ok=0
      EndIf
    EndFor
    If ok=1 Then
      Goto exitfor
    EndIf
  EndFor
exitfor:
  x=""
  For i=1 To nn
    x=x+","+t[i]
  EndFor
  TextWindow.WriteLine(nn+":"+Text.GetSubTextToEnd(x,2))
EndFor
Output:
  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

MUMPS[edit]

This shows a few unique features of MUMPS:

- There is only one datatype which is implicitly coerced to string, integer, or floating-point as necessary.

- MUMPS arrays sort automatically

- The condensed version shows that there are no reserved keywords

SortLexographically(n)
 new array,i,j
 for i=1:1:n set array(i_" ")=""
 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
 do SortLexographically(13)
Output:
1 10 11 12 13 2 3 4 5 6 7 8 9

Nim[edit]

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)
Output:
@[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]

Perl[edit]

printf("%4d: [%s]\n", $_, join ',', sort $_ > 0 ? 1..$_ : $_..1) for 13, 21, -22
Output:
  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]
 -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]

Phix[edit]

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.

with javascript_semantics
function lexicographic_order(sequence s) 
    return extract(s,custom_sort(apply(s,sprint),tagset(length(s))))
end function
 
?lexicographic_order({1,0})
?lexicographic_order(tagset(5))
?lexicographic_order(tagset(13))
?lexicographic_order(tagset(21,1,2))
?lexicographic_order(tagset(11,-21,4))
?lexicographic_order({1.25, -6, -10, 9, -11.3, 13, -3, 0})
Output:
{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}

PicoLisp[edit]

(println
   (by
      format
      sort
      (range 1 13) ) )
Output:
(1 10 11 12 13 2 3 4 5 6 7 8 9)

Prolog[edit]

Works with: SWI Prolog
lexicographical_sort(Numbers, Sorted_numbers):-
    number_strings(Numbers, Strings),
    sort(Strings, Sorted_strings),
    number_strings(Sorted_numbers, Sorted_strings).

number_strings([], []):-!.
number_strings([Number|Numbers], [String|Strings]):-
    number_string(Number, String),
    number_strings(Numbers, Strings).

number_list(From, To, []):-
    From > To,
    !.
number_list(From, To, [From|Rest]):-
    Next is From + 1,
    number_list(Next, To, Rest).

lex_sorted_number_list(Number, List):-
    (Number < 1 ->
        number_list(Number, 1, Numbers)
        ;
        number_list(1, Number, Numbers)
    ),
    lexicographical_sort(Numbers, List).

test(Number):-
    lex_sorted_number_list(Number, List),
    writef('%w: %w\n', [Number, List]).

main:-
    test(0),
    test(5),
    test(13),
    test(21),
    test(-22).
Output:
0: [0,1]
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]
-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]

PureBasic[edit]

Translation of: Go
EnableExplicit

Procedure lexOrder(n, Array ints(1))
    Define first = 1, last = n, k = n, i  
    If n < 1
        first = n
        last = 1
        k = 2 - n
    EndIf
    Dim strs.s(k - 1)
    For i = first To last
        strs(i - first) = Str(i)
    Next
    SortArray(strs(), #PB_Sort_Ascending)
    For i = 0 To k - 1
        ints(i) = Val(Strs(i))
    Next
EndProcedure

If OpenConsole()
    PrintN(~"In lexicographical order:\n")
    Define i, j, n, k
    For i = 0 To 4
        Read n
        k = n
        If n < 1
            k = 2 - n
        EndIf
        Dim ints(k - 1)
        lexOrder(n, ints())
        Define.s ns = RSet(Str(n), 3)
        Print(ns + ": [")
        For j = 0 To k - 1
            Print(Str(ints(j)) + " ")
        Next j
        PrintN(~"\b]")
    Next i
    Input()
    End

    DataSection
        Data.i 0, 5, 13, 21, -22
    EndDataSection
EndIf
Output:
In lexicographical order:

  0: [0 1]
  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]
-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]

Python[edit]

n=13
print(sorted(range(1,n+1), key=str))
Output:
[1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]

Quackery[edit]

  [ [] swap times 
      [ i^ 1+ number$ 
        nested join ] 
    sort$ 
    [] swap 
    witheach 
      [ $->n drop join ] ] is task ( n --> [ )

  13 task echo
Output:
[ 1 10 11 12 13 2 3 4 5 6 7 8 9 ]


Racket[edit]

#lang racket

(define (lex-sort n) (sort (if (< 0 n) (range 1 (add1 n)) (range n 2))
                           string<? #:key number->string))

(define (show n) (printf "~a: ~a\n" n (lex-sort n)))

(show 0)
(show 1)
(show 5)
(show 13)
(show 21)
(show -22)
Output:
0: (0 1)
1: (1)
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)
-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)

Raku[edit]

(formerly Perl 6)

Works with: Rakudo version 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.)

sub lex (Real $n, $step = 1) {
    ($n < 1 ?? ($n, * + $step …^ * > 1)
            !! ($n, * - $step …^ * < 1)).sort: ~*
}

# TESTING
for 13, 21, -22, (6, .333), (-4, .25), (-5*π, e) {
    my ($bound, $step) = |$_, 1;
    say "Boundary:$bound, Step:$step >> ", lex($bound, $step).join: ', ';
}
Output:
Boundary:13, Step:1 >> 1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9
Boundary:21, Step:1 >> 1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 2, 20, 21, 3, 4, 5, 6, 7, 8, 9
Boundary:-22, Step:1 >> -1, -10, -11, -12, -13, -14, -15, -16, -17, -18, -19, -2, -20, -21, -22, -3, -4, -5, -6, -7, -8, -9, 0, 1
Boundary:6, Step:0.333 >> 1.005, 1.338, 1.671, 2.004, 2.337, 2.67, 3.003, 3.336, 3.669, 4.002, 4.335, 4.668, 5.001, 5.334, 5.667, 6
Boundary:-4, Step:0.25 >> -0.25, -0.5, -0.75, -1, -1.25, -1.5, -1.75, -2, -2.25, -2.5, -2.75, -3, -3.25, -3.5, -3.75, -4, 0, 0.25, 0.5, 0.75, 1
Boundary:-15.707963267948966, Step:2.718281828459045 >> -10.271399611030876, -12.989681439489921, -15.707963267948966, -2.116554125653742, -4.834835954112787, -7.553117782571832, 0.6017277028053032

REXX[edit]

This REXX version allows the starting and ending numbers to be specified via the command line (CL),
as well as the increment.   Negative numbers are supported and need not be integers.

/*REXX pgm displays a horizontal list of a  range of numbers  sorted  lexicographically.*/
parse arg LO HI INC .                            /*obtain optional arguments from the CL*/
if  LO=='' |  LO==","  then  LO=  1              /*Not specified?  Then use the default.*/
if  HI=='' |  HI==","  then  HI= 13              /* "      "         "   "   "     "    */
if INC=='' | INC==","  then INC=  1              /* "      "         "   "   "     "    */
#= 0                                             /*for actual sort, start array with  1.*/
                  do j=LO  to  HI  by  INC       /*construct an array from  LO   to  HI.*/
                  #= # + 1;        @.#= j / 1    /*bump counter;  define array element. */
                  end   /*j*/                    /* [↑]  Also, normalize the element #. */
call Lsort #                                     /*sort numeric array with a simple sort*/
$=                                               /*initialize a horizontal numeric list.*/
                  do k=1  for  #;    $= $','@.k  /*construct      "         "      "    */
                  end   /*k*/                    /* [↑]  prefix each number with a comma*/
                                                 /* [↓]  display a continued  SAY  text.*/
say 'for   '  LO"──►"HI     ' by '     INC     " (inclusive), "         # ,
                                               ' elements sorted lexicographically:'
say  '['strip($, "L", ',')"]"                    /*strip leading comma, bracket the list*/
exit                                             /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
Lsort: procedure expose @.; parse arg n;  m= n-1 /*N: is the number of @ array elements.*/
       do m=m  by -1  until ok;          ok= 1   /*keep sorting the  @ array until done.*/
          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
output   when using the default inputs:
for    1──►13  by  1  (inclusive),  13  elements sorted lexicographically:
[1,10,11,12,13,2,3,4,5,6,7,8,9]
output   when using the input of:     1   34
for    1──►34  by  1  (inclusive),  34  elements sorted lexicographically:
[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,4,5,6,7,8,9]
output   when using the input of:     -11   22
for    -11──►22  by  1  (inclusive),  34  elements sorted lexicographically:
[-1,-10,-11,-2,-3,-4,-5,-6,-7,-8,-9,0,1,10,11,12,13,14,15,16,17,18,19,2,20,21,22,3,4,5,6,7,8,9]
output   when using the input of:     -4   8   0.5
for    -4──►8  by  0.5  (inclusive),  25  elements sorted lexicographically:
[-0.5,-1,-1.5,-2,-2.5,-3,-3.5,-4,0,0.5,1,1.5,2,2.5,3,3.5,4,4.5,5,5.5,6,6.5,7,7.5,8]

Ring[edit]

# Project : Lexicographical numbers

lex = 1:13
strlex = list(len(lex))
for n = 1 to len(lex)
     strlex[n] = string(lex[n])
next
strlex = sort(strlex)
see "Lexicographical numbers = "
showarray(strlex)

func showarray(vect)
        see "["
        svect = ""
        for n = 1 to len(vect)
              svect = svect + vect[n] + ","
        next
        svect = left(svect, len(svect) - 1)
        see svect + "]" + nl

Output:

Lexicographical numbers = [1,10,11,12,13,2,3,4,5,6,7,8,9]

Ruby[edit]

n = 13
p (1..n).sort_by(&:to_s)
Output:
[1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]

Rust[edit]

fn lex_sorted_vector(num: i32) -> Vec<i32> {
    let (min, max) = if num >= 1 { (1, num) } else { (num, 1) };
    let mut str: Vec<String> = (min..=max).map(|i| i.to_string()).collect();
    str.sort();
    str.iter().map(|s| s.parse::<i32>().unwrap()).collect()
}

fn main() {
    for n in &[0, 5, 13, 21, -22] {
        println!("{}: {:?}", n, lex_sorted_vector(*n));
    }
}
Output:
0: [0, 1]
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]
-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]

Scala[edit]

Output:
Best seen in running your browser either by ScalaFiddle (ES aka JavaScript, non JVM) or Scastie (remote JVM).
object LexicographicalNumbers extends App {  def ints = List(0, 5, 13, 21, -22)

  def lexOrder(n: Int): Seq[Int] = (if (n < 1) n to 1 else 1 to n).sortBy(_.toString)

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

}

Sidef[edit]

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

[13, 21, -22].each {|n|
    printf("%4s: %s\n", n, lex_order(n))
}
Output:
  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]
 -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]


Swift[edit]

func lex(n: Int) -> [Int] {
  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))")
print("-22: \(lex(n: -22))")
Output:
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]
-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]

Tcl[edit]

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]]
Output:
1 10 11 12 13 2 3 4 5 6 7 8 9

VBA[edit]

Public Function sortlexicographically(N As Integer)
    Dim arrList As Object
    Set arrList = CreateObject("System.Collections.ArrayList")
    For i = 1 To N
        arrList.Add CStr(i)
    Next i
    arrList.Sort
    Dim item As Variant
    For Each item In arrList
        Debug.Print item & ", ";
    Next
End Function

Public Sub main()
    Call sortlexicographically(13)
End Sub
Output:
1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9, 

Wren[edit]

Library: Wren-sort
import "/sort" for Sort

var a = (1..13).map { |i| "%(i)" }.toList
Sort.quick(a)
System.print(a)
Output:
[1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]

zkl[edit]

fcn lexN(n){ n.pump(List,'+(1),"toString").sort().apply("toInt") }
foreach n in (T(5,13,21)){ println("%2d: %s".fmt(n,lexN(n).concat(","))) }
Output:
 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