Python – Uppercase Half String

Given a String, perform uppercase of the later part of the string.

Input : test_str = 'Lazyroarforgeek' 
Output : LazyroarfORGEEK 
Explanation : Latter half of string is uppercased. 

Input : test_str = 'apples' 
Output : appLES 
Explanation : Latter half of string is uppercased.

Method #1 : Using upper() + loop + len()

In this, we compute the half index and then perform upper() to only those characters which lie in the other half of the string.

The original string is : neveropen
The resultant string : LazyroarfORGEEKS

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

Method #2 : Using list comprehension + join() + upper()

This is similar to the above method, just the task is performed in a shorthand manner using list comprehension.

The original string is : neveropen
The resultant string : LazyroarfORGEEKS

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

Method#3: Using String slicing and upper()

Use string slicing to divide the string into two separate sub_string and convert the right sub_string to the upper case with upper() method. 

The original string is : neveropen
The resultant string : LazyroarfORGEEKS

Time Complexity: O(n) -> (slicing)
Auxiliary Space: O(n)

Method #4 : Using slicing +index()+for loop

The original string is : neveropen
The resultant string : LazyroarfORGEEKS

Time Complexity: O(n) where n is the length of the input string.
Auxiliary Space: O(n) as we are creating a new string ‘res’ with a length equal to the length of the input string.

Method#5: using re module

Steps:

1. Import the re module.
2. Define a string to be processed, test_str.
3. Print the original string.
4. Compute the half index of the string by dividing its length by 2.
5. Extract the second half of the string using the half index.
6. Use regular expressions to convert all word characters in the second half of the string to uppercase.
7. a. Use (?i) to set the regular expression to case-insensitive mode.
8. b. Use \w+ to match all word characters in the string.
9. c. Use a lambda function to convert each match to uppercase using the group() method of the match object.
10. d. Replace all matches in the second half of the string with their uppercase equivalents using re.sub().
11. Concatenate the first half of the string with the modified second half to create the result string.
12. Print the result string.

The original string is : neveropen
The resultant string : LazyroarfORGEEKS

Time complexity: O(n), where n is the length of the input string. This is because the regular expression pattern is applied to the second half of the string, which has length n/2. The time complexity of re.sub() is proportional to the length of the input string, so the overall time complexity is O(n/2 + n/2) = O(n).

Auxiliary space: O(n), where n is the length of the input string. This is because the re.sub() function creates a new string containing the modified second half of the input string, and the result string also has length n. The space used by the other variables (e.g., test_str, hlf_idx, res) is constant, regardless of the length of the input string.

Method #6: Using string concatenation and conditional operator

Steps:

1. Initialize the string variable test_str.
2. Calculate the length of the string and store it in the length variable.
3. Initialize an empty string variable result.
4. Use a for loop to iterate through the string characters.
   • Use a conditional operator to check if the index of the character is less than half of the string length.
   • If the above condition is true, concatenate the character with the result variable.
   • If the above condition is false, concatenate the uppercase of the character with the result variable.
5. Print the result variable.

Below is the implementation of the above approach:

The original string is : neveropen
The resultant string : LazyroarfORGEEKS

Time complexity: O(n), where n is the length of the input string.
Auxiliary space: O(n), as we are using an extra variable result to store the output string.

Method#7:Using itertools, islice(), and string concatenation:

Algorithm :

1. Initialize the input string test_str and compute its half index hlf_idx.
2. Use the islice function from the itertools module to iterate over the characters of test_str from the beginning until the end, and assign each character to the variable c.
3. For each character c, use a list comprehension to:
4. Check if its index i is greater than or equal to hlf_idx.
5. If so, convert the character to uppercase using the upper() method and append it to a list.
6. If not, append the character as is to the list.
7. Use the join() method to concatenate the list of characters into a new string res.
8. Print the new string res.

The original string is : neveropen
The resultant string : LazyroarfORGEEKS

Time complexity: O(n), where n is the length of the input string test_str. This is because the code iterates over the characters of the string exactly once, and each iteration takes constant time.

Auxiliary space: O(N), where n is the length of the input string test_str. This is because the code creates a list of the characters of the string and then joins them back into a string, using an additional list to hold the characters of the new string. Both the original and the new string require O(n) space. The islice object created by the islice function also requires O(1) space.

Method 8: Using built-in function map() + the ternary operator.

Steps:

1. Get the length of the string and find the half index by dividing it by 2 and using the floor division operator to get an integer value.
2. Use map() to apply the ternary operator on each character of the string. If the index of the character is greater than or equal to the half index, return the character in uppercase, otherwise return the original character.
3. Convert the map object to a string using the join() method.
4. Assign the resultant string to the variable res.
5. Print the original string and the resultant string.

The original string is : neveropen
The resultant string : LazyroarfORLazyroar

Time complexity: O(N), where n is the length of the string. 
Auxiliary space: O(N) because the new string is created in memory.