Permute a string by changing case

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 <bits/stdc++.h>
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

<script>

// JavaScript code to print all permutations
// with respect to cases

// Function to generate permutations
function permute(ip, op)
{
    // base case
    if(ip.length == 0){
        document.write(op," ");
        return;
    }
    // pick lower and uppercase
    let ch = ip[0].toLowerCase();
    let ch2 = ip[0].toUpperCase();
    ip = ip.substring(1) ;

    permute(ip, op + ch);
    permute(ip, op + ch2);
}

// Driver code

let ip = "aB" ;
permute(ip,"");

// This code is contributed by shinjanpatra

</script>

Output

ab aB Ab AB 

Note: Recursion will generate output in this order only. 

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

Method 2: For a string of length n there exist 2ⁿ 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 <bits/stdc++.h>
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

<?php
// PHP program to print all permutations
// with respect to cases

// Function to generate permutations
function permute($input)
{
    $n = strlen($input);

    // Number of permutations is 2^n
    $max = 1 << $n;

    // Converting string to lower case
    $input = strtolower($input);

    // Using all subsequences and permuting them
    for($i = 0; $i < $max; $i++)
    {
        $combination = $input;

        // If j-th bit is set, we convert
        // it to upper case
        for($j = 0; $j < $n; $j++)
        {
            if((($i >> $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

<script>

// javascript program to print all permutations
// with respect to cases


// Function to generate permutations
function permute(input)
{
    var n = input.length;

    // Number of permutations is 2^n
    var max = 1 << n;

    // Converting string to lower case
    input = input.toLowerCase();

    // Using all subsequences and permuting them
    for(var i = 0;i < max; i++)
    {
        var combination = input.split('');

        // If j-th bit is set, we convert it to upper case
        for(var j = 0; j < n; j++)
        {
            if(((i >> j) &  1) == 1)
                combination[j] = String.fromCharCode(combination[j].charCodeAt(0)-32);
        }

        // Printing current combination
        document.write(combination.join(''));
        document.write("   ");
    }
}

// Driver Program to test above function
permute("ABC");

// This code contributed by Princi Singh
</script>

Output

abc Abc aBc ABc abC AbC aBC ABC 

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

Asked in : Facebook.

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.