# Mastering String Manipulation: 13 Python Exercises to Boost Your Skills

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 + 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 + s1[middle_1] + s1[-1] + s2 + 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.

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