Skip to content
Related Articles

Related Articles

Permute a string by changing case

Improve Article
Save Article
  • Difficulty Level : Hard
  • Last Updated : 14 Nov, 2022
Improve Article
Save Article

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*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 <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*2n) , since we are running a nested loop of size n inside a loop of size 2n.
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. 


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!