Permute a string by changing case
Last Updated :
13 Apr, 2024
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>
Note: Recursion will generate output in this order only.
Time Complexity: O(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.
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>
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
?>
Outputabc 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.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...