Course: Python Training
Topic: Practicing Python Coding, Logic, and Problem-Solving Questions
Course Link: Python Training Course at JustAcademy
Demo Registration: Register for a Course Demo
Website: Visit JustAcademy
Python coding and problem-solving involve understanding a problem, identifying the required output, designing a logical solution, and translating that solution into executable Python code. Practicing coding questions helps learners strengthen programming fundamentals, improve analytical thinking, and prepare for technical interviews and real-world software development.
Problem-solving is not only about writing code that works. A good solution should also be readable, accurate, efficient, maintainable, and capable of handling unusual inputs. Python provides convenient features such as loops, conditional statements, functions, lists, dictionaries, sets, and built-in functions that make it suitable for solving a wide variety of programming problems.
A reliable problem-solving process reduces mistakes and makes unfamiliar coding questions easier to approach.
Read the question carefully and identify the expected result. Determine what information is provided, what must be calculated, and whether any restrictions apply.
Example problem: Given a list of numbers, find the largest number without using the built-in max() function.
[12, 5, 28, 9, 17].28.max().Clearly define the data entering the program and the result it must produce. This helps determine which Python data types and operations are appropriate.
| Problem | Input | Expected Output |
|---|---|---|
| Check even or odd | 8 |
Even |
| Reverse a string | "python" |
"nohtyp" |
| Calculate factorial | 5 |
120 |
| Find largest element | [4, 9, 2] |
9 |
| Count vowels | "education" |
5 |
Divide a complex task into manageable operations. For example, a program that checks whether a number is prime can be divided into these steps:
Pseudocode describes the logic in plain language before implementation.
START
Read number
IF number is less than 2
Display "Not prime"
ELSE
Assume number is prime
Check divisors from 2 through square root of number
IF any divisor divides number evenly
Mark number as not prime
Display the result
ENDTranslate the logic into Python, test normal and unusual inputs, and then consider whether the code can be simplified or made more efficient.
Variables store references to values that a program uses during execution. Common Python data types include integers, floating-point numbers, strings, booleans, lists, tuples, sets, and dictionaries.
age = 25
price = 499.50
name = "Aarav"
is_active = True
scores = [75, 82, 91]
student = {"name": "Aarav", "age": 25}
print(type(age))
print(type(name))
print(type(scores))Choosing an appropriate data type makes a solution easier to implement and understand. For example, use a list when maintaining an ordered collection, a set when unique values are needed, and a dictionary when associating keys with values.
| Operator Category | Operators | Example |
|---|---|---|
| Arithmetic | + - * / // % ** |
17 % 5 == 2 |
| Comparison | == != > < >= <= |
10 > 4 |
| Logical | and or not |
age >= 18 and age <= 60 |
| Membership | in, not in |
"a" in "apple" |
| Assignment | = += -= *= |
count += 1 |
Conditional statements allow programs to make decisions based on conditions.
number = 14
if number % 2 == 0:
print("Even")
else:
print("Odd")Use if, elif, and else when a problem contains multiple possible outcomes. Conditions should be ordered carefully so that special cases are handled correctly.
A for loop iterates over a sequence or iterable. A while loop repeats while a condition remains true.
# Using a for loop
for number in range(1, 6):
print(number)
# Using a while loop
count = 1
while count <= 5:
print(count)
count += 1Use loops for repeated operations such as counting, summing values, searching, and processing characters. Make sure a while loop has a clear termination condition.
Functions package reusable logic into named blocks of code. They improve readability, reduce duplication, and make testing easier.
def add_numbers(a, b):
return a + b
result = add_numbers(10, 20)
print(result) # 30Prefer returning a result when other parts of the program need to use it. Printing a value displays it, whereas returning a value makes it available to the caller.
An integer is even if it is divisible by two without a remainder. Otherwise, it is odd.
def even_or_odd(number):
if number % 2 == 0:
return "Even"
return "Odd"
print(even_or_odd(10)) # Even
print(even_or_odd(7)) # OddLogic: The modulo operator % returns the remainder after division. If number % 2 equals zero, the number is even.
Complexity: O(1) time and O(1) extra space.
The factorial of a non-negative integer is the product of all positive integers from one through that number. By definition, 0! = 1.
def factorial(number):
if number < 0:
raise ValueError("Factorial is not defined for negative integers")
result = 1
for value in range(2, number + 1):
result *= value
return result
print(factorial(5)) # 120
print(factorial(0)) # 1Logic: Start with one and multiply by each integer from two to the input number. When the input is zero or one, the loop does not run and the result remains one.
Complexity: O(n) time and O(1) extra space for this iterative version.
A prime number is an integer greater than one that has exactly two positive divisors: one and itself.
from math import isqrt
def is_prime(number):
if number < 2:
return False
for divisor in range(2, isqrt(number) + 1):
if number % divisor == 0:
return False
return True
print(is_prime(7)) # True
print(is_prime(12)) # False
print(is_prime(2)) # TrueLogic: A composite number must have a factor less than or equal to its square root. Therefore, checking every number up to the square root is sufficient.
Complexity: O(√n) time and O(1) extra space.
The Fibonacci sequence begins with zero and one. Each subsequent value is the sum of the previous two values.
def fibonacci(count):
if count < 0:
raise ValueError("Count cannot be negative")
sequence = []
first, second = 0, 1
for _ in range(count):
sequence.append(first)
first, second = second, first + second
return sequence
print(fibonacci(7))
# [0, 1, 1, 2, 3, 5, 8]Logic: Keep two variables representing consecutive values. Append the first value and update both variables for the next iteration.
Complexity: O(n) time and O(n) space because the function stores the resulting sequence.
This problem calculates the sum of all digits in an integer. For example, the digits of 472 are 4, 7, and 2, so the sum is 13.
def sum_of_digits(number):
number = abs(number)
total = 0
while number > 0:
digit = number % 10
total += digit
number //= 10
return total
print(sum_of_digits(472)) # 13
print(sum_of_digits(-123)) # 6
print(sum_of_digits(0)) # 0Logic: Use % 10 to extract the last digit and // 10 to remove it. Repeat until the number becomes zero.
Complexity: O(d) time, where d is the number of digits, and O(1) extra space.
def reverse_integer(number):
sign = -1 if number < 0 else 1
number = abs(number)
reversed_number = 0
while number > 0:
digit = number % 10
reversed_number = reversed_number * 10 + digit
number //= 10
return sign * reversed_number
print(reverse_integer(1234)) # 4321
print(reverse_integer(-560)) # -65This solution reverses the digits mathematically and preserves the sign. Leading zeros in the reversed representation are not retained because the result is an integer.
A string can be reversed using slicing or by iterating over its characters.
def reverse_string(text):
return text[::-1]
print(reverse_string("python")) # nohtypThe slice [::-1] traverses the string from the end to the beginning. This is concise and useful when a direct reversed copy is required.
Complexity: O(n) time and O(n) space for the resulting string.
A palindrome reads the same forward and backward under the chosen comparison rules. Some problems ignore spaces, punctuation, and letter case; others require an exact comparison.
def is_palindrome(text):
normalized = "".join(
character.lower()
for character in text
if character.isalnum()
)
return normalized == normalized[::-1]
print(is_palindrome("Madam")) # True
print(is_palindrome("A man, a plan, a canal: Panama")) # True
print(is_palindrome("Python")) # FalseLogic: Normalize the input by retaining alphanumeric characters and converting them to lowercase. Compare the normalized string with its reverse.
def count_vowels(text):
vowels = set("aeiou")
return sum(
1 for character in text.lower()
if character in vowels
)
print(count_vowels("Education")) # 5This solution converts the text to lowercase and counts characters that belong to the vowel set. It counts English vowels only, according to the stated rule.
A dictionary is useful for counting how often each character appears.
def character_frequency(text):
frequency = {}
for character in text:
frequency[character] = frequency.get(character, 0) + 1
return frequency
print(character_frequency("banana"))
# {'b': 1, 'a': 3, 'n': 2}The dictionary's get() method returns the current count or zero when the character has not appeared before.
Anagrams contain the same characters with the same frequencies, although the character order may differ.
from collections import Counter
def are_anagrams(first, second):
first = first.replace(" ", "").lower()
second = second.replace(" ", "").lower()
return Counter(first) == Counter(second)
print(are_anagrams("listen", "silent")) # True
print(are_anagrams("hello", "world")) # FalseThis version ignores spaces and letter case but retains punctuation. If a problem specifies different normalization rules, modify the preprocessing accordingly.
def find_largest(numbers):
if not numbers:
raise ValueError("The list cannot be empty")
largest = numbers[0]
for number in numbers[1:]:
if number > largest:
largest = number
return largest
print(find_largest([12, 5, 28, 9, 17])) # 28Logic: Assume the first element is the largest, then compare each remaining element against the current largest value.
Complexity: O(n) time and O(1) extra space, excluding the small list slice used in this implementation. Iterating by index or iterator avoids creating that slice.
def second_largest(numbers):
largest = None
second = None
for number in numbers:
if largest is None or number > largest:
if number != largest:
second = largest
largest = number
elif number != largest and (
second is None or number > second
):
second = number
if second is None:
raise ValueError("At least two distinct values are required")
return second
print(second_largest([10, 5, 10, 8, 3])) # 8Logic: Maintain the largest and second-largest distinct values as the list is traversed. Duplicate occurrences of the largest value must not become the second-largest distinct value.
There are multiple ways to remove duplicates. If the original order must be preserved, use a set to track values already encountered.
def remove_duplicates(items):
seen = set()
result = []
for item in items:
if item not in seen:
seen.add(item)
result.append(item)
return result
print(remove_duplicates([1, 2, 2, 3, 1, 4]))
# [1, 2, 3, 4]This method requires the list elements to be hashable because they are stored in a set. For hashable values, the average time complexity is O(n).
def common_elements(first, second):
second_values = set(second)
return list(dict.fromkeys(
value for value in first if value in second_values
))
print(common_elements([1, 2, 3, 4], [3, 4, 5, 6]))
# [3, 4]This implementation preserves the order of the first list and returns each matching value once. It assumes the elements are hashable.
def move_zeros(numbers):
non_zeros = [number for number in numbers if number != 0]
zero_count = len(numbers) - len(non_zeros)
return non_zeros + [0] * zero_count
print(move_zeros([0, 1, 0, 3, 12]))
# [1, 3, 12, 0, 0]This approach preserves the relative order of non-zero values and places all zeros at the end. It creates a new list rather than modifying the original list.
from collections import Counter
import re
def word_frequency(sentence):
words = re.findall(r"\b\w+\b", sentence.lower())
return Counter(words)
print(word_frequency("Python is easy. Python is powerful."))
# Counter({'python': 2, 'is': 2, 'easy': 1, 'powerful': 1})This example converts text to lowercase and extracts word-like sequences before counting them. Tokenization rules can differ for languages, apostrophes, and special characters, so production applications may require more advanced text processing.
from collections import Counter
def most_frequent(items):
if not items:
raise ValueError("The list cannot be empty")
counts = Counter(items)
return counts.most_common(1)[0]
print(most_frequent(["red", "blue", "red", "green", "red"]))
# ('red', 3)most_common(1) returns the most frequent item and its count. If multiple values have the same highest frequency, define a tie-breaking rule when the problem requires one.
def merge_dictionaries(first, second):
return {**first, **second}
a = {"name": "Aarav", "age": 24}
b = {"age": 25, "city": "Mumbai"}
print(merge_dictionaries(a, b))
# {'name': 'Aarav', 'age': 25, 'city': 'Mumbai'}When both dictionaries contain the same key, the value from the second dictionary takes precedence in this example.
Linear search examines each element until the target is found or the collection ends. It works with unsorted lists.
def linear_search(numbers, target):
for index, number in enumerate(numbers):
if number == target:
return index
return -1
print(linear_search([8, 3, 12, 5], 12)) # 2
print(linear_search([8, 3, 12, 5], 9)) # -1Complexity: O(n) time in the worst case and O(1) extra space.
Binary search repeatedly divides the search interval in half. It requires a sorted collection and is efficient for searching by index in a list.
def binary_search(numbers, target):
left = 0
right = len(numbers) - 1
while left <= right:
middle = (left + right) // 2
if numbers[middle] == target:
return middle
elif numbers[middle] < target:
left = middle + 1
else:
right = middle - 1
return -1
values = [2, 5, 8, 12, 16, 23, 38]
print(binary_search(values, 16)) # 4Complexity: O(log n) time and O(1) extra space for this iterative implementation. The input must be sorted in ascending order.
Bubble sort repeatedly compares adjacent values and swaps them when they are in the wrong order. It is easy to understand but inefficient for large collections.
def bubble_sort(numbers):
values = numbers.copy()
size = len(values)
for end in range(size - 1, 0, -1):
swapped = False
for index in range(end):
if values[index] > values[index + 1]:
values[index], values[index + 1] = (
values[index + 1], values[index]
)
swapped = True
if not swapped:
break
return values
print(bubble_sort([5, 2, 8, 1, 3]))
# [1, 2, 3, 5, 8]Complexity: O(n²) worst-case time and O(n) extra space in this version because it copies the input list. In production Python, built-in sorted() and list.sort() are generally preferable.
Recursion is a technique in which a function calls itself to solve a smaller version of the same problem. A recursive solution needs a base case that stops further calls and a recursive case that makes progress toward the base case.
def recursive_factorial(number):
if number < 0:
raise ValueError("Number cannot be negative")
if number <= 1:
return 1
return number * recursive_factorial(number - 1)
print(recursive_factorial(5)) # 120The base case is reached when the number is zero or one. Each recursive call reduces the number by one until the base case is reached.
Complexity: O(n) time and O(n) call-stack space. Very deep recursion can exceed Python's recursion limit.
The Euclidean algorithm finds the greatest common divisor by repeatedly replacing a pair of numbers with the second number and the remainder of the first divided by the second.
def gcd(a, b):
while b != 0:
a, b = b, a % b
return abs(a)
print(gcd(48, 18)) # 6
print(gcd(20, 8)) # 4This iterative algorithm is efficient and avoids recursive call-stack usage. It is commonly used in number-theory problems.
The two-pointer technique uses two indexes to examine or process elements efficiently. Depending on the problem, the pointers may move toward each other or advance through the collection at different speeds.
For example, two pointers can determine whether a sorted list contains a pair whose sum equals a target.
def pair_with_target_sum(numbers, target):
left = 0
right = len(numbers) - 1
while left < right:
total = numbers[left] + numbers[right]
if total == target:
return numbers[left], numbers[right]
elif total < target:
left += 1
else:
right -= 1
return None
print(pair_with_target_sum([1, 2, 4, 6, 9], 10))
# (1, 9)The input must be sorted in ascending order. The algorithm runs in O(n) time and uses O(1) extra space.
A sliding window maintains a range of elements and updates it as the range moves through a list or string. This can avoid repeatedly recalculating results for overlapping ranges.
The following example finds the maximum sum of any consecutive window of a specified size.
def maximum_window_sum(numbers, window_size):
if window_size <= 0 or window_size > len(numbers):
raise ValueError("Invalid window size")
current_sum = sum(numbers[:window_size])
maximum_sum = current_sum
for index in range(window_size, len(numbers)):
current_sum += numbers[index]
current_sum -= numbers[index - window_size]
maximum_sum = max(maximum_sum, current_sum)
return maximum_sum
print(maximum_window_sum([2, 1, 5, 1, 3, 2], 3))
# 9Complexity: O(n) time after initializing the first window. This approach is generally more efficient than recalculating each window's sum independently.
Time complexity describes how an algorithm's running time grows as input size increases. Space complexity describes how its memory requirements grow. Big O notation is commonly used to express upper bounds on growth.
| Complexity | Name | Example |
|---|---|---|
| O(1) | Constant | Accessing a list element by index. |
| O(log n) | Logarithmic | Binary search on a sorted list. |
| O(n) | Linear | Traversing a list once. |
| O(n log n) | Linearithmic | Typical comparison sorting algorithms such as merge sort. |
| O(n²) | Quadratic | Comparing all pairs using two nested loops. |
| O(2ⁿ) | Exponential | Some brute-force recursive approaches to combinatorial problems. |
def print_pairs(numbers):
for first in numbers:
for second in numbers:
print(first, second)If the list contains n elements, the function prints n × n pairs. Therefore, the number of operations grows quadratically, giving O(n²) time complexity.
Edge cases are inputs that occur at the boundaries of a problem's requirements. A solution that works only for typical examples may fail when it receives an empty list, a negative number, duplicate values, or unexpected input.
| Problem Type | Edge Cases to Test |
|---|---|
| Find largest element | Empty list, one element, all negative numbers, duplicate maximum values. |
| Factorial | Zero, one, negative input, large input. |
| Palindrome | Empty string, mixed case, spaces, punctuation, single character. |
| Binary search | Empty list, target missing, target at either boundary, repeated values. |
| Division | Zero denominator, negative values, decimal values. |
| List filtering | Empty list, no matching values, all matching values, repeated values. |
def safe_divide(numerator, denominator):
if denominator == 0:
raise ZeroDivisionError("Denominator cannot be zero")
return numerator / denominator
print(safe_divide(10, 2)) # 5.0Validation should reflect the requirements of the problem. Raising a meaningful exception is often preferable to silently returning an arbitrary value for invalid input.
The assert statement checks whether a condition is true. It is useful for quick examples and simple checks while developing a solution.
def is_even(number):
return number % 2 == 0
assert is_even(4) is True
assert is_even(7) is False
assert is_even(0) is True
print("All checks passed")For production validation and comprehensive automated tests, use a testing framework such as unittest or pytest. Python can disable assertions under optimized execution, so do not use them for essential application input validation.
import unittest
def reverse_text(text):
return text[::-1]
class TestReverseText(unittest.TestCase):
def test_normal_text(self):
self.assertEqual(reverse_text("python"), "nohtyp")
def test_empty_text(self):
self.assertEqual(reverse_text(""), "")
def test_single_character(self):
self.assertEqual(reverse_text("a"), "a")
if __name__ == "__main__":
unittest.main()Testing several cases makes it easier to discover mistakes before a solution is reused in a larger program.
Project objective: Create a Python program that processes student marks, calculates averages, determines pass or fail status, and identifies the highest-scoring student.
def analyze_results(students, pass_mark=40):
if not students:
raise ValueError("At least one student is required")
for name, mark in students.items():
if not isinstance(mark, (int, float)) or isinstance(mark, bool):
raise TypeError(f"Invalid mark for {name}")
if not 0 <= mark <= 100:
raise ValueError(f"Mark out of range for {name}")
average = sum(students.values()) / len(students)
top_student = max(students, key=students.get)
results = {}
for name, mark in students.items():
results[name] = {
"mark": mark,
"status": "Pass" if mark >= pass_mark else "Fail"
}
return {
"average": average,
"top_student": top_student,
"top_mark": students[top_student],
"results": results
}
students = {
"Aarav": 85,
"Diya": 92,
"Kabir": 37,
"Meera": 76
}
report = analyze_results(students)
print(f"Average: {report['average']:.2f}")
print(
f"Top student: {report['top_student']} "
f"({report['top_mark']})"
)
for name, result in report["results"].items():
print(
f"{name}: {result['mark']} - {result['status']}"
)Average: 72.50
Top student: Diya (92)
Aarav: 85 - Pass
Diya: 92 - Pass
Kabir: 37 - Fail
Meera: 76 - Passsum(), len(), and max().| Mistake | Problem | Solution |
|---|---|---|
| Incorrect indentation | Python may raise an error or execute a different block than intended. | Use consistent four-space indentation. |
| Off-by-one errors | A loop may skip or repeat a boundary value. | Check the start, stop, and inclusivity of each range. |
| Wrong comparison operator | A condition may not match the requirement. | Test conditions with values on both sides of the boundary. |
| Mutating a list while iterating over it | Elements can be skipped or processed unexpectedly. | Build a new list or iterate over a copy. |
| Ignoring empty inputs | Indexing or calculations may fail. | Validate the input or define the expected empty-input behavior. |
| Using the wrong data structure | The solution may be unnecessarily slow or complex. | Consider lists, sets, dictionaries, and tuples based on the operation needed. |
| Returning too early | A loop may stop before all values are processed. | Check whether the return statement belongs inside or outside the loop. |
| Not testing duplicates | Logic for unique or second-largest values may be incorrect. | Include repeated values in test cases. |
Consistent practice is more effective than attempting many problems without understanding the solutions. Start with simple tasks and gradually introduce more complex patterns.
| Day | Focus Area | Practice Goal |
|---|---|---|
| Day 1 | Variables, operators, and conditions | Solve 5 basic logic questions. |
| Day 2 | Loops and number problems | Practice factorial, primes, digit sums, and Fibonacci. |
| Day 3 | String problems | Practice reversing, palindromes, and character counts. |
| Day 4 | Lists and dictionaries | Practice duplicates, frequencies, and largest values. |
| Day 5 | Searching and sorting | Implement linear search and binary search. |
| Day 6 | Problem-solving patterns | Practice two pointers and sliding windows. |
| Day 7 | Revision and mini-project | Review errors and complete one small project. |
Try to solve the following questions independently before looking for alternative solutions.
Answer: An algorithm is a finite sequence of well-defined steps used to solve a problem or complete a task.
Answer: Pseudocode describes the logic of an algorithm in a readable, language-independent form before it is implemented in a programming language.
Answer: A list is mutable, meaning its contents can be changed. A tuple is immutable, meaning its structure cannot be modified after creation.
Answer: == compares values for equality, whereas is checks whether two references point to the same object.
Answer: A function is a reusable block of code defined using def or another function-creation mechanism. It can accept arguments and return a result.
Answer: Recursion is a technique in which a function calls itself to solve a smaller version of a problem. A correct recursive solution requires a base case.
Answer: Linear search checks elements sequentially and takes O(n) time in the worst case. Binary search repeatedly halves a sorted search interval and takes O(log n) time.
Answer: Big O notation describes how an algorithm's resource usage grows as input size increases, commonly focusing on time or space complexity.
Answer: You can use a set for unique values or maintain a set of seen elements while building a new list if the original order must be preserved.
Answer: A dictionary stores key-value pairs and provides efficient average-case lookups by key.
Answer: Edge cases reveal failures that may not appear with typical inputs, such as empty collections, negative values, duplicates, or boundary conditions.
Answer: Identify repeated work, choose appropriate data structures, apply suitable algorithms, analyze complexity, and benchmark the revised implementation.
Answer: It indicates quadratic growth. For example, a simple nested loop that processes every pair of n elements performs approximately n² iterations.
Answer: Sets and dictionaries use hashing to support efficient average-case membership checks and key lookups for hashable objects.
Answer: Clarify the requirements, identify inputs and outputs, work through a small example, design an algorithm, implement it, test edge cases, and evaluate its complexity.
Practicing Python coding, logic, and problem-solving questions helps build a strong foundation for software development, automation, data analysis, and technical interviews. By learning to break problems into smaller steps, select suitable data structures, apply algorithms, and test edge cases, learners can develop solutions that are both correct and efficient.
Consistent practice is the key to improvement. Begin with simple problems, gradually work toward intermediate algorithms, and build small projects that combine several Python concepts. Focus on understanding the reasoning behind each solution instead of memorizing code.
Continue learning through the Python Training Course at JustAcademy. You can also register for a course demo or visit the JustAcademy website.
For more practice with Python fundamentals, control flow, functions, and data structures, explore the official Python Tutorial.
