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

• Difficulty Level : Medium
• Last Updated : 20 Apr, 2022

Given two integer N and D, 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).
Examples:

Input: N = 2, D = 2
Output: 01100
Explanation:
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
Explaination:
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.

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

## C++

 `// C++ Program to find the``// minimum length string``// consisting of all``// permutations of length N``// of D digits``#include ``using` `namespace` `std;` `// Initialize set to see``// if all the possible``// permutations are present``// in the min length string``set visited;` `// To keep min length string``string ans;` `// Generate the required string``void` `dfs(string curr, ``int` `D)``{``    ``// Iterate over all the possible``    ``// character``    ``for` `(``int` `x = 0; x < D; ++x) {``        ``char` `chr = x + ``'0'``;` `        ``// Append to make a new string``        ``string neighbour = curr + chr;``        ``// If the new string is not``        ``// visited` `        ``if` `(visited.find(neighbour) == visited.end()) {` `            ``// Add in set``            ``visited.insert(neighbour);``            ``// Call the dfs function on``            ``// the last d characters``            ``dfs(neighbour.substr(1), D);` `            ``ans.push_back(chr);``        ``}``    ``}``}``string reqString(``int` `N, ``int` `D)``{``    ``// Base case``    ``if` `(N == 1 && D == 1)``        ``return` `"0"``;` `    ``visited.clear();``    ``ans.clear();``    ``string start;` `    ``// Append '0' n-1 times``    ``for` `(``int` `i = 0; i < N - 1; i++)``        ``start.append(``"0"``);` `    ``// Call the DFS Function``    ``dfs(start, D);` `    ``ans.append(start);``    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``int` `N = 2;``    ``int` `D = 2;``    ``cout << reqString(N, D) << ``'\n'``;``    ``return` `0;``}`

## Java

 `// Java Program to find the``// minimum length string``// consisting of all``// permutations of length N``// of D digits``import` `java.io.*;``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 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) {``            ``sb.append(``"0"``);``        ``}``        ``String start = sb.toString();``        ``// Call the DFS Function``        ``dfs(start, D);``        ``ans.append(start);` `        ``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``                ``visited.add(neighbour);``                ``// Call the dfs function on``                ``// the last d characters``                ``dfs(neighbour.substring(``1``), D);` `                ``ans.append(x);``            ``}``        ``}``    ``}``    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{` `        ``int` `N = ``2``;``        ``int` `D = ``2``;``        ``System.out.println(reqString(N, D));``    ``}``}`

## Python3

 `# Python3 Program to find the``# minimum length string``# consisting of all``# permutations of length N``# of D digits` `#  Initialize set to see``#  if all the possible``#  permutations are present``#  in the min length string``visited``=``set``()`` ` `# To keep min length string``ans``=``[]` `# Generate the required string``def` `dfs(curr, D):``  ` `    ``# Iterate over all possible character``    ``for` `c ``in` `range``(D):``        ``c ``=` `str``(c)` `        ``# Append to make a new string``        ``neighbour ``=` `curr ``+` `c` `        ``# If the new string is not visited``        ``if` `neighbour ``not` `in` `visited:` `            ``# Add in set``            ``visited.add(neighbour)``            ` `            ``# Call the dfs function on the last d characters``            ``dfs(neighbour[``1``:], D)` `            ``ans.append(c)``    ` `def` `reqString(N, D):``    ``# Base case``    ``if` `(N ``=``=` `1` `and` `D ``=``=` `1``):``        ``return` `"0"``        ` `    ``# Append '0' n-1 times``    ``start``=``'``'.join(['``0``']``*``(N ``-` `1``))` `    ``# Call the DFS Function``    ``dfs(start, D)` `    ``ans.extend([``'0'``]``*``(N ``-` `1``))``    ``return` `''.join(ans)` `if` `__name__ ``=``=` `'__main__'``:``    ``N, D ``=` `2``, ``2``    ``print``(reqString(N,D))``    ` `    ``# This code is contributed by amartyaghoshgfg.`

## Javascript

 ``

Output:

`01100`

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

My Personal Notes arrow_drop_up