# Generate all numbers up to N in Lexicographical Order

• Difficulty Level : Easy
• Last Updated : 31 Jul, 2022

Given an integer N, the task is to print all numbers up to N in Lexicographical order.

Examples:

Input: N = 15
Output:
1 10 11 12 13 14 15 2 3 4 5 6 7 8 9

Input: N = 19
Output:
1 10 11 12 13 14 15 16 17 18 19 2 3 4 5 6 7 8 9

Approach:
In order to solve the problem, follow the steps below:

• Iterate from 1 to N and store all the numbers in the form of strings.
• Sort the vector containing the strings.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement the``// above approach``#include ``using` `namespace` `std;` `// Function to print all the``// numbers up to n in``// lexicographical order``void` `lexNumbers(``int` `n)``{``    ``vector s;` `    ``for` `(``int` `i = 1; i <= n; i++) {``        ``s.push_back(to_string(i));``    ``}` `    ``sort(s.begin(), s.end());``    ``vector<``int``> ans;``    ``for` `(``int` `i = 0; i < n; i++)``        ``ans.push_back(stoi(s[i]));` `    ``for` `(``int` `i = 0; i < n; i++)``        ``cout << ans[i] << ``" "``;``}``// Driver Program``int` `main()``{` `    ``int` `n = 15;``    ``lexNumbers(n);``    ``return` `0;``}`

## Java

 `// Java Program to implement the``// above approach``import` `java.util.*;``class` `GFG{` `// Function to print all the``// numbers up to n in``// lexicographical order``static` `void` `lexNumbers(``int` `n)``{``    ``Vector s = ``new` `Vector();` `    ``for` `(``int` `i = ``1``; i <= n; i++)``    ``{``        ``s.add(String.valueOf(i));``    ``}` `    ``Collections.sort(s);``    ``Vector ans = ``new` `Vector();``    ``for` `(``int` `i = ``0``; i < n; i++)``        ``ans.add(Integer.valueOf(s.get(i)));` `    ``for` `(``int` `i = ``0``; i < n; i++)``        ``System.out.print(ans.get(i) + ``" "``);``}``// Driver Program``public` `static` `void` `main(String[] args)``{``    ``int` `n = ``15``;``    ``lexNumbers(n);``}``}` `// This code is contributed by sapnasingh4991`

## Python3

 `# Python3 program to implement``# above approach` `# Function to print all the``# numbers up to n in``# lexicographical order``def` `lexNumbers(n):``    ` `    ``s ``=` `[]``    ``for` `i ``in` `range``(``1``, n ``+` `1``):``        ``s.append(``str``(i))``        ` `    ``s.sort()``    ``ans ``=` `[]``    ` `    ``for` `i ``in` `range``(n):``        ``ans.append(``int``(s[i]))` `    ``for` `i ``in` `range``(n):``        ``print``(ans[i], end ``=` `' '``)``        ` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ` `    ``n ``=` `15``    ``lexNumbers(n)``    ` `# This code is contributed by Ediga_Manisha`

## C#

 `// C# program to implement the``// above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to print all the``// numbers up to n in``// lexicographical order``static` `void` `lexNumbers(``int` `n)``{``    ``List s = ``new` `List();` `    ``for``(``int` `i = 1; i <= n; i++)``    ``{``       ``s.Add(String.Join(``""``, i));``    ``}` `    ``s.Sort();``    ``List<``int``> ans = ``new` `List<``int``>();``    ` `    ``for``(``int` `i = 0; i < n; i++)``       ``ans.Add(Int32.Parse(s[i]));` `    ``for``(``int` `i = 0; i < n; i++)``       ``Console.Write(ans[i] + ``" "``);``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `n = 15;``    ` `    ``lexNumbers(n);``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output

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

Time Complexity: O(N log N) // time complexity of sort function is NlogN

Space Complexity: O(N) // because an extra vector of string s is used

Another Approach:

• Using DFS: Always multiply temp by 10 till temp * 10 is greater than n
• Increment temp by 1 when the last digit of temp is not equal to 9

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `void` `dfs(``int` `temp, ``int` `n, vector<``int``> &sol);` `void` `lexNumbers(``int` `n)``{``    ``vector<``int``> sol;``    ``dfs(1, n, sol);``    ``cout << ``"["` `<< sol[0];``    ``for` `(``int` `i = 1; i < sol.size(); i++)``       ``cout << ``", "``<< sol[i];``    ``cout << ``"]"``;``}` `void` `dfs(``int` `temp, ``int` `n, vector<``int``> &sol)``{``    ``if` `(temp > n)``        ``return``;``    ``sol.push_back(temp);``    ``dfs(temp * 10, n, sol);``    ``if` `(temp % 10 != 9)``        ``dfs(temp + 1, n, sol);``}` `int` `main()``{``    ``int` `n = 15;``    ``lexNumbers(n);``    ``return` `0;``}` `// This Code is contributed by ShubhamSingh10`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.util.*;` `class` `GFG {` `    ``public` `static` `void` `lexNumbers(``int` `n)``    ``{``        ``List sol = ``new` `ArrayList<>();``        ``dfs(``1``, n, sol);``        ``System.out.println(sol);``    ``}` `    ``public` `static` `void` `dfs(``int` `temp, ``int` `n,``                           ``List sol)``    ``{``        ``if` `(temp > n)``            ``return``;``        ``sol.add(temp);``        ``dfs(temp * ``10``, n, sol);``        ``if` `(temp % ``10` `!= ``9``)``            ``dfs(temp + ``1``, n, sol);``    ``}` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `n = ``15``;``        ``lexNumbers(n);``    ``}``}`

## Python3

 `# Python program for the above approach``def` `lexNumbers(n):``    ``sol ``=` `[]``    ``dfs(``1``, n, sol)``    ``print``(``"["``, sol[``0``], end``=` `"``", sep ="``")``    ``for` `i ``in` `range``(``1``,n):``        ``print``(``", "``, sol[i], end``=` `"``", sep ="``")``    ``print``(``"]"``)`  `def` `dfs(temp, n, sol):``    ``if` `(temp > n):``        ``return``    ``sol.append(temp)``    ``dfs(temp ``*` `10``, n, sol)``    ``if` `(temp ``%` `10` `!``=` `9``):``        ``dfs(temp ``+` `1``, n, sol)` `n ``=` `15``lexNumbers(n)` `# This Code is contributed by ShubhamSingh10`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `public` `static` `void` `lexNumbers(``int` `n)``{``    ``List<``int``> sol = ``new` `List<``int``>();``    ``dfs(1, n, sol);``    ``Console.WriteLine(``"["` `+ ``string``.Join(``", "``, sol) + ``"]"``);``}` `public` `static` `void` `dfs(``int` `temp, ``int` `n,``                       ``List<``int``> sol)``{``    ``if` `(temp > n)``        ``return``;``        ` `    ``sol.Add(temp);``    ``dfs(temp * 10, n, sol);``    ` `    ``if` `(temp % 10 != 9)``        ``dfs(temp + 1, n, sol);``}` `// Driver code``public` `static` `void` `Main()``{``    ``int` `n = 15;``    ``lexNumbers(n);``}``}` `// This code is contributed by shubhamsingh10`

## Javascript

 ``

Output

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

Time Complexity: O(N)
Auxiliary Space: O (1)

When There is a Range:-

Given two integers L and R, the task is to print all numbers in the range of  L to R (inclusively) in Lexicographical Order.

Examples:

```Input: L = 9 , R = 21
Output:
10 11 12 13 14 15 16 17 18 19 20 21 9
Input: L = 1 , R= 13
Output:
1 10 11 12 13 2 3 4 5 6 7 8 9```

Approach:

In order to solve the problem, follow the steps below:

• Iterate from L to R ( inclusively ) and store all the numbers in the form of strings.
• Sort the vector containing the strings.

Below is the implementation of the above approach :

## C++

 `// C++ program to implement the``// above approach``#include ``using` `namespace` `std;` `// Function to print all the``// numbers form l to r in``// lexicographical order``void` `lexNumbers(``int` `l, ``int` `r)``{``    ``vector s;` `    ``for``(``int` `i = l; i <= r; i++)``    ``{``        ``s.push_back(to_string(i));``    ``}` `    ``sort(s.begin(),s.end());``    ``vector<``int``> ans;``    ` `    ``for``(``int` `i = 0; i < s.size(); i++)``        ``ans.push_back(stoi(s[i]));` `    ``for``(``int` `i = 0; i < s.size(); i++)``        ``cout << ans[i] << ``" "``;``}``    ` `// Driver code``int` `main()``{``    ``int` `l = 9;``    ``int` `r = 21;``    ` `    ``lexNumbers(l, r);``}` `// This code is contributed by ajaykr00kj`

## Java

 `// Java Program to implement the``// above approach``import` `java.util.*;``class` `GFG {` `    ``// Function to print all the``    ``// numbers form l to r in``    ``// lexicographical order``    ``static` `void` `lexNumbers(``int` `l, ``int` `r)``    ``{``        ``Vector s = ``new` `Vector();` `        ``for` `(``int` `i = l; i <= r; i++) {``            ``s.add(String.valueOf(i));``        ``}` `        ``Collections.sort(s);``        ``Vector ans = ``new` `Vector();``        ``for` `(``int` `i = ``0``; i < s.size(); i++)``            ``ans.add(Integer.valueOf(s.get(i)));` `        ``for` `(``int` `i = ``0``; i < s.size(); i++)``            ``System.out.print(ans.get(i) + ``" "``);``    ``}``    ``// Driver Program``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `l = ``9``;``        ``int` `r = ``21``;``        ``lexNumbers(l, r);``    ``}``}`

## Python3

 `# Python 3 program to implement``# the above approach` `# Function to print all the``# numbers form l to r in``# lexicographical order``def` `lexNumbers(l, r):` `    ``s ``=` `[]` `    ``for` `i ``in` `range``(l, r ``+` `1``):``        ``s.append(``str``(i))` `    ``s.sort()``    ``ans ``=` `[]` `    ``for` `i ``in` `range``(``len``(s)):``        ``ans.append(``int``(s[i]))` `    ``for` `i ``in` `range``(``len``(s)):``        ``print``(ans[i], end ``=` `" "``)` `# Driver code``if` `__name__ ``=``=` `"__main__"``:``  ` `    ``l ``=` `9``    ``r ``=` `21``    ``lexNumbers(l, r)` `# This code is contributed by Chitranayal`

## C#

 `// C# program to implement the``// above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG``{` `  ``// Function to print all the``  ``// numbers form l to r in``  ``// lexicographical order``  ``static` `void` `lexNumbers(``int` `l, ``int` `r)``  ``{``    ``List s = ``new` `List();` `    ``for` `(``int` `i = l; i <= r; i++)``    ``{``      ``s.Add(String.Join(``""``, i));``    ``}` `    ``s.Sort();``    ``List<``int``> ans = ``new` `List<``int``>();` `    ``for` `(``int` `i = 0; i < s.Count; i++)``      ``ans.Add(Int32.Parse(s[i]));` `    ``for` `(``int` `i = 0; i < s.Count; i++)``      ``Console.Write(ans[i] + ``" "``);``  ``}` `  ``// Driver Program``  ``static` `public` `void` `Main()``  ``{``    ``int` `l = 9;``    ``int` `r = 21;``    ``lexNumbers(l, r);``  ``}``}` `// This code is contributed by Dharanendra L V`

## Javascript

 ``

Output

`10 11 12 13 14 15 16 17 18 19 20 21 9 `

Time Complexity: O(N*logN)
Auxiliary Space: O (1)

My Personal Notes arrow_drop_up