Python – Convert Snake case to Pascal case

Sometimes, while working with Python Strings, we have problem in which we need to perform a case conversion of String. This a very common problem. This can have application in many domains such as web development. Lets discuss certain ways in which this task can be performed.

Input : Lazyroar_for_Lazyroar Output : Lazyroar Input : left_index Output : leftIndex

Method #1 : Using title() + replace() This task can be solved using combination of above functions. In this, we first convert the underscore to empty string and then title case each word. 

The original string is : neveropen_is_best
The String after changing case : GeeksforLazyroarIsBest

Time Complexity: O(1)
Auxiliary Space: O(1)

  Method #2 : Using capwords() The task of performing title case is performed using capwords() in this method. 

The original string is : neveropen_is_best
The String after changing case : GeeksforLazyroarIsBest

The time complexity is O(n), where n is the length of the input string.

The auxiliary space is O(n) as well.

Method #3 : Using split(),title() and join() methods

The original string is : neveropen_is_best
The String after changing case : GeeksforLazyroarIsBest

The Time and Space Complexity for all the methods are the same:

Time Complexity: O(n)

Space Complexity: O(n)

Approach#4:  Using capitalize

The function splits the input string into words based on the underscore separator, capitalizes the first letter of each word, and then concatenates the words to form the output string in PascalCase.

Algorithm

1. Split the given string at “_” to form a list of words.
2. Capitalize the first letter of each word and join them.
3. Return the resulting string in Pascal case.

GeeksforLazyroarIsBest

Time Complexity: O(n), where n is the length of the input string.
Auxiliary Space: O(n), where n is the length of the input string.

METHOD 5: using the split() method,

APPROACH:

In this approach, we split the string by the underscore character using the split() method, capitalize the first letter of each split word using the title() method, and then join the words using the join() method.

ALGORITHM:

1.Split the string by the underscore character using the split() method.
2.Capitalize the first letter of each split word using the title() method.
3.Join the words using the join() method.
4.Return the resulting string.

GeeksforLazyroarIsBest

Time complexity: O(n), where n is the length of the input string. The split() method takes O(n) time, and the title() method takes O(m) time for each word, where m is the length of the word. The join() method takes O(n) time.

Auxiliary Space: O(n), where n is the length of the input string. The split() method creates a list of words that takes O(n) space. The capitalized_words list also takes O(n) space, and the resulting string takes O(n) space.

METHOD 6: using reduce():

1. Initialize a string variable test_str with the input string.
2. Split the test_str string into a list of words using the split() method and underscore (_) as the delimiter. Store the result in a list variable x.
3. Initialize an empty list variable res to store the capitalized words.
4. Iterate over each word in the x list using a for loop:
   a. Use the title() method to capitalize the first letter of each word, and store the result in a variable i.
   b. Append the capitalized word i to the res list.
5. Use the join() method to concatenate the capitalized words in the res list into a single string, and store the result in a string variable res.
6. Print the original string and the converted string.

The original string is : neveropen_is_best
The String after changing case : GeeksforLazyroarIsBest

The time complexity :O(n), where n is the length of the input string, because we need to iterate over each character in the string once to split it into words, and then iterate over each word once to capitalize the first letter of each word. 

The space complexity : O(n), because we need to store the input string in memory, as well as the list of words and the list of capitalized words.

Algorithm 7:

Steps:

1. Initialize an empty string “result”.
2. Initialize a boolean flag “capitalize_next_word” to True.
3. Iterate through each character in the input string.
4. If the character is an underscore, set “capitalize_next_word” to True.
5. If the character is not an underscore and “capitalize_next_word” is True, append the capitalized version of the character to “result” and set “capitalize_next_word” to False.
6. If the character is not an underscore and “capitalize_next_word” is False, append the character to “result”.
7. Return the final “result” string.

GeeksForGeeks
LeftIndex

Time Complexity: O(n), where n is the length of the input string.

Auxiliary Space: O(1), as we are using constant extra space throughout the algorithm.

Using regular expressions

Import the regex module. Define a function that takes a snake_case string as input. Use the sub() method of the regex module to replace the underscore character with an empty string and capitalize the first letter of each word. Return the resulting string.

GeeksforLazyroarIsBest

Time Complexity: O(n)

Auxiliary Space: O(n)