# Permute a string by changing case

• Difficulty Level : Hard
• Last Updated : 14 Nov, 2022

Print all permutations of a string keeping the sequence but changing cases.

Examples:

```Input : ab
Output : AB Ab ab aB

Input : ABC
Output : abc Abc aBc ABc abC AbC aBC ABC```

Method 1 (Naive) : Naive approach would be to traverse the whole string and for every character, consider two cases, (1) change case and recur (2) Do not change case and recur.

## C++

 `// CPP code to print all permutations` `// with respect to cases` `#include ` `using` `namespace` `std;`   `// Function to generate permutations` `void` `permute(string ip, string op)` `{` `    ``// base case` `    ``if` `(ip.size() == 0) {` `        ``cout << op << ``" "``;` `        ``return``;` `    ``}` `    ``// pick lower and uppercase` `    ``char` `ch = ``tolower``(ip[0]);` `    ``char` `ch2 = ``toupper``(ip[0]);` `    ``ip = ip.substr(1);`   `    ``permute(ip, op + ch);` `    ``permute(ip, op + ch2);` `}`   `// Driver code` `int` `main()` `{` `    ``string ip = ``"aB"``;` `    ``permute(ip, ``""``);` `    ``return` `0;` `}`

## Java

 `// Java code to print all permutations` `// with respect to cases` `import` `java.util.*;`   `class` `GFG` `{` `  ``// Function to generate permutations` `  ``static` `void` `permute(String ip, String op)` `  ``{` `    ``// base case` `    ``if``(ip.length() == ``0``){` `      ``System.out.print(op + ``" "``);` `      ``return``;` `    ``}` `    ``// pick lower and uppercase` `    ``String ch = (``""` `+ ip.charAt(``0``)).toLowerCase();` `    ``String ch2 = (``""` `+ ip.charAt(``0``)).toUpperCase();` `    ``ip = ip.substring(``1``, ip.length()) ;`   `    ``permute(ip, op + ch);` `    ``permute(ip, op + ch2);` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``String ip = ``"aB"` `;` `    ``permute(ip,``""``);` `  ``}`   `}`   `// This code is contributed by phasing17`

## Python3

 `# Python code to print all permutations` `# with respect to cases`   `# function to generate permutations`     `def` `permute(ip, op):`   `    ``#  base case` `    ``if` `len``(ip) ``=``=` `0``:` `        ``print``(op, end``=``" "``)` `        ``return`   `    ``#  pick lower and uppercase` `    ``ch ``=` `ip[``0``].lower()` `    ``ch2 ``=` `ip[``0``].upper()` `    ``ip ``=` `ip[``1``:]` `    ``permute(ip, op``+``ch)` `    ``permute(ip, op``+``ch2)`   `# driver code`     `def` `main():` `    ``ip ``=` `"AB"` `    ``permute(ip, "")`     `main()`   `# This Code is Contributed by Vivek Maddeshiya`

## C#

 `// C# code to print all permutations` `// with respect to cases`   `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG` `{` `  ``// Function to generate permutations` `  ``static` `void` `permute(``string` `ip, ``string` `op)` `  ``{` `    ``// base case` `    ``if``(ip.Length == 0){` `      ``Console.Write(op + ``" "``);` `      ``return``;` `    ``}` `    ``// pick lower and uppercase` `    ``string` `ch = (``""` `+ ip[0]).ToLower();` `    ``string` `ch2 = (``""` `+ ip[0]).ToUpper();` `    ``ip = ip.Substring(1) ;`   `    ``permute(ip, op + ch);` `    ``permute(ip, op + ch2);` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `Main(``string``[] args)` `  ``{` `    ``string` `ip = ``"aB"` `;` `    ``permute(ip,``""``);` `  ``}`   `}`   `// This code is contributed by phasing17`

## Javascript

 ``

Output

`ab aB Ab AB `

Note: Recursion will generate output in this order only.

Time Complexity: O(n*2n))
Auxiliary Space: O(n)

Method 2: For a string of length n there exist 2n maximum combinations. We can represent this as a bitwise operation.
The same idea is discussed in Print all subsequences.

Below is the implementation of the above idea :

## C++

 `// CPP code to print all permutations` `// with respect to cases` `#include ` `using` `namespace` `std;`   `// Function to generate permutations` `void` `permute(string input)` `{` `    ``int` `n = input.length();`   `    ``// Number of permutations is 2^n` `    ``int` `max = 1 << n;`   `    ``// Converting string to lower case` `    ``transform(input.begin(), input.end(), input.begin(),` `              ``::``tolower``);` `    ``// Using all subsequences and permuting them` `    ``for` `(``int` `i = 0; i < max; i++) {`   `        ``// If j-th bit is set, we convert it to upper case` `        ``string combination = input;` `        ``for` `(``int` `j = 0; j < n; j++)` `            ``if` `(((i >> j) & 1) == 1)` `                ``combination[j] = ``toupper``(input.at(j));`   `        ``// Printing current combination` `        ``cout << combination << ``" "``;` `    ``}` `}`   `// Driver code` `int` `main()` `{` `    ``permute(``"ABC"``);` `    ``return` `0;` `}`

## Java

 `// Java program to print all permutations` `// with respect to cases`   `public` `class` `PermuteString {` `    ``// Function to generate permutations` `    ``static` `void` `permute(String input)` `    ``{` `        ``int` `n = input.length();`   `        ``// Number of permutations is 2^n` `        ``int` `max = ``1` `<< n;`   `        ``// Converting string to lower case` `        ``input = input.toLowerCase();`   `        ``// Using all subsequences and permuting them` `        ``for` `(``int` `i = ``0``; i < max; i++) {` `            ``char` `combination[] = input.toCharArray();`   `            ``// If j-th bit is set, we convert it to upper` `            ``// case` `            ``for` `(``int` `j = ``0``; j < n; j++) {` `                ``if` `(((i >> j) & ``1``) == ``1``)` `                    ``combination[j]` `                        ``= (``char``)(combination[j] - ``32``);` `            ``}`   `            ``// Printing current combination` `            ``System.out.print(combination);` `            ``System.out.print(``"   "``);` `        ``}` `    ``}`   `    ``// Driver Program to test above function` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``permute(``"ABC"``);` `    ``}` `}`   `// This code is contributed by Sumit Ghosh`

## Python

 `# Python code to print all permutations` `# with respect to cases`   `# Function to generate permutations`     `def` `permute(inp):` `    ``n ``=` `len``(inp)`   `    ``# Number of permutations is 2^n` `    ``mx ``=` `1` `<< n`   `    ``# Converting string to lower case` `    ``inp ``=` `inp.lower()`   `    ``# Using all subsequences and permuting them` `    ``for` `i ``in` `range``(mx):` `        ``# If j-th bit is set, we convert it to upper case` `        ``combination ``=` `[k ``for` `k ``in` `inp]` `        ``for` `j ``in` `range``(n):` `            ``if` `(((i >> j) & ``1``) ``=``=` `1``):` `                ``combination[j] ``=` `inp[j].upper()`   `        ``temp ``=` `""` `        ``# Printing current combination` `        ``for` `i ``in` `combination:` `            ``temp ``+``=` `i` `        ``print` `temp,`     `# Driver code` `permute(``"ABC"``)`   `# This code is contributed by Sachin Bisht`

## C#

 `// C# program to print all permutations` `// with respect to cases` `using` `System;`   `class` `PermuteString {`   `    ``// Function to generate` `    ``// permutations` `    ``static` `void` `permute(String input)` `    ``{` `        ``int` `n = input.Length;`   `        ``// Number of permutations is 2^n` `        ``int` `max = 1 << n;`   `        ``// Converting string` `        ``// to lower case` `        ``input = input.ToLower();`   `        ``// Using all subsequences` `        ``// and permuting them` `        ``for` `(``int` `i = 0; i < max; i++) {` `            ``char``[] combination = input.ToCharArray();`   `            ``// If j-th bit is set, we` `            ``// convert it to upper case` `            ``for` `(``int` `j = 0; j < n; j++) {` `                ``if` `(((i >> j) & 1) == 1)` `                    ``combination[j]` `                        ``= (``char``)(combination[j] - 32);` `            ``}`   `            ``// Printing current combination` `            ``Console.Write(combination);` `            ``Console.Write(``" "``);` `        ``}` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main() { permute(``"ABC"``); }` `}`   `// This code is contributed by Nitin Mittal.`

## PHP

 `> ``\$j``) & 1) == 1)` `                ``\$combination``[``\$j``] = ``chr``(ord(``\$combination``[``\$j``]) - 32);` `        ``}` `        `  `        ``// Printing current combination` `        ``echo` `\$combination` `. ``" "``;` `    ``}` `}`   `// Driver Code` `permute(``"ABC"``);`   `// This code is contributed by mits` `?>`

## Javascript

 ``

Output

`abc Abc aBc ABc abC AbC aBC ABC `

Time complexity: O(n*2n) , since we are running a nested loop of size n inside a loop of size 2n.
Auxiliary Space: O(n)

This article is contributed by Aarti_Rathi and Rohit Thapliyal. 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.

My Personal Notes arrow_drop_up
Related Articles