Generate all passwords from given character set

24 Feb, 2022
Given a set of characters generate all possible passwords from them. This means we should generate all possible permutations of words using the given characters, with repetitions and also upto a given length. Examples:  
Input : arr[] = {a, b}, 
          len = 2.
Output :
a b aa ab ba bb
 
The solution is to use recursion on the given character array. The idea is to pass all possible lengths and an empty string initially to a helper function. In the helper function we keep appending all the characters one by one to the current string and recur to fill the remaining string till the desired length is reached.It can be better visualized using the below recursion tree: 
        (a, b)
         /   \
        a     b
       / \   / \
      aa  ab ba bb
Following is the implementation of the above method. 
C++
Java
Python 3
C#
Javascript
// C++ program to generate all passwords for given characters#include <bits/stdc++.h>using namespace std; // int cnt; // Recursive helper function, adds/removes characters// until len is reachedvoid generate(char* arr, int i, string s, int len){    // base case    if (i == 0) // when len has been reached    {        // print it out        cout << s << "\n";        // cnt++;        return;    }     // iterate through the array    for (int j = 0; j < len; j++) {         // Create new string with next character        // Call generate again until string has        // reached its len        string appended = s + arr[j];        generate(arr, i - 1, appended, len);    }     return;} // function to generate all possible passwordsvoid crack(char* arr, int len){    // call for all required lengths    for (int i = 1; i <= len; i++) {        generate(arr, i, "", len);    }} // driver functionint main(){    char arr[] = { 'a', 'b', 'c' };    int len = sizeof(arr) / sizeof(arr[0]);    crack(arr, len);     //cout << cnt << endl;    return 0;}// This code is contributed by Satish Srinivas.
// Java program to generate all passwords for given charactersimport java.util.*; class GFG{     // int cnt;    // Recursive helper function, adds/removes characters    // until len is reached    static void generate(char[] arr, int i, String s, int len)    {        // base case        if (i == 0) // when len has been reached        {            // print it out            System.out.println(s);                         // cnt++;            return;        }         // iterate through the array        for (int j = 0; j < len; j++)        {             // Create new string with next character            // Call generate again until string has            // reached its len            String appended = s + arr[j];            generate(arr, i - 1, appended, len);        }         return;    }     // function to generate all possible passwords    static void crack(char[] arr, int len)    {        // call for all required lengths        for (int i = 1; i <= len; i++)        {            generate(arr, i, "", len);        }    }     // Driver code    public static void main(String[] args)    {        char arr[] = {'a', 'b', 'c'};        int len = arr.length;        crack(arr, len);    } } // This code has been contributed by 29AjayKumar
# Python3 program to# generate all passwords# for given characters # Recursive helper function,# adds/removes characters# until len is reacheddef generate(arr, i, s, len):     # base case    if (i == 0): # when len has                 # been reached             # print it out        print(s)        return         # iterate through the array    for j in range(0, len):         # Create new string with        # next character Call        # generate again until        # string has reached its len        appended = s + arr[j]        generate(arr, i - 1, appended, len)     return # function to generate# all possible passwordsdef crack(arr, len):     # call for all required lengths    for i in range(1 , len + 1):        generate(arr, i, "", len)     # Driver Codearr = ['a', 'b', 'c' ]len = len(arr)crack(arr, len) # This code is contributed by Smita.
// C# program to generate all passwords for given charactersusing System;     class GFG{     // int cnt;    // Recursive helper function, adds/removes characters    // until len is reached    static void generate(char[] arr, int i, String s, int len)    {        // base case        if (i == 0) // when len has been reached        {            // print it out            Console.WriteLine(s);                         // cnt++;            return;        }         // iterate through the array        for (int j = 0; j < len; j++)        {             // Create new string with next character            // Call generate again until string has            // reached its len            String appended = s + arr[j];            generate(arr, i - 1, appended, len);        }         return;    }     // function to generate all possible passwords    static void crack(char[] arr, int len)    {        // call for all required lengths        for (int i = 1; i <= len; i++)        {            generate(arr, i, "", len);        }    }     // Driver code    public static void Main(String[] args)    {        char []arr = {'a', 'b', 'c'};        int len = arr.Length;        crack(arr, len);    } } /* This code contributed by PrinciRaj1992 */
<script>// JavaScript program to generate all passwords for given characters     // let cnt;    // Recursive helper function, adds/removes characters    // until len is reached    function generate(arr, i, s, len)    {        // base case        if (i == 0) // when len has been reached        {            // print it out            document.write(s + "<br/>");                           // cnt++;            return;        }           // iterate through the array        for (let j = 0; j < len; j++)        {               // Create new string with next character            // Call generate again until string has            // reached its len            let appended = s + arr[j];            generate(arr, i - 1, appended, len);        }           return;    }       // function to generate all possible passwords    function crack(arr, len)    {        // call for all required lengths        for (let i = 1; i <= len; i++)        {            generate(arr, i, "", len);        }    }   // Driver Code         let arr = ['a', 'b', 'c'];        let len = arr.length;        crack(arr, len);                 </script>
Output:  
a
b
c
aa
ab
ac
ba
bb
bc
ca
cb
cc
aaa
aab
aac
aba
abb
abc
aca
acb
acc
baa
bab
bac
bba
bbb
bbc
bca
bcb
bcc
caa
cab
cac
cba
cbb
cbc
cca
ccb
ccc
If we want to see the count of the words, we can uncomment the lines having cnt variable in the code. We can observe that it comes out to be , where n = len. Thus the time complexity of the program is also , hence exponential. We can also check for a particular password while generating and break the loop and return if it is found. We can also include other symbols to be generated and if needed remove duplicates by preprocessing the input using a HashTable.This article is contributed by Satish Srinivas. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
Smitha Dinesh Semwal
29AjayKumar
princiraj1992
susmitakundugoaldanga
saurabh1990aror
simranarora5sos
Combinatorial
Recursion
Recursion
Combinatorial
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Count of subsets with sum equal to X
Find the K-th Permutation Sequence of first N natural numbers
Count Derangements (Permutation such that no element appears in its original position)
Stack Permutations (Check if an array is stack permutation of other)
Find the Number of Permutations that satisfy the given condition in an array
Given an array A[] and a number x, check for pair in A[] with sum as x (aka Two Sum)
Recursion
Program for Tower of Hanoi
Backtracking | Introduction
Print all subsequences of a string