Smallest number containing all possible N length permutations using digits 0 to D

Given two integer N and K, the task is to find the size of the smallest string that contains all permutations of length N that can be formed using first D digits (0, 1, …, D-1).


Input: N = 2, D = 2
Output: 01100
Possible permutations of length 2 from digits (0, 1) are {00, 01, 10, 11}.
“01100” is one such string that contains all the permutations as a substring.
Other possible answers are “00110”, “10011”, “11001”

Input: N = 2, D = 4
Output: 03322312113020100
Here all possible permutations of length 2 from digits {0, 1, 2, 3} are
00 10 20 30
01 11 21 31
02 12 22 32
03 13 23 33
“03322312113020100” is a string of minimum length that contains all the above permutations.

Append ‘0’ N-1 times and call DFS on the string in the current state. Append all the D characters one by one. Every time after appending, check if the new string is visited or not. If so, mark it visited by inserting it into a HashSet and add this character in the answer. Recursively call the DFS function on the last D characters. Repeat this process until all possible substrings of N length from the D digits are appended to the string. Print the final string generated.

Below is the implementation of the above approach:






// Java Program to find the
// minimum length string
// consisting of all
// permutations of length N
// of D digits
import java.util.*;
import java.lang.*;
class GeeksforGeeks {
    // Initialize hashset to see
    // if all the possible
    // permutations are present
    // in the min length string
    static Set<String> visited;
    // To keep min length string
    static StringBuilder ans;
    public static String reqString(int N,
                                   int D)
        // Base case
        if (N == 1 && D == 1)
            return "0";
        visited = new HashSet<>();
        ans = new StringBuilder();
        StringBuilder sb = new StringBuilder();
        // Append '0' n-1 times
        for (int i = 0; i < N - 1; ++i) {
        String start = sb.toString();
        // Call the DFS Function
        dfs(start, D);
        return new String(ans);
    // Generate the required string
    public static void dfs(String curr, int D)
        // Iterate over all the possible
        // character
        for (int x = 0; x < D; ++x) {
            // Append to make a new string
            String neighbour = curr + x;
            // If the new string is not
            // visited
            if (!visited.contains(neighbour)) {
                // Add in hashset
                // Call the dfs function on
                // the last d characters
                dfs(neighbour.substring(1), D);
    // Driver Code
    public static void main(String args[])
        int N = 2;
        int D = 2;
        System.out.println(reqString(N, D));




Time Complexity: O(N * DN)
Auxiliary Space: O(N * DN)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Recommended Posts:

If you like GeeksforGeeks and would like to contribute, you can also write an article using or mail your article to See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.