Most Popular Python Coding Questions & Answers
Whether you’re preparing for a campus placement, a technical interview, or simply sharpening your Python skills, practicing the right coding problems makes all the difference. Python continues to dominate both academic and professional environments — AI and Machine Learning questions have become a core part of Python interviews alongside traditional coding problems.
This guide covers the most frequently asked Python coding questions — from fundamentals to AI/ML concepts — complete with problem statements, sample inputs/outputs, and well-explained solutions.
Table of Contents
Section 1: Core Python Coding Questions
1. Reverse a String in Python
Problem: Write a Python function that takes a string as input and returns it reversed.
Input: "Hello" Output: "olleH"
Python’s slicing syntax makes this one of the cleanest one-liners in the language. The [::-1] slice reads the string from end to start with a step of -1.
def reverse_string(s):
return s[::-1]
print(reverse_string("Hello")) # Output: olleH
Key Concept: String slicing — [start:stop:step]
2. Find the Second Largest Element in a List
Problem: Given a list of integers, return the second largest value.
Input: [10, 20, 4, 45, 99] Output: 45
def second_largest(nums):
unique_nums = sorted(set(nums))
return unique_nums[-2]
print(second_largest([10, 20, 4, 45, 99])) # Output: 45
Key Concept: set() for deduplication, sorted() for ordering
3. Check Whether a Number is Prime
Problem: Write a function that returns True if a given number is prime, False otherwise.
Input: 7 Output: True
def is_prime(n):
if n <= 1:
return False
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
return False
return True
print(is_prime(7)) # Output: True
Key Concept: Square root optimization — reduces time complexity from O(n) to O(√n)
4. Generate the Fibonacci Sequence
Problem: Return a list of the first N numbers in the Fibonacci sequence.
Input: 5 Output: [0, 1, 1, 2, 3]
def fibonacci(n):
sequence = [0, 1]
for i in range(2, n):
sequence.append(sequence[-1] + sequence[-2])
return sequence[:n]
print(fibonacci(5)) # Output: [0, 1, 1, 2, 3]
Key Concept: Iterative approach avoids stack overflow for large N
5. Return All Unique Subsets of a List
Problem: Given a list of numbers, return all possible unique subsets including the empty set.
Input: [1, 2] Output: [[], [1], [2], [1, 2]]
def unique_subsets(nums):
result = [[]]
for num in nums:
result += [curr + [num] for curr in result]
return result
print(unique_subsets([1, 2])) # Output: [[], [1], [2], [1, 2]]
Key Concept: List comprehension + iterative subset expansion (Power Set pattern)
6. Find the Longest Common Prefix
Problem: Given an array of strings, find the longest prefix string shared by all elements.
Input: ["flower", "flow", "flight"] Output: "fl"
def longest_common_prefix(strs):
if not strs:
return ""
prefix = strs[0]
for string in strs[1:]:
while not string.startswith(prefix):
prefix = prefix[:-1]
if not prefix:
return ""
return prefix
print(longest_common_prefix(["flower", "flow", "flight"])) # Output: fl
Key Concept: startswith() method + string trimming loop
7. Merge Two Sorted Lists
Problem: Given two already-sorted lists, merge them into a single sorted list without using built-in sort.
Input: [1, 3, 5] and [2, 4, 6] Output: [1, 2, 3, 4, 5, 6]
def merge_sorted_lists(list1, list2):
result = []
i = j = 0
while i < len(list1) and j < len(list2):
if list1[i] < list2[j]:
result.append(list1[i])
i += 1
else:
result.append(list2[j])
j += 1
result.extend(list1[i:])
result.extend(list2[j:])
return result
print(merge_sorted_lists([1, 3, 5], [2, 4, 6])) # Output: [1, 2, 3, 4, 5, 6]
Key Concept: Two-pointer technique — core concept in merge sort algorithm
8. Count Vowels in a String
Problem: Write a function that counts the total number of vowels in a given string.
Input: "hello world" Output: 3
def count_vowels(s):
vowels = "aeiouAEIOU"
return sum(1 for char in s if char in vowels)
print(count_vowels("hello world")) # Output: 3
Key Concept: Generator expressions + sum() for concise counting
9. Binary Search on a Sorted List
Problem: Implement binary search to determine whether a target number exists in a sorted list.
Input: [1, 2, 3, 4, 5], target = 3 Output: True
def binary_search(arr, target):
left, right = 0, len(arr) - 1
while left <= right:
mid = (left + right) // 2
if arr[mid] == target:
return True
elif arr[mid] < target:
left = mid + 1
else:
right = mid - 1
return False
print(binary_search([1, 2, 3, 4, 5], 3)) # Output: True
Key Concept: Divide and conquer — time complexity O(log n)
🤖 Section 2: AI & Machine Learning Python Questions
These questions are increasingly asked interviews for roles involving data science, AI development, and ML engineering.
10. Calculate Euclidean Distance Between Two Points
Problem: Write a function to compute the Euclidean distance between two data points. This is a fundamental operation in algorithms like K-Nearest Neighbors (KNN).
Input: point1 = [1, 2], point2 = [4, 6] Output: 5.0
import math
def euclidean_distance(p1, p2):
return math.sqrt(sum((a - b) ** 2 for a, b in zip(p1, p2)))
print(euclidean_distance([1, 2], [4, 6])) # Output: 5.0
Key Concept: Distance metrics — used in KNN, clustering, and similarity search
11. Implement Min-Max Normalization
Problem: Normalize a list of numbers to a range between 0 and 1. This is a required preprocessing step before training most ML models.
Input: [10, 20, 30, 40, 50] Output: [0.0, 0.25, 0.5, 0.75, 1.0]
def min_max_normalize(data):
min_val = min(data)
max_val = max(data)
return [(x - min_val) / (max_val - min_val) for x in data]
print(min_max_normalize([10, 20, 30, 40, 50]))
# Output: [0.0, 0.25, 0.5, 0.75, 1.0]
Key Concept: Feature scaling — prevents larger values from dominating model training
12. Implement the Sigmoid Activation Function
Problem: Write a Python function that applies the sigmoid activation function to a given value. Sigmoid is used in logistic regression and neural network output layers.
Input: 0 Output: 0.5
import math
def sigmoid(x):
return 1 / (1 + math.exp(-x))
print(sigmoid(0)) # Output: 0.5
print(sigmoid(2)) # Output: 0.8807970779778823
Key Concept: Activation functions — converts any real number into a probability between 0 and 1
13. Calculate Mean Squared Error (MSE)
Problem: Given a list of actual values and predicted values, compute the Mean Squared Error — a common loss function used to evaluate regression models.
Input: actual = [3, 5, 2, 8], predicted = [2.5, 5, 4, 7] Output: 0.9375
def mean_squared_error(actual, predicted):
n = len(actual)
return sum((a - p) ** 2 for a, p in zip(actual, predicted)) / n
actual = [3, 5, 2, 8]
predicted = [2.5, 5, 4, 7]
print(mean_squared_error(actual, predicted)) # Output: 0.9375
Key Concept: Loss functions — measures how far model predictions are from actual values
14. Implement a Simple Linear Regression (Gradient Descent)
Problem: Use gradient descent to find the slope (m) and intercept (b) that best fit a dataset. This is the foundation of supervised learning.
Input: X = [1, 2, 3, 4, 5], Y = [2, 4, 5, 4, 5] Output: Optimized values of m and b
def linear_regression_gd(X, Y, learning_rate=0.01, epochs=1000):
m, b = 0, 0
n = len(X)
for _ in range(epochs):
y_pred = [m * x + b for x in X]
dm = (-2/n) * sum(x * (y - yp) for x, y, yp in zip(X, Y, y_pred))
db = (-2/n) * sum(y - yp for y, yp in zip(Y, y_pred))
m -= learning_rate * dm
b -= learning_rate * db
return round(m, 4), round(b, 4)
X = [1, 2, 3, 4, 5]
Y = [2, 4, 5, 4, 5]
m, b = linear_regression_gd(X, Y)
print(f"Slope: {m}, Intercept: {b}")
# Output: Slope: 0.6, Intercept: 1.8
Key Concept: Gradient descent — the core optimization algorithm behind all neural networks
15. Tokenize a Sentence (NLP Preprocessing)
Problem: Write a function that splits a sentence into individual word tokens and converts them to lowercase. This is the first step in any Natural Language Processing (NLP) pipeline.
Input: "Machine Learning is the Future of AI" Output: ['machine', 'learning', 'is', 'the', 'future', 'of', 'ai']
def tokenize(sentence):
return sentence.lower().split()
print(tokenize("Machine Learning is the Future of AI"))
# Output: ['machine', 'learning', 'is', 'the', 'future', 'of', 'ai']
Key Concept: Text preprocessing — tokenization is step one in chatbots, sentiment analysis, and LLMs
16. Calculate Cosine Similarity Between Two Vectors
Problem: Compute cosine similarity between two vectors. This is widely used in recommendation systems, document similarity, and AI search engines.
Input: vec1 = [1, 2, 3], vec2 = [4, 5, 6] Output: 0.9746
import math
def cosine_similarity(vec1, vec2):
dot_product = sum(a * b for a, b in zip(vec1, vec2))
mag1 = math.sqrt(sum(a ** 2 for a in vec1))
mag2 = math.sqrt(sum(b ** 2 for b in vec2))
return round(dot_product / (mag1 * mag2), 4)
print(cosine_similarity([1, 2, 3], [4, 5, 6])) # Output: 0.9746
Key Concept: Similarity metrics — used in vector databases, search engines, and LLM embeddings
17. Implement a Basic Confusion Matrix
Problem: Given actual labels and predicted labels from a binary classifier, compute the confusion matrix values: TP, FP, TN, FN.
Input: actual = [1,0,1,1,0,1,0,0], predicted = [1,0,1,0,0,1,1,0] Output: TP=3, FP=1, TN=3, FN=1
def confusion_matrix(actual, predicted):
TP = sum(1 for a, p in zip(actual, predicted) if a == 1 and p == 1)
FP = sum(1 for a, p in zip(actual, predicted) if a == 0 and p == 1)
TN = sum(1 for a, p in zip(actual, predicted) if a == 0 and p == 0)
FN = sum(1 for a, p in zip(actual, predicted) if a == 1 and p == 0)
return {"TP": TP, "FP": FP, "TN": TN, "FN": FN}
actual = [1, 0, 1, 1, 0, 1, 0, 0]
predicted = [1, 0, 1, 0, 0, 1, 1, 0]
print(confusion_matrix(actual, predicted))
# Output: {'TP': 3, 'FP': 1, 'TN': 3, 'FN': 1}
Key Concept: Model evaluation — confusion matrix is the foundation of accuracy, precision, recall, and F1 score
Quick Reference Table
| # | Problem | Category | Core Concept |
|---|---|---|---|
| 1 | Reverse a String | Core Python | Slicing [::-1] |
| 2 | Second Largest Element | Core Python | set(), sorted() |
| 3 | Prime Number Check | Core Python | Square root optimization |
| 4 | Fibonacci Sequence | Core Python | Iterative loops |
| 5 | Unique Subsets | Core Python | Power set pattern |
| 6 | Longest Common Prefix | Core Python | String trimming |
| 7 | Merge Sorted Lists | Core Python | Two-pointer technique |
| 8 | Count Vowels | Core Python | Generator + sum() |
| 9 | Binary Search | Core Python | Divide and conquer |
| 10 | Euclidean Distance | AI / ML | Distance metrics |
| 11 | Min-Max Normalization | AI / ML | Feature scaling |
| 12 | Sigmoid Function | AI / ML | Activation functions |
| 13 | Mean Squared Error | AI / ML | Loss functions |
| 14 | Linear Regression (GD) | AI / ML | Gradient descent |
| 15 | Sentence Tokenization | AI / NLP | Text preprocessing |
| 16 | Cosine Similarity | AI / ML | Vector similarity |
| 17 | Confusion Matrix | AI / ML | Model evaluation |
Final Thoughts
Python interviews go well beyond basic syntax — especially for roles in data science, AI development, and full-stack engineering. Mastering both core Python logic and AI/ML fundamentals gives you a clear edge in placements at product companies, startups, and tech firms.
Practice each function from scratch, test edge cases, and focus on understanding why each solution works — not just memorizing the code.
Tags: python coding questions with solutions, Python coding interview questions and answers, python AI coding questions, python machine learning interview questions, python coding questions for placement , Python NLP questions, Python data science interview questions, python coding questions for freshers, python coding questions for experienced, top python coding questions
