Introduction
Python lists are one of the most powerful data structures, providing dynamic storage and flexible operations. While working with lists is often straightforward, some problems require deep understanding and creativity. This blog presents 20 of the hardest Python list questions, covering everything from basic manipulations to advanced algorithmic challenges. Each problem is designed to test and expand your Python skills.
1. Reverse a List in Groups of k
Problem: Given a list and an integer k, reverse every k elements in the list.
Example:
Input: [1, 2, 3, 4, 5, 6, 7, 8, 9], k = 3
Output: [3, 2, 1, 6, 5, 4, 9, 8, 7]
Solution:
def reverse_groups(lst, k):
return [lst[i:i+k][::-1] for i in range(0, len(lst), k)]
2. Find All Subsequences of a List
Problem: Generate all possible subsequences of a given list.
Solution:
from itertools import chain, combinations
def all_sublists(lst):
return list(chain.from_iterable(combinations(lst, r) for r in range(len(lst)+1)))
3. Find the Maximum Sum of a Subarray (Kadane鈥檚 Algorithm)
Problem: Find the contiguous subarray with the maximum sum.
Solution:
def max_subarray_sum(arr):
max_sum = float('-inf')
current_sum = 0
for num in arr:
current_sum = max(num, current_sum + num)
max_sum = max(max_sum, current_sum)
return max_sum
4. Find the Longest Increasing Subsequence
Problem: Find the longest increasing subsequence (LIS) in a list.
Solution:
from bisect import bisect_left
def longest_increasing_subsequence(arr):
lis = []
for num in arr:
pos = bisect_left(lis, num)
if pos == len(lis):
lis.append(num)
else:
lis[pos] = num
return len(lis)
5. Find the Missing Number in a List
Problem: Given a list of n numbers from 1 to n+1, find the missing number.
Solution:
def missing_number(lst, n):
return (n * (n + 1)) // 2 - sum(lst)
6. Merge Overlapping Intervals
Problem: Given a list of intervals, merge overlapping intervals.
Solution:
def merge_intervals(intervals):
intervals.sort()
merged = [intervals[0]]
for curr in intervals[1:]:
if curr[0] <= merged[-1][1]:
merged[-1][1] = max(merged[-1][1], curr[1])
else:
merged.append(curr)
return merged
7. Find All Pairs That Sum to K
Problem: Find all pairs (a, b) in a list such that a + b = k.
Solution:
def pair_sum(lst, k):
seen = set()
pairs = []
for num in lst:
if k - num in seen:
pairs.append((num, k - num))
seen.add(num)
return pairs
8. Find the Majority Element
Problem: Find the element that appears more than n/2 times in a list.
Solution:
def majority_element(lst):
count, candidate = 0, None
for num in lst:
if count == 0:
candidate = num
count += (1 if num == candidate else -1)
return candidate
9. Find the First Missing Positive Integer
Problem: Given an unsorted list, find the first missing positive integer.
Solution:
def first_missing_positive(nums):
nums = set(nums)
for i in range(1, len(nums) + 2):
if i not in nums:
return i
10. Rotate List Right by k Places
Problem: Rotate a list to the right by k places.
Solution:
def rotate_list(lst, k):
k %= len(lst)
return lst[-k:] + lst[:-k]
11-20: Advanced Challenges
- Find the maximum product of three numbers in a list.
- Find the longest consecutive sequence in a list.
- Find all unique permutations of a list.
- Find the intersection of two lists.
- Find the union of two lists without duplicates.
- Check if a list contains a cycle (Linked List style).
- Find the kth smallest element in a list.
- Rearrange a list so that positive and negative numbers alternate.
- Find the two numbers in a list that have the smallest difference.
- Group anagrams in a list of words.
Conclusion
Python lists are a versatile and powerful data structure. These 20 challenges push the boundaries of what can be done with lists in Python. Mastering these problems will enhance your algorithmic thinking and coding efficiency.
Are you up for the challenge? Try these problems and level up your Python skills!
