String Manipulation Exercises: Enhancing Your Python SkillsString manipulation is the process of modifying a given string to create new strings or obtain specific information from the original string. It is a fundamental concept of computer programming and is widely used in various applications such as data analysis, natural language processing, and web development.
Python is a popular programming language for string manipulation, and its built-in string functions and operations make it easy to perform various tasks on strings.
In this article, we will explore a set of exercises that cover various aspects of string manipulation in Python.
These exercises will help you improve your programming skills, especially if you’re a beginner who wants to learn how to work with strings in Python. Each exercise will have its own problem statement and expected output, and we’ll provide solutions to help you check your work.
Exercise 1A: Create a string made of the first, middle, and last character
The first exercise is to create a string made of the first, middle, and last character of a given string. Here’s the problem statement:
Problem Statement: Write a Python program that takes a string as input and returns a new string made of the first, middle, and last character of the input string.
Example:
Input: “Hello World”
Output: “Her”
Solution:
To solve this problem, we can use string indexing to access the first, middle, and last character of the input string. We can calculate the position of the middle character by dividing the length of the input string by 2 and rounding down to the nearest integer.
“`python
def first_middle_last(s):
middle = len(s) // 2
return s[0] + s[middle] + s[-1]
input_string = “Hello World”
output_string = first_middle_last(input_string)
print(output_string) # Output: “Her”
“`
Exercise 2: Append new string in the middle of a given string
The second exercise is to append a new string in the middle of a given string. Here’s the problem statement:
Problem Statement: Write a Python program that takes two strings as input and returns a new string where the second string is added in the middle of the first string.
Example:
Input: “Hello World”, “Python”
Output: “Hello Python World”
Solution:
To solve this problem, we can use string concatenation to combine the substrings before and after the middle point. We can calculate the position of the middle point by dividing the length of the first string by 2 and rounding down to the nearest integer.
“`python
def append_middle(s1, s2):
middle = len(s1) // 2
return s1[:middle] + s2 + s1[middle:]
input_string_1 = “Hello World”
input_string_2 = “Python”
output_string = append_middle(input_string_1, input_string_2)
print(output_string) # Output: “Hello Python World”
“`
Exercise 3: Create a new string made of the first, middle, and last characters of each input string
The third exercise is to create a new string made of the first, middle, and last characters of each input string. Here’s the problem statement:
Problem Statement: Write a Python program that takes two strings as input and returns a new string made of the first, middle, and last characters of each input string.
Example:
Input: “Hello”, “World”
Output: “HeloWrd”
Solution:
To solve this problem, we can use string concatenation and indexing to access the first, middle, and last characters in each input string. We can calculate the position of the middle character by dividing the length of the input string by 2 and rounding down to the nearest integer.
“`python
def first_middle_last_of_all(s1, s2):
middle_1 = len(s1) // 2
middle_2 = len(s2) // 2
return s1[0] + s1[middle_1] + s1[-1] + s2[0] + s2[middle_2] + s2[-1]
input_string_1 = “Hello”
input_string_2 = “World”
output_string = first_middle_last_of_all(input_string_1, input_string_2)
print(output_string) # Output: “HeloWrd”
“`
Exercise 4: Arrange string characters such that lowercase letters should come first
The fourth exercise is to arrange string characters such that lowercase letters should come first. Here’s the problem statement:
Problem Statement: Write a Python program that takes a string as input and returns a new string in which all lowercase letters come first, followed by all uppercase letters.
Example:
Input: “hElLo”
Output: “hlEoL”
Solution:
To solve this problem, we can use two loops to iterate through the input string, adding lowercase and uppercase letters into separate strings. We can then concatenate the two strings to create the final output.
“`python
def lowercase_first(s):
lower = “”
upper = “”
for c in s:
if c.islower():
lower += c
else:
upper += c
return lower + upper
input_string = “hElLo”
output_string = lowercase_first(input_string)
print(output_string) # Output: “hlEoL”
“`
Exercise 5: Count all letters, digits, and special symbols from a given string
The fifth exercise is to count all letters, digits, and special symbols from a given string. Here’s the problem statement:
Problem Statement: Write a Python program that takes a string as input and counts the number of letters, digits, and special symbols in the input string.
Example:
Input: “Hello World! 123”
Output: Letters = 10, Digits = 3, Symbols = 3
Solution:
To solve this problem, we can use three counter variables to keep track of the number of letters, digits, and special symbols in the input string. We can then iterate through the input string and increment the counters based on the type of character.
“`python
def count_letters_digits_symbols(s):
letters = 0
digits = 0
symbols = 0
for c in s:
if c.isalpha():
letters += 1
elif c.isdigit():
digits += 1
else:
symbols += 1
return f”Letters = {letters}, Digits = {digits}, Symbols = {symbols}”
input_string = “Hello World! 123”
output_string = count_letters_digits_symbols(input_string)
print(output_string) # Output: “Letters = 10, Digits = 3, Symbols = 3”
“`
Exercise 6: Create a mixed String using the following rules
The sixth exercise is to create a mixed String using the following rules. Here’s the problem statement:
Problem Statement: Write a Python program that takes two strings as input and returns a new string that contains the first character of both strings, followed by the second character of both strings, and so on.
If one string is longer than the other, append the remaining characters of the longer string at the end of the new string. Example:
Input: “Hello”, “World”
Output: “HWeolrllod”
Solution:
To solve this problem, we can use two loops to iterate through both input strings, adding the characters alternately into a new string.
We can then append the remaining characters of the longer string to the end of the new string. “`python
def mixed_string(s1, s2):
new_string = “”
for i in range(min(len(s1), len(s2))):
new_string += s1[i] + s2[i]
new_string += s1[len(s2):] if len(s1) > len(s2) else s2[len(s1):]
return new_string
input_string_1 = “Hello”
input_string_2 = “World”
output_string = mixed_string(input_string_1, input_string_2)
print(output_string) # Output: “HWeolrllod”
“`
Exercise 7: String characters balance Test
The seventh exercise is to perform a string characters balance test.
Here’s the problem statement:
Problem Statement: Write a Python program that takes a string as input and checks whether the string’s parentheses, brackets, and braces are balanced. Example:
Input: “{[]{()}}”
Output: Balanced
Solution:
To solve this problem, we can use a stack data structure to keep track of all opening brackets.
We can then pop the stack when we encounter a closing bracket and ensure that it matches the previous opening bracket. “`python
def is_balanced(s):
stack = []
opening_brackets = [“(“, “[“, “{“]
closing_brackets = [“)”, “]”, “}”]
for c in s:
if c in opening_brackets:
stack.append(c)
elif c in closing_brackets:
if not stack:
return False
previous = stack.pop()
if opening_brackets.index(previous) != closing_brackets.index(c):
return False
return not stack
input_string = “{[]{()}}”
output_string = “Balanced” if is_balanced(input_string) else “Not Balanced”
print(output_string) # Output: “Balanced”
“`
Exercise 8: Find all occurrences of a substring in a given string by ignoring the case
The eighth exercise is to find all occurrences of a substring in a given string by ignoring the case.
Here’s the problem statement:
Problem Statement: Write a Python program that takes two strings as input and returns a list of all occurrences of the second string within the first string, ignoring the case. Example:
Input: “Hello world, Hello python, hello java”, “hello”
Output: [6, 23, 29]
Solution:
To solve this problem, we can use the `find()` method to search for all occurrences of the second string within the first string.
We can then append the index of each occurrence to a list and return it. “`python
def find_all_occurrences(s, substring):
index = 0
occurrences = []
while True:
index = s.lower().find(substring.lower(), index)
if index == -1:
break
occurrences.append(index)
index += len(substring)
return occurrences
input_string_1 = “Hello world, Hello python, hello java”
input_string_2 = “hello”
output_list = find_all_occurrences(input_string_1, input_string_2)
print(output_list) # Output: [6, 23, 29]
“`
Exercise 9: Calculate the sum and average of the digits present in a string
The ninth exercise is to calculate the sum and average of the digits present in a string.
Here’s the problem statement:
Problem Statement: Write a Python program that takes a string as input and calculates the sum and average of all the digits in the string. Example:
Input: “Hello123”
Output: Sum = 6, Average = 2.0
Solution:
To solve this problem, we can use a loop to iterate through the input string, summing all digits in the string and counting the number of digits.
We can then divide the sum by the count to obtain the average. “`python
def sum_average_digits(s):
digit_sum = 0
digit_count = 0
for c in s:
if c.isdigit():
digit_sum += int(c)
digit_count += 1
return f”Sum = {digit_sum}, Average = {digit_sum / digit_count}” if digit_count > 0 else “No digits found”
input_string = “Hello123”
output_string = sum_average_digits(input_string)
print(output_string) # Output: “Sum = 6, Average = 2.0”
“`
Exercise 10: Count the Occurrences of Each Word in a given string
The tenth exercise is to count the occurrences of each word in a given string.
Here’s the problem statement:
Problem Statement: Write a Python program that takes a string as input and returns a dictionary containing the number of occurrences of each word in the string. Example:
Input: “The quick brown fox jumps over the lazy dog”
Output: {‘The’: 1, ‘quick’: 1, ‘brown’: 1, ‘fox’: 1, ‘jumps’: 1, ‘over’: 1, ‘the’: 1, ‘lazy’: 1, ‘dog’: 1}
Solution:
To solve this problem, we can split the input string into words using the `split()` method.
We can then use a dictionary to keep track of the number of occurrences of each word in the string. “`python
def count_words(s):
words = s.split()
word_count = {}
for word in words:
if word in word_count:
word_count[word] += 1
else:
word_count[word] = 1
return word_count
input_string = “The quick brown fox jumps over the lazy dog”
output_dict = count_words(input_string)
print(output_dict) # Output: {‘The’: 1, ‘quick’: 1, ‘brown’: 1, ‘fox’: 1, ‘jumps’: 1, ‘over’: 1, ‘the’: 1, ‘lazy’: 1, ‘dog’: 1}
“`
Exercise 11: Reverse a given string
The eleventh exercise is to reverse a given string.
Here’s the problem statement:
Problem Statement: Write a Python program that takes a string as input and returns a reversed string. Example:
Input: “Hello”
Output: “olleH”
Solution:
To solve this problem, we can use slicing to reverse the original string.
“`python
def reverse_string(s):
return s[::-1]
input_string = “Hello”
output_string = reverse_string(input_string)
print(output_string) # Output: “olleH”
“`
Exercise 12: Find the last position of a given substring
The twelfth exercise is to find the last position of a given substring. Here’s the problem statement:
Problem Statement: Write a Python program that takes two strings as input and returns the last position of the second string within the first string.
Example:
Input: “Hello world, Hello python, hello java”, “hello”
Output: 35
Solution:
To solve this problem, we can use the `rfind()` method to find the last occurrence of the second string within the first string. “`python
def last_position(s, substring):
return s.rfind(substring)
input_string_1 = “Hello world, Hello python, hello java”
input_string_2 = “hello”
output_integer = last_position(input_string_1, input_string_2)
print(output_integer) # Output: 35
“`
Exercise 13: Split a string on hyphens
The thirteenth exercise is to split a string on hyphens.
Here’s the problem statement:
Problem Statement: Write a Python program that takes a string as input and splits the string on hyphens. Example:
Input: “Hello-world-python”
Output: [‘Hello’, ‘world’, ‘python’]
Solution:
To solve this problem, we can use the `split()` method to split the input string on hyphens.
“`python
def split_on_hyphens(s):
return s.split(“-“)
input_string = “Hello-world