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 9Input: 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++ Program to implement the // above approach #include <bits/stdc++.h> using namespace std;
// Function to print all the // numbers up to n in // lexicographical order 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] << " " ;
} // Driver Program int main()
{ int n = 15;
lexNumbers(n);
return 0;
} |
// 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<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) + " " );
} // Driver Program public static void main(String[] args)
{ int n = 15 ;
lexNumbers(n);
} } // This code is contributed by sapnasingh4991 |
# 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# 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<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] + " " );
} // Driver code public static void Main(String[] args)
{ int n = 15;
lexNumbers(n);
} } // This code is contributed by Rajput-Ji |
<script> // Javascript Program to implement the // above approach // Function to print all the // numbers up to n in // lexicographical order 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] + " " );
} // Driver Program let n = 15; lexNumbers(n); // This code is contributed by avanitrachhadiya2155 </script> |
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++ program for the above approach #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;
} // This Code is contributed by ShubhamSingh10 |
// Java program for the above approach 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);
}
} |
# 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# 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 |
<script> // JavaScript program for the above approach 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); // This Code is contributed by ShubhamSingh10 </script> |
[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++ program to implement the // above approach #include <bits/stdc++.h> using namespace std;
// Function to print all the // numbers form l to r in // lexicographical order 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] << " " ;
} // Driver code int main()
{ int l = 9;
int r = 21;
lexNumbers(l, r);
} // This code is contributed by ajaykr00kj |
// 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<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) + " " );
}
// Driver Program
public static void main(String[] args)
{
int l = 9 ;
int r = 21 ;
lexNumbers(l, r);
}
} |
# 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# 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<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] + " " );
}
// Driver Program
static public void Main()
{
int l = 9;
int r = 21;
lexNumbers(l, r);
}
} // This code is contributed by Dharanendra L V |
<script> // Javascript Program to implement the // above approach // Function to print all the
// numbers form l to r in
// lexicographical order
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] + " " );
}
// Driver Program
let l = 9;
let r = 21;
lexNumbers(l, r);
// This code is contributed by rag2127 </script> |
10 11 12 13 14 15 16 17 18 19 20 21 9
Time Complexity: O(N*logN)
Auxiliary Space: O (1)