Get in touch
Explain Big-O notation with 5 original examples.
Explain Big-Theta notation with 3 original examples.
Explain Big-Omega notation with 3 original examples.
Analyze time complexity of linear search in best, average, and worst cases.
Analyze time complexity of binary search in best, average, and worst cases.
Analyze space complexity of recursive Fibonacci.
Calculate time complexity of bubble sort in all cases.
Calculate time complexity of insertion sort in all cases.
Calculate time complexity of merge sort.
Calculate time complexity of quicksort and explain pivot choice effects.
Calculate space complexity of merge sort.
Compare space vs time trade-off in merge sort vs quicksort.
Time complexity of a balanced binary search tree operations.
Explain amortized time complexity with stack push/pop.
Calculate time complexity for matrix multiplication naive approach.
Calculate time complexity for matrix multiplication using Strassen’s algorithm.
Explain why hashmap operations are average O(1) but worst-case O(n).
Calculate time complexity of naive substring search.
Calculate time complexity of KMP substring search.
Explain how caching (memoization) improves time complexity for Fibonacci.
Analyze time complexity of DFS and BFS on graphs.
Calculate space complexity of DFS and BFS.
Analyze time complexity of Dijkstra’s shortest path algorithm.
Analyze space complexity of Dijkstra’s algorithm.
Calculate complexity of Prim’s and Kruskal’s MST algorithms.
Explain time complexity of heap operations.
Implement and analyze complexity of priority queue insert/extract.
Calculate time complexity of n-queens problem brute force.
Calculate time complexity of backtracking Sudoku solver.
Analyze recursive vs iterative factorial time and space complexity.
Explain complexity of exponentiation by squaring.
Compare iterative vs recursive binary search.
Analyze complexity of array vs linked list insertion/deletion.
Calculate complexity of dynamic array resizing.
Explain time complexity of hash collision resolution methods (chaining, open addressing).
Analyze space complexity of trie data structure.
Calculate time complexity of radix sort.
Compare time complexity of different sorting algorithms on nearly sorted data.
Calculate complexity of counting sort.
Analyze worst-case scenario for quicksort.
Explain time-space trade-offs with example of lookup tables.
Analyze time complexity of substring search with Rabin-Karp.
Calculate complexity of finding duplicates using sorting vs hashing.
Analyze the complexity of string reversal.
Explain time complexity of palindrome checking.
Calculate time complexity of all pairs shortest path (Floyd-Warshall).
Compare complexity of BFS vs DFS for cycle detection.
Calculate complexity of dynamic programming solutions for Fibonacci.
Explain time complexity of topological sort.
Analyze complexity of graph coloring heuristics.
Implement and analyze sieve of Eratosthenes for primes up to 10^5.
Modify sieve to return prime count up to N.
Find sum of primes up to 10^6 using sieve.
Count twin primes up to 10^6.
Implement naive prime checker using trial division.
Compare sieve and naive prime checker performance.
Implement segmented sieve for range [L, R].
Use sieve to factorize numbers up to 10^6.
Find largest prime factor of a number using sieve.
Implement prime checking using Miller-Rabin test.
Generate all primes between 1 and 10^7 using sieve.
Find prime gaps between consecutive primes up to 10^6.
Find first 100 primes.
Find sum of first N primes.
Check if number is perfect square of a prime.
Find primes in arithmetic progression using sieve.
Count prime numbers in a large interval efficiently.
Calculate product of primes up to N modulo M.
Implement Eratosthenes sieve with bitset optimization.
Find the smallest prime factor for all numbers up to N.
Check Goldbach’s conjecture for even numbers up to 10^6.
Find number of primes with digit sum equal to X.
Find primes with palindrome property.
Find next prime number after N.
Calculate Euler’s Totient function for numbers up to N.
Calculate GCD using Euclidean Algorithm.
Implement Extended Euclidean Algorithm.
Solve linear Diophantine equations using extended Euclidean.
Calculate LCM using GCD.
Implement fast modular exponentiation.
Use modular exponentiation to compute large powers modulo M.
Calculate modular inverse using Fermat’s little theorem.
Implement combinatorial nCr using Pascal’s triangle.
Precompute factorials and inverse factorials modulo M for fast nCr.
Implement Lucas theorem for large nCr modulo prime.
Use prefix sums to answer range sum queries.
Implement difference array for range update and point query.
Use prefix sums in 2D arrays.
Solve subarray sum problems using prefix sums.
Implement bit manipulation for counting set bits.
Use bit manipulation to generate all subsets of a set.
Implement Brian Kernighan’s algorithm for bit counting.
Use bitmask DP to solve subset sum problem.
Find XOR of all elements in an array.
Implement left and right bit shifts and explain effect.
Solve problems involving checking power of two using bits.
Implement and explain combinatorial permutations (nPr).
Calculate number of derangements for n elements.
Solve problems combining prefix sums and combinatorics.
Explain how modular arithmetic applies to hash functions.
Implement segmented sieve for prime factorization on huge ranges.
Use sieve to solve prime factor queries online.
Implement multiplicative inverse using extended Euclidean.
Create a mini library for modular arithmetic (add, subtract, multiply, divide).
Compare iterative vs recursive factorial with memoization.
Optimize prefix sums for dynamic arrays.
Use Fenwick tree or Segment tree to answer prefix sum queries with updates.
Implement fast exponentiation for matrices.
Explore connections between combinatorics and probability in algorithms.
Solve classic combinatorial puzzles using code (e.g., Catalan numbers).
