Generate all numbers up to N in Lexicographical Order
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++
#include <bits/stdc++.h>
using namespace std;
void lexNumbers( int n)
{
vector<string> 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] << " " ;
}
int main()
{
int n = 15;
lexNumbers(n);
return 0;
}
|
Java
import java.util.*;
class GFG{
static void lexNumbers( int n)
{
Vector<String> s = new Vector<String>();
for ( int i = 1 ; i <= n; i++)
{
s.add(String.valueOf(i));
}
Collections.sort(s);
Vector<Integer> ans = new Vector<Integer>();
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) + " " );
}
public static void main(String[] args)
{
int n = 15 ;
lexNumbers(n);
}
}
|
Python3
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 = ' ' )
if __name__ = = "__main__" :
n = 15
lexNumbers(n)
|
C#
using System;
using System.Collections.Generic;
class GFG{
static void lexNumbers( int n)
{
List<String> s = new List<String>();
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] + " " );
}
public static void Main(String[] args)
{
int n = 15;
lexNumbers(n);
}
}
|
Javascript
<script>
function lexNumbers(n)
{
let s = [];
for (let i = 1; i <= n; i++)
{
s.push(i.toString());
}
s.sort();
let ans = [];
for (let i = 0; i < n; i++)
ans.push(parseInt(s[i]));
for (let i = 0; i < n; i++)
document.write(ans[i] + " " );
}
let n = 15;
lexNumbers(n);
</script>
|
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++
#include <bits/stdc++.h>
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;
}
|
Java
import java.io.*;
import java.util.*;
class GFG {
public static void lexNumbers( int n)
{
List<Integer> sol = new ArrayList<>();
dfs( 1 , n, sol);
System.out.println(sol);
}
public static void dfs( int temp, int n,
List<Integer> 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
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)
|
C#
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);
}
public static void Main()
{
int n = 15;
lexNumbers(n);
}
}
|
Javascript
<script>
function lexNumbers(n)
{
var sol = [];
dfs(1, n, sol);
document.write( "[" + sol[0]);
for ( var i = 1; i < sol.length; i++)
document.write( ", " + sol[i]);
document.write( "]" );
}
function dfs(temp, n, sol)
{
if (temp > n)
return ;
sol.push(temp);
dfs(temp * 10, n, sol);
if (temp % 10 != 9)
dfs(temp + 1, n, sol);
}
var n = 15;
lexNumbers(n);
</script>
|
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++
#include <bits/stdc++.h>
using namespace std;
void lexNumbers( int l, int r)
{
vector<string> 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] << " " ;
}
int main()
{
int l = 9;
int r = 21;
lexNumbers(l, r);
}
|
Java
import java.util.*;
class GFG {
static void lexNumbers( int l, int r)
{
Vector<String> s = new Vector<String>();
for ( int i = l; i <= r; i++) {
s.add(String.valueOf(i));
}
Collections.sort(s);
Vector<Integer> ans = new Vector<Integer>();
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) + " " );
}
public static void main(String[] args)
{
int l = 9 ;
int r = 21 ;
lexNumbers(l, r);
}
}
|
Python3
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 = " " )
if __name__ = = "__main__" :
l = 9
r = 21
lexNumbers(l, r)
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static void lexNumbers( int l, int r)
{
List<String> s = new List<String>();
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] + " " );
}
static public void Main()
{
int l = 9;
int r = 21;
lexNumbers(l, r);
}
}
|
Javascript
<script>
function lexNumbers(l,r)
{
let s = [];
for (let i = l; i <= r; i++) {
s.push((i).toString());
}
s.sort();
let ans = [];
for (let i = 0; i < s.length; i++)
ans.push(parseInt(s[i]));
for (let i = 0; i < s.length; i++)
document.write(ans[i] + " " );
}
let l = 9;
let r = 21;
lexNumbers(l, r);
</script>
|
Output
10 11 12 13 14 15 16 17 18 19 20 21 9
Time Complexity: O(N*logN)
Auxiliary Space: O (1)
Share your thoughts in the comments
Please Login to comment...