Case conversion (Lower to Upper and Vice Versa) of a string using BitWise operators in C/C++

Given a string, write a function that converts it either from lower to upper case or from upper to lower case using the bitwise operators &(AND), |(OR), ~(NOT) in place and returns the string. Many of us know that Bitwise manipulations are faster than performing arithmetic operations for a compiler as the data is stored in binary form 0's and 1's. Examples:

Input : "LowerToUpPer"
Output : "LOWERTOUPPER"
   Letters already in the uppercase remains the same. 
   while rest get converted to uppercase.

Input : "UPPerTOloweR"
Output : "uppertolower"
   Letters already in the lowercase remains the same.
   while rest get converted to lowercase.

1.Lower to Upper Case This method simply subtracts a value of 32 from the ASCII value of lowercase letter by Bitwise ANDing (&) with negation (~) of 32 converting the letter to uppercase. 

Implementation:

// C++ program to convert a string from 
// lower to upper case. 
#include<stdio.h> 

const int x = 32; 

// Converts a string to uppercase 
char *toUpperCase(char *a) 
{ 
    for (int i=0; a[i]!='\0'; i++) 
        a[i] = a[i] & ~x; 

    return a; 
} 

// Driver Code 
int main() 
{ 
    char str[] = "SanjaYKannA"; 

    //Here it's recommended to use character array 
    //as it's stored in read-write area. 
    //If a pointer is used it's stored 
    //in read-only memory as a string literal. 

    printf("%s", toUpperCase(str)); 

    return 0; 
} 

public class Main {

    static final int x = 32;

    // Converts a string to uppercase
    static String toUpperCase(String a) {
        char[] chars = a.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            chars[i] = (char) (chars[i] & ~x);
        }
        return new String(chars);
    }

    // Driver Code
    public static void main(String[] args) {
        String str = "SanjaYKannA";

        // Here it's recommended to use a String
        // as it's stored in the heap area.
        // If a char array is used, it's stored
        // in the stack as a string literal.

        System.out.print(toUpperCase(str));
    }
}

def to_upper_case(s):
    result = ""
    for char in s:
        if 'a' <= char <= 'z':
            result += chr(ord(char) & ~32)
        else:
            result += char
    return result

# Driver code
str = "SanjaYKannA"
print(to_upper_case(str))

// Converts a string to uppercase
function toUpperCase(str) {
    let result = '';
    const x = 32; // ASCII difference between uppercase and lowercase letters
    for (let i = 0; i < str.length; i++) {
        const charCode = str.charCodeAt(i);
        // Convert lowercase letters to uppercase by adding the ASCII difference
        // Note: this assumes the input string only contains lowercase letters
        result += String.fromCharCode(charCode & ~x);
    }
    return result;
}

// Driver Code
function main() {
    const str = "SanjaYKannA";
    console.log(toUpperCase(str));
}

main();

SANJAYKANNA

Time complexity : O(n) 
Auxiliary Space : O(1) 

2.Upper to Lower Case Similarly, it adds a value of 32 to the ASCII value of uppercase letter by Bitwise ORing (|) with 32 converting the letter to lowercase. 

Implementation:

// C++ program to convert a string from 
// upper to lower case. 
#include<stdio.h> 
const int x = 32; 

// Converts a string to lowercase 
char * toLowerCase(char *a) 
{ 
    for (int i=0; a[i]!='\0'; i++) 
        a[i] = a[i] | x; 

    return a; 
} 

// Driver Code 
int main() 
{ 
    char str[] = "SanjaYKannA"; 
    printf("%s", toLowerCase(str)); 
    return 0; 
} 

public class Main {
    // Constant value for converting uppercase to lowercase
    static final int x = 32;

    // Converts a string to lowercase
    static String toLowerCase(String str) {
        char[] chars = str.toCharArray();
        // Iterate through each character in the string
        for (int i = 0; i < chars.length; i++) {
            // Check if the character is an uppercase letter
            if (Character.isUpperCase(chars[i])) {
                // Convert the uppercase letter to lowercase using ASCII manipulation
                chars[i] = (char) (chars[i] | x);
            }
        }
        // Convert the character array back to a string and return
        return new String(chars);
    }

    // Main method
    public static void main(String[] args) {
        // Input string
        String str = "SanjaYKannA";
        // Convert the string to lowercase and print
        System.out.println(toLowerCase(str));
    }
}

# code
def gfg(string):
    # Initialize an empty string to store the lowercase result
    result = ''
    # Loop through each character in the input string
    for char in string:
        # Check if the character is uppercase
        if 'A' <= char <= 'Z':
            result += chr(ord(char) + 32)
        else:
            # If the character is not uppercase, add it to the result as it is
            result += char
    # Return the resulting lowercase string
    return result

# Test the function
string = "SanjaYKannA"
print(gfg(string))

function GFG(str) {
    // Initialize an empty string to the store the lowercase result
    let result = '';
    // Loop through each character in input string
    for (let i = 0; i < str.length; i++) {
        // Check if the character is uppercase
        if (str[i] >= 'A' && str[i] <= 'Z') {
            result += String.fromCharCode(str.charCodeAt(i) + 32);
        } else {
            // If the character is not uppercase, add it to result as it is
            result += str[i];
        }
    }
    // Return the resulting lowercase string
    return result;
}
// Test the function
let str = "SanjaYKannA";
console.log(GFG(str));

sanjaykanna

Time complexity : O(n) 
Auxiliary Space : O(1) 

Explanation: The ASCII table is constructed in such way that the binary representation of lowercase letters is almost identical of binary representation of uppercase letters. Character ‘A’ is integer 65 = (0100 0001)2, while character ‘a’ is integer 97 = (0110 0001)2. The difference between the ASCII values of 'a' and 'A' is 32. So we can easily change the case of the letters either from Upper to lower or lower to upper by adding or subtracting the difference from the letters using bitwise operators as shown above. 

Exercise: Implement a function that change the case of a string such that GeeksFoRgeekS turns gEEKSfOrGEEKs .