Algorithms & data structures
Classic patterns — search, sort, stacks, queues, and practical complexity-aware code.
How to Compute Jaccard Similarity in Python
Compute the Jaccard similarity between two lists by converting them to sets and dividing the intersection size by the union size.
def jaccard_similarity(list1, list2):
set1 = set(list1)
set2 = set(list2)
intersection = set1 & set2
union = set1 | set2
if not union:
return 0.0
return len(intersection) / len(union)
if __name__ == "__main__":
a = [1, 2, 3, 4, 5]
b = [3, 4, 5, 6, 7]
pri…How to Compute the Cartesian Product of Two Lists in Python
Generates all ordered pairs from two lists using itertools.product and prints each combination.
from itertools import product
# Two small input lists
list_a = [1, 2, 3]
list_b = ["x", "y"]
# Compute the Cartesian product
result = list(product(list_a, list_b))
# Display the result
print("Cartesian product of", list_a, "and", list_b, "is:")
for pair in result:
print(pair)How to Compute the Dot Product of Two Lists in Python
Compute the dot product of two equal-length numeric lists using a generator expression with zip and sum.
def dot_product(list1, list2):
"""
Compute the dot product of two numeric lists.
The lists must have the same length.
"""
if len(list1) != len(list2):
raise ValueError("Lists must have the same length")
return sum(a * b for a, b in zip(list1, list2))
if __name__ == "__main__":
…How to Count Occurrences of Each Value in Python
Count how many times each value appears in a list using Python's Counter from the collections module.
from collections import Counter
def count_occurrences(values):
"""Return a dictionary mapping each value to its count."""
return dict(Counter(values))
if __name__ == "__main__":
sample_data = ["apple", "banana", "apple", "cherry", "banana", "apple"]
result = count_occurrences(sample_data)
print(r…How to Detect Hardcoded Secrets in Python Source Code
A Python utility that scans source code for common hardcoded secrets like API keys, passwords, tokens, and AWS credentials using regex patterns.
import re
def detect_secrets(text):
"""Detect potential hardcoded secrets in source code."""
patterns = {
'api_key': r'(?i)(api[_-]?key|apikey)\s*[=:]\s*["\']([^"\']+)["\']',
'password': r'(?i)(password|passwd)\s*[=:]\s*["\']([^"\']+)["\']',
'token': r'(?i)(\b(token|secret)\b)\s*[=:]\s…How to Evaluate RPN Expressions in Python
Use a stack to evaluate Reverse Polish Notation token lists with a dictionary of operator lambdas, truncating division toward zero.
def eval_rpn(tokens):
stack = []
ops = {
'+': lambda a, b: a + b,
'-': lambda a, b: a - b,
'*': lambda a, b: a * b,
'/': lambda a, b: int(a / b) # truncate toward zero
}
for token in tokens:
if token in ops:
b = stack.pop()
a = stack.pop(…How to Find Gaps Between Sorted Intervals in Python
This code finds gap ranges between sorted intervals using pairwise iteration, returning ranges where no interval covers.
from itertools import pairwise
def find_gaps(intervals):
intervals = sorted(intervals)
gaps = []
for prev, curr in pairwise(intervals):
if prev[1] < curr[0]:
gaps.append((prev[1] + 1, curr[0] - 1))
return gaps
if __name__ == "__main__":
intervals = [(1, 3), (5, 7), (10, 12), (…How to Find Intersection of Two Sorted Interval Lists in Python
A two-pointer algorithm that finds all overlapping intervals between two sorted lists of intervals.
def interval_intersection(list1, list2):
i = j = 0
result = []
while i < len(list1) and j < len(list2):
# Find the overlap between current intervals
lo = max(list1[i][0], list2[j][0])
hi = min(list1[i][1], list2[j][1])
# If there's an overlap, add it to result
…How to Find Minimum Swaps to Sort an Array in Python
Calculate the minimum number of adjacent-free swaps needed to sort a permutation array using cycle detection in Python.
def min_swaps_to_sort(arr):
n = len(arr)
arr_pos = sorted((val, idx) for idx, val in enumerate(arr))
visited = [False] * n
swaps = 0
for i in range(n):
if visited[i] or arr_pos[i][1] == i:
continue
cycle_size = 0
j = i
while not visited[j]:
…How to Find the Previous Smaller Element in Python
Use a monotonic stack to find the nearest smaller element to the left of each item in a list, returning -1 when none exists.
from collections import deque
def previous_smaller_elements(arr):
stack = deque()
result = [-1] * len(arr)
for i in range(len(arr)):
while stack and arr[stack[-1]] >= arr[i]:
stack.pop()
if stack:
result[i] = arr[stack[-1]]
stack.append(i)
return resul…How to Find the n Smallest Items in a Large List with heapq in Python
This code demonstrates how to efficiently extract the n smallest items from a large list using Python's heapq module and a manual max-heap approach.
import heapq
def n_smallest_iterable(data, n):
"""Return the n smallest items without loading the whole list."""
if n <= 0:
return []
return heapq.nsmallest(n, data)
def n_smallest_manual(data, n):
"""Return the n smallest using a heap, O(n log k) time."""
if n <= 0:
return []
…How to Flatten List of Dict Values in Python
This code flattens the values of a list of dictionaries into a single list, handling both list values and scalar values.
def flatten_dict_values(dicts):
flattened = []
for d in dicts:
for value in d.values():
if isinstance(value, list):
flattened.extend(value)
else:
flattened.append(value)
return flattened
if __name__ == "__main__":
data = [
{"a": …How to Generate Fibonacci Sequence in Python
Generate the first n Fibonacci numbers as a list using a simple iterative loop.
def fibonacci(n):
"""Generate the first n terms of the Fibonacci sequence."""
if n <= 0:
return []
seq = [0, 1]
while len(seq) < n:
seq.append(seq[-1] + seq[-2])
return seq[:n]
if __name__ == "__main__":
n = 10
result = fibonacci(n)
print(result)How to Generate Permutations of Length r in Python
Generate and print all r-length permutations of a list using Python's itertools.permutations.
from itertools import permutations
def show_permutations(items, r):
result = list(permutations(items, r))
for perm in result:
print(perm)
print(f"Total: {len(result)}")
if __name__ == "__main__":
data = ["A", "B", "C"]
show_permutations(data, 2)How to Generate a Geometric Progression List in Python
This Python function builds a list of n terms in a geometric progression, starting with a given first term and multiplying by a constant ratio at each step.
def geometric_progression(first_term, ratio, count):
"""
Generate a list of 'count' terms in a geometric progression
starting with 'first_term' and multiplied by 'ratio' each step.
"""
progression = []
current = first_term
for _ in range(count):
progression.append(current)
c…How to Generate a Power Set in Python with Bitmasks
Generate the power set of a small list using a bitmask approach, producing all possible subsets.
def power_set(items):
"""Generate the power set of a list using bitmask approach."""
n = len(items)
result = []
for mask in range(1 << n):
subset = []
for i in range(n):
if mask & (1 << i):
subset.append(items[i])
result.append(subset)
r…How to Generate an Arithmetic Progression List in Python
Generates a list of terms in an arithmetic progression using a list comprehension.
def generate_ap(start, difference, count):
"""Generate a list of n terms in an arithmetic progression."""
return [start + i * difference for i in range(count)]
if __name__ == "__main__":
ap = generate_ap(3, 5, 6)
print(ap)How to Get All Combinations of a List in Python
Generate and display all combinations of a given length from a list using Python's itertools.combinations.
from itertools import combinations
def list_combinations(items, r):
"""Return all combinations of length r from a list."""
return list(combinations(items, r))
if __name__ == "__main__":
fruits = ["apple", "banana", "cherry", "date"]
pick = 2
result = list_combinations(fruits, pick)
print…How to Get the Breadth-First Traversal Order of a Graph in Python
Performs a breadth-first search on an adjacency list and returns the order nodes are visited, using a deque for efficient queue operations.
from collections import deque
def bfs_order(adjacency, start=0):
"""Return the order nodes are visited in a breadth-first traversal."""
visited = set()
order = []
queue = deque([start])
visited.add(start)
while queue:
node = queue.popleft()
order.append(node)
for neig…How to Heapify a List into a Min Heap with heapq in Python
Convert any list into a valid min heap in-place using Python's heapq.heapify(), then pop the smallest element to verify heap order.
import heapq
data = [5, 3, 8, 1, 9, 2, 7, 4, 6]
print("Original list:", data)
heapq.heapify(data)
print("Min heap:", data)
popped = heapq.heappop(data)
print("Smallest element popped:", popped)
print("Heap after pop:", data)How to Remove Banned Values from a List in Python
Filters a list by removing elements present in a banned set, preserving the original order.
def remove_banned(values, banned):
banned_set = set(banned)
return [item for item in values if item not in banned_set]
if __name__ == "__main__":
values = [1, 2, 3, 4, 5, 2, 6, 3, 7]
banned = [2, 3]
result = remove_banned(values, banned)
print(result)How to Remove Duplicates in Python Preserving Order
Removes duplicate items from a list while keeping the first occurrence order intact using a set for fast membership checks.
def remove_duplicates_preserving_order(items):
seen = set()
result = []
for item in items:
if item not in seen:
seen.add(item)
result.append(item)
return result
if __name__ == "__main__":
sample = [3, 1, 2, 1, 3, 4, 2, 5]
unique_items = remove_duplicates_preserv…How to Replace Outliers Beyond Threshold with Cap in Python
Replace values that fall below a lower threshold or above an upper threshold by capping them to the threshold values using a simple Python function.
def replace_outliers_with_cap(data, lower_threshold=None, upper_threshold=None):
"""Replace values beyond given thresholds with the threshold values (capping)."""
if lower_threshold is None and upper_threshold is None:
raise ValueError("At least one threshold must be provided.")
capped_data = …How to Rotate an Array by k Steps in Python
This code rotates a list to the right by k positions using modulo arithmetic to handle k larger than the list length.
def rotate_array(nums, k):
if not nums:
return []
n = len(nums)
k = k % n
return nums[-k:] + nums[:-k] if k else nums[:]
if __name__ == "__main__":
arr = [1, 2, 3, 4, 5, 6]
k = 2
result = rotate_array(arr, k)
print(f"Original: {arr}")
print(f"Rotated by {k}: {result}")Browse by section
Each section groups closely related Python snippets.
Algorithms & data structures — Python code examples
What you will find here
This page collects algorithms & data structures snippets — short, copy-ready Python you can paste into our free online IDE and run without installing anything. Each sample includes a plain-English explanation and the full source code.
Samples vs tutorials and challenges
Samples are quick reference — one concept per page. For step-by-step teaching, use our Python tutorials. To test yourself, try quizzes or coding challenges. Clean up style with the Python formatter.