# 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)