📚 Index of Challenges
Converting an Integer into Decimals
Convert a standard integer into a precise decimal object to prevent binary floating-point representation issues.
decimal.Decimal class implements fixed and floating-point arithmetic with
user-controlled precision limits.
# Python 3 Solution
import decimal
integer_value = 10
decimal_value = decimal.Decimal(integer_value)
print(decimal_value)
print(type(decimal_value))
# Output:
# 10
# <class 'decimal.Decimal'>
Converting a String of Integers into Decimals
Safely convert a string representation of an integer value into a high-precision decimal representation.
# Python 3 Solution
import decimal
numeric_str = "12345"
decimal_output = decimal.Decimal(numeric_str)
print(decimal_output)
print(type(decimal_output))
# Output:
# 12345
# <class 'decimal.Decimal'>
Reversing a String using Slicing
Reverse a string cleanly without loops using extended slicing parameters.
[start:stop:step]. Passing a step of
-1 tells Python to traverse the string backward from the end to the beginning in a
single pass.
# Python 3 Solution
sample_string = "Python Programming"
reversed_string = sample_string[::-1]
print(reversed_string)
# Output:
# gnimmargorP nohtyP
Counting Vowels in a Given Word
Count the occurrences of vowels in a word using membership checking. We compare both a basic loop and a clean generator expression.
# Python 3 Solution
vowels = {'a', 'e', 'i', 'o', 'u'}
target_word = "programming"
# 1. Procedural loop method:
count_loop = 0
for char in target_word.lower():
if char in vowels:
count_loop += 1
# 2. Optimized generator method:
count_gen = sum(1 for char in target_word.lower() if char in vowels)
print(f"Vowel Count: {count_gen}")
# Output:
# Vowel Count: 3
Counting Consonants in a Given Word
Count the number of non-vowel, alphabetical characters in a word.
# Python 3 Solution
vowels = {'a', 'e', 'i', 'o', 'u'}
target_word = "programming"
# Count alphabetical characters that are not in the vowel set:
consonant_count = sum(
1 for char in target_word.lower()
if char.isalpha() and char not in vowels
)
print(f"Consonant Count: {consonant_count}")
# Output:
# Consonant Count: 8
Counting Occurrences of a Character in a String
Count how many times a target character appears inside a string.
# Python 3 Solution
word = "python"
target_char = "p"
# Python's built-in count() runs in compiled C and is highly optimized:
occurrences = word.count(target_char)
print(f"Occurrences: {occurrences}")
# Output:
# Occurrences: 1
Generating the Fibonacci Series
Compute and format the Fibonacci Sequence using relative negative indexing lookup speeds.
# Python 3 Solution
fib_sequence = [0, 1]
# Generate the next 5 elements:
for _ in range(5):
# fib_sequence[-1] and fib_sequence[-2] look up the last two values in O(1) time
fib_sequence.append(fib_sequence[-1] + fib_sequence[-2])
# Join elements with a comma:
output_str = ", ".join(str(val) for val in fib_sequence)
print(output_str)
# Output:
# 0, 1, 1, 2, 3, 5, 8
Finding the Maximum Number in a List
Locate the largest number in a list of integers without using
Python's built-in max() helper.
# Python 3 Solution
numbers = [15, 85, 35, 89, 125]
# Assume the first element is the largest:
max_val = numbers[0]
for num in numbers:
if num > max_val:
max_val = num
print(f"Maximum: {max_val}")
# Output:
# Maximum: 125
Finding the Minimum Number in a List
Locate the smallest value in an array without using the built-in
min() function.
# Python 3 Solution
numbers = [15, 85, 35, 89, 125, 2]
min_val = numbers[0]
for num in numbers:
if num < min_val:
min_val = num
print(f"Minimum: {min_val}")
# Output:
# Minimum: 2
Finding the Middle Element in a List
Locate and extract the middle item of a list using floor division to handle even/odd boundaries cleanly.
# Python 3 Solution
num_list = [1, 2, 3, 4, 5]
# Floor division // returns a clean integer index
middle_index = len(num_list) // 2
print(f"Middle Element: {num_list[middle_index]}")
# Output:
# Middle Element: 3
Converting a List into a String
Join a list of characters or strings into a single consolidated string.
str.join() instead of a loop with
+=. join() calculates the required memory up front and performs the
concatenation in a single $O(n)$ step.
# Python 3 Solution
chars_list = ["P", "Y", "T", "H", "O", "N"]
result_str = "".join(chars_list)
print(result_str)
print(type(result_str))
# Output:
# PYTHON
# <class 'str'>
Dynamic Pairwise List Addition
Add corresponding elements of two lists together. We compare a
basic range loop with an elegant list comprehension using zip().
# Python 3 Solution
list1 = [1, 2, 3]
list2 = [4, 5, 6]
# 1. Procedural loop:
pairwise_sum_loop = []
for i in range(len(list1)):
pairwise_sum_loop.append(list1[i] + list2[i])
# 2. Optimized Pythonic approach using zip():
pairwise_sum_zip = [a + b for a, b in zip(list1, list2)]
print(pairwise_sum_zip)
# Output:
# [5, 7, 9]
Comparing Two Strings for Anagrams
Determine if two strings are anagrams of each other (contain the same characters in a different order) by sorting their characters.
# Python 3 Solution
string1 = "Listen"
string2 = "Silent"
# Normalize case and sort the characters:
sorted_str1 = sorted(string1.upper())
sorted_str2 = sorted(string2.upper())
is_anagram = (sorted_str1 == sorted_str2)
print(is_anagram)
# Output:
# True
Checking for Palindromes
Verify if a word is a palindrome (reads the same forward and backward) using string reversing slicing.
# Python 3 Solution
input_word = "Kayak"
# Normalize the string:
clean_word = input_word.lower()
# Compare the string with its reversed slice:
is_palindrome = (clean_word == clean_word[::-1])
print(is_palindrome)
# Output:
# True
Counting Whitespaces in a String
Count the occurrences of space characters inside a string.
# Python 3 Solution
text_line = "P r ogramm in g "
# Use the built-in str.count() method:
space_count = text_line.count(' ')
print(space_count)
# Output:
# 5
Counting Digits, Letters, and Spaces inside a String
Parse a string to calculate the number of digits, letters, and space characters it contains.
# Python 3 Solution
import re
text_input = 'Python is 1'
# 1. Regex approach:
digit_chars = re.sub(r"[^0-9]", "", text_input)
letter_chars = re.sub(r"[^a-zA-Z]", "", text_input)
space_chars = re.findall(r"\s", text_input)
print(f"Digits: {len(digit_chars)} | Letters: {len(letter_chars)} | Spaces: {len(space_chars)}")
# 2. Optimized, clean Pythonic approach using generator expressions:
digits_count = sum(1 for char in text_input if char.isdigit())
letters_count = sum(1 for char in text_input if char.isalpha())
spaces_count = sum(1 for char in text_input if char.isspace())
# Output:
# Digits: 1 | Letters: 8 | Spaces: 2
Counting Special Characters in a String
Determine the count of special characters by filtering out alphanumeric characters and spaces.
# Python 3 Solution
special_char_str = "!@#$%^&*()"
# Check for characters that are not alphanumeric and not whitespace:
special_count = sum(1 for char in special_char_str if not char.isalnum() and not char.isspace())
print(special_count)
# Output:
# 10
Removing All Whitespace in a String
Strip all whitespaces (spaces, tabs, newlines) from a string.
# Python 3 Solution
import re
spaced_str = "C O D E"
# 1. Using regular expressions:
pattern = re.compile(r'\s+')
clean_regex = re.sub(pattern, '', spaced_str)
# 2. Faster native alternative:
clean_native = "".join(spaced_str.split())
print(clean_native)
# Output:
# CODE
Building a Centered Pyramid
Construct a visually centered star pyramid using string formatting parameters.
'{:^{}}' centers a string value
(first argument) inside a field of a specified width (second argument).
# Python 3 Solution
floors = 3
total_width = 2 * floors - 1
for i in range(1, 2 * floors, 2):
# Center stars based on calculated width:
print('{:^{}}'.format('*' * i, total_width))
# Output:
# * # *** # *****
Shuffling List Elements In-Place
Randomize the order of items in a list using an in-place shuffle operation.
# Python 3 Solution
from random import shuffle
tech_list = ['Python', 'is', 'Easy']
# shuffle() mutates the list in-place and returns None:
shuffle(tech_list)
print(tech_list)
# Output (will vary due to randomization):
# ['Easy', 'is', 'Python']