Arrays & Strings Course

An array is a collection of items stored in contiguous memory locations.

An array stores multiple values under a single variable name, accessed by an index.

Arrays use contiguous memory blocks.

Static arrays have a fixed length (C arrays, Java arrays).

Every array element sits next to the previous one in RAM.

Traversal means visiting every element exactly once.

Inserting at the end is O(1) amortized.

Deleting an element requires shifting later elements left to fill the gap.

Updating is O(1): you compute the address from the index and overwrite the value.

Access O(1), search O(n), insert at end O(1) amortized, insert/delete in middle O(n).

2D arrays are arrays of arrays — a grid of rows and columns.

Sum, average, min, max, reverse, copy, fill, contains.

Patterns: prefix sum, sliding window, two pointers, fast/slow, sort+scan, hashmap counting.

Prefix sum lets you answer 'sum of any subarray' in O(1) after O(n) preprocessing.

Kadane finds the maximum sum contiguous subarray in O(n).

A string is a sequence of characters.

Strings are stored as contiguous arrays of bytes (ASCII) or code units (UTF-16, UTF-8).

Loop from i=0 to length-1, read s[i].

A char[] is a mutable array of characters.

String objects in Java/Python/JS are immutable — every concatenation creates a new object.

Splitting, joining, replacing, trimming, slicing — basic transformations every developer uses daily.

== compares references, equals/strcmp/.compareTo compares characters.

StringBuilder uses a resizable char buffer to append in O(1) amortized.

A palindrome reads the same forwards and backwards.

Count character occurrences with a 26-int array (lowercase) or HashMap.

Two strings are anagrams if they contain the same characters in any order.

Finding a pattern P inside text T.

ASCII has 128 chars (0-127).

Length n: traversal O(n), substring O(k), concat O(n+m), sort O(n log n), naive search O(n·m).

Validating email, parsing URLs, sanitizing user input, building a search engine, log-line parsing — strings are everywhere.

Walk through every element until found.

Search a sorted array in O(log n) by repeatedly halving the range.

Repeatedly swap adjacent out-of-order pairs.

Find the smallest element and put it at index 0, then the next smallest at index 1, and so on.

Build the sorted prefix one element at a time.

Divide array in half, sort each half recursively, merge in O(n).

Pick a pivot, partition smaller/larger elements, recurse.

Find two indices i,j such that nums[i]+nums[j]=target.

Find the contiguous subarray with the largest sum.

Shift array right by k.

Move all zeros to the end without changing relative order.

Build array where output[i] = product of all nums except nums[i] — without division and in O(n).

Range-sum, equilibrium index, subarray sum equals K.

To apply many range increments efficiently, store +x at l and -x at r+1; one prefix sum at the end gives final array.

Monotonic deque, sparse table, Mo's algorithm, square-root decomposition — patterns above the basics that solve the hardest problems.

Use two pointers from both ends and swap.

Reverse the entire string, then reverse each word.

Compare characters of all strings index-by-index until mismatch.

Sliding window + hashmap.

Run-length encode 'aaabb' as 'a3b2'.

Compare rolling hashes to find pattern in O(n+m) average.

Build failure function so the pattern never re-checks prefixes.

Compute Z[i] = longest substring starting at i that matches a prefix.

Maintain a moving window with character counts.

Polynomial rolling hash for fast substring comparison.

Patterns to describe strings: anchors, character classes, quantifiers, groups, lookaheads.

Word count, log parsing, CSV splitting, tokenizing — daily backend chores.

Run-length, base64, URL encode, JSON escape — convert strings between formats safely.

Minimum operations to make equal, longest palindromic substring, edit distance — DP-heavy challenges.

Suffix arrays, suffix trees, Aho-Corasick — state-of-the-art techniques for search and bioinformatics.

Linear, binary, ternary, exponential, interpolation — pick the one that fits your data and constraints.

Lower bound, upper bound, search-on-answer, rotated arrays.

Lower bound: first index ≥ x.

Comparison-based sorts can't beat O(n log n).

A stable sort preserves the relative order of equal keys.

External sorting, parallel merge sort, in-place variants.

Random pivot, three-way partition (Dutch flag), introsort.

Build a max heap in O(n), extract max n times.

O(n + k) when keys are integers in range [0, k].

Distribute into k buckets, sort each, concatenate.

Modified binary search; pick the sorted half each step.

Binary search on slope direction.

Index, sort once and binary search many times, cache hot keys, use bloom filters for membership.

Time, space, stability, in-place — choose by constraints, not by name.

Sort + two pointers, sort + binary search, sort + greedy — hybrid recipes from FAANG sets.

Maintain a window over the array and slide it instead of recomputing every range.

Window of size k slides one step at a time; add the new element, drop the old.

Window grows when valid, shrinks when invalid.

Two indices traverse the array.

One starts at the beginning, one at the end; they move toward each other.

Fast moves twice as fast as slow.

Longest with sum=k, longest with at most k distinct, longest no-repeat — all sliding window patterns.

Find shortest substring containing all chars of T.

Subarray sum equals k via prefix sum + hashmap; subarray with sum divisible by k via mod hashmap.

HashSet, sort+scan, frequency array, Floyd's cycle on indices — many ways to find duplicates.

Dutch flag, segregate odd/even, sort colors — partition with two or three pointers in O(n).

Use deque to maintain max/min in O(1) per element.

Nested loop with j depending on i?

Top 50 LeetCode patterns walkthrough — every one comes back as a slight variation.

Sliding window median, k-distinct subarray, count of nice subarrays — when basic windows aren't enough.

Make the locally optimal choice at every step.

2D grid traversals, row/column ops, transpose, in-place rotation.

Visit a 2D matrix in spiral order with four pointers — top, bottom, left, right.

Stack that only keeps increasing (or decreasing) elements.

Combine prefix and suffix arrays to answer range queries without nested loops.

Convert nested loop searches into O(1) lookups.

Fixed-size int[26] or int[256] beats HashMap for ASCII problems by 5-10×.

Most cells are zero — store only non-zero entries with HashMap or coordinate list.

Run-length, Huffman, LZ77 — turn long arrays into short ones with no info loss.

Process elements one at a time without storing all of them.

Bit manipulation, modular arithmetic, lookup tables, precomputation — gain milliseconds.

Reuse buffers, in-place ops, primitive arrays vs object arrays, Java -Xmx tuning.

Replace O(n²) with O(n log n) via sort+pointer, or with O(n) via hashmap.

Pagination, search ranking, recommendation, deduplication — algorithms running 24/7 in real systems.

Throughput, latency, SLA, observability — algorithms that survive production load.

20 hand-picked problems covering every fundamental array pattern, ordered easy → hard.

20 string problems from reverse to KMP — graded difficulty.

Custom comparators, sort-then-scan, k-th element, top-k frequent.

Top-15 LeetCode sliding window questions with full solutions.

Search-on-answer problems: ship-capacity, koko-bananas, split-array.

100+ FAANG-style questions with hints, brute force, optimal, and follow-ups.

Three full 45-minute mock interview scripts with rubric and feedback.

Curated path: 75 essential problems → 150 → 300.

'Walk me through how you'd…' open-ended scenarios that test communication.

Google, Meta, Amazon, Apple, Microsoft — the patterns each company favours.

Take a working O(n²) and reach O(n log n) or O(n).

Spot the off-by-one, the wrong base case, the integer overflow — train your eye.

No autocomplete, no compiler — neat handwriting + think-aloud habits.

Given a problem, name the pattern in under 30 seconds.

HackerRank, Codility, CoderPad style timed tests with sample rubrics.