Explore how Big O notation measures the order of growth and provides an upper bound, using a direct method and examples such as linear and quadratic functions.

Explore space complexity and auxiliary space, from constant space to theta n for lists, and how recursion can yield theta n auxiliary space via the function call stack.

Demonstrates the sum of first n natural numbers using the formula n(n+1)/2, with a Python program that reads n and prints the result; shows n=10 yields 55.

Learn to count digits by repeatedly dividing a positive number by ten using floor division in a while loop, with a Python implementation that reads input and prints the count.

Learn to compute the gcd of two numbers with brute-force divisors from min(a,b) to 1, then apply Euclid's algorithm using repeated swaps and modulo for fast results.

Learn to determine if a number is prime by testing divisors up to the square root of n, with special handling for n equals 1.

Explore bitwise operators in Python, including left shift, right shift, and bitwise not, with examples of multiplying and dividing by powers of two, and two's complement for negatives.

Count set bits in a number using naive bit-by-bit methods with LSB, then apply Brian Cunningham's algorithm to unset bits, and finish with an eight-bit lookup table for constant-time results.

Explore a linear-time xor-based solution in Python to find the two numbers with odd occurrences in an array, using bit splitting and partitioning.

Generate the power set of a string using an iterative bitwise approach, mapping binary numbers to subsets to print all 2^n subsets with no recursion overhead.

Use recursion in Python to print numbers from one to n by first recursing on n-1, then printing n, with a base case of zero to stop.

Understand tail recursion, why tail call elimination matters in languages like C, C++, and Java, and how Python does not perform tail call elimination, so you convert to a loop.

Identify and implement base cases for recursion by analyzing recursion trees for factorial and fibonacci. Handle zero and one and ensure all recursions terminate.

Learn to compute the average of a list in Python by summing elements and dividing by their count, with examples like 10, 20, 30, 40.

Explore Python slicing for lists, tuples, and strings by applying start, stop, and step to obtain sub-sequences, including defaults, negative indices, and reversing with colon colon minus one.

Master Python comprehensions, including list, set, and dictionary forms, turning iterables like range into concise one-line constructs, with examples for even/odd filtering and dictionary mapping.

Learn to find the largest element in a non-empty list using Python's max or a linear-time custom function, and compare with a quadratic nested-loop approach.

Learn one traversal algorithm to find the second largest in a list by maintaining largest and second largest, handling equal values and edge cases like empty or single element lists.

Remove duplicates in place from a sorted array and return size of distinct prefix. Also explore arranging an array so every odd index is strictly greater than previous even index.

Learn how to left rotate a list by one in Python, using slicing, pop and append, and an in-place loop that preserves a constant extra space.

Explore Kadane's algorithm to compute the maximum subarray sum in a contiguous array, using a running sum that resets when negative, delivering O(n) time and O(1) space in Python.

Explore the sliding window technique to solve the maximum sum of k consecutive elements in an array, by updating the current window in O(1) as you move.

Learn to compute the square root of a positive integer using binary search, returning the floor when n isn't a perfect square, without the inbuilt sqrt function.

Learn to detect a triplet that sums to x in a sorted array with a two-pointer approach, achieving O(n^2) time and O(1) space (sorting for unsorted arrays).

Explore the allocate minimum pages problem by using a naive recursive method to distribute contiguous books among k students, minimizing the maximum pages read.

Bubble sort is a simple comparison based algorithm with theta(n^2) time that sorts by repeatedly swapping adjacent out of order elements, moving the largest to the end.

Merge sort is a divide-and-conquer, stable sorting algorithm that divides input, recursively sorts parts, and merges them. It runs in theta(n log n) time with O(n) space, used in libraries.

Merge two sorted subarrays within a list using two auxiliary lists and a stable merge back into the original, in Python, with theta(m+n) time and space.

Explore quicksort with Hoare's partition, contrasting it with Lomuto; Hoare partitions without fixing the pivot, returning the end of the left part, enabling in-place, recursive sorting of subarrays.

Learn to sort arrays containing zeros, ones, and twos, and extend to three-way and range-based partitioning using the Dutch national flag algorithm. Implemented with low, mid, and high pointers in a single pass, it runs in theta n time and uses no auxiliary space.

Learn to maximize the number of guests you can meet by merging sorted arrival and departure events, tracking current guests and updating the maximum, with O(n log n) time.

Explore counting sort, a theta(n+k) linear time algorithm for small-range integers, using a count array and prefix sums to produce a stable sort with auxiliary space.

Discover cycle sort, an in-place, not stable sorting method with O(n^2) worst-case time, that minimizes memory writes by counting smaller elements and fixing cycles.

Explore radix sort introduction, a linear-time, non-compare sorting method that uses counting sort as a stable subroutine across digit passes from least to most significant, padding numbers to equal digits.

Implement Python bucket sort by distributing non-negative integers into k buckets, sorting each bucket with insertion sort, and merging, achieving near-linear time under uniform distribution; note best and worst cases.

Learn how to pass a 2d array as an argument to a function in Python, access its rows and columns, and print the matrix with space-separated values.

Implement matrix boundary traversal in Python by visiting the boundary in a clockwise order starting from the first row, covering the top row, last column, last row, and first column.

Explore hashing for dictionaries and sets, enabling average time for search, insert, and delete, and note its limits on closest value, sorted order, and prefix search.

Explore direct address tables with a boolean array to achieve constant-time search, insert, and delete for small key ranges, and note limitations that motivate hashing.

Explore Python dictionaries, their key-value pairs, and how hashing makes them unordered, with practical examples of access, insertion, update, and removal using get, in, length, pop, del, and popitem.

Learn to find a zero-sum subarray in Python by comparing prefix sums with a hash set, moving from a quadratic naive solution to a linear time approach.

Use a flexible sliding window with two pointers to find a subarray that sums to the given value in an array of non-negative integers in linear time.

Count character frequencies with a counter to determine if a string has at most one odd frequency, enabling palindrome permutation; this linear-time solution contrasts with the naive factorial approach.

Identify elements in an array whose frequency exceeds n by k using sorting or hash table methods, including Python counter for efficient frequency counts.