aloalgoArrays & Strings Summary
A quick reference for array and string techniques and problems to practice. Arrays and strings are the most fundamental data structures in programming, and they appear in nearly every coding interview. An array stores elements in contiguous memory, giving you constant-time access by index, while a string is essentially an array of characters with specialized operations for text manipulation.Mastering arrays and strings means understanding how to traverse, transform, and search through sequential data efficiently. Many problems that seem complex at first glance can be reduced to a handful of well-known patterns. The key is recognizing which pattern applies and implementing it cleanly. Below you will find the core techniques, chapter links, and curated practice problems organized by difficulty.Key Concepts
The following table summarizes the most important techniques you will encounter when solving array and string problems. Each technique addresses a specific category of problems and offers a characteristic time complexity advantage over brute-force approaches.| Technique | When to Use | Time |
|---|---|---|
| Two Pointers | Sorted arrays, palindromes, pair finding | O(n) |
| Sliding Window | Contiguous subarrays/substrings with constraints | O(n) |
| Binary Search | Sorted data, finding boundaries, optimization | O(log n) |
| Prefix Sum | Range sum queries, subarray sums | O(1) query |
| Sorting | Simplify comparisons, enable two pointers | O(n log n) |
When to Use Each Technique
Choosing the right technique is often the hardest part of solving an array or string problem. Here are some rules of thumb to guide your decision:- If the array is sorted or you can sort it without breaking the problem constraints, consider two pointers or binary search.
- If the problem asks about contiguous subarrays or substrings with some constraint (maximum sum, at most K distinct characters), the sliding window technique is likely the right fit.
- If you need to answer multiple range sum queries, precompute a prefix sum array first so each query takes constant time.
- If the problem involves finding pairs or complements, a hash map can reduce the time from O(n²) to O(n).
- When nothing else fits, sorting the input often simplifies the problem enough to apply a greedy or two-pointer approach.
Chapters
Work through these chapters in order to build a strong foundation in array and string manipulation. Each chapter introduces a technique, explains when and why it works, and walks through examples.- Arrays - Array basics and operations
- Strings - String manipulation and patterns
- Two Pointers - Opposite ends and same direction patterns
- Sliding Window - Fixed and variable window techniques
- Binary Search - Classic and advanced applications
- Prefix & Suffix Arrays - Precomputation for range queries
Common Mistakes
- Off-by-one errors: Carefully consider whether your loop bounds should be inclusive or exclusive. For example, iterating from 0 to n-1 versus 0 to n can make or break a solution.
- Mutating while iterating: Modifying an array while looping over it can lead to skipped elements or infinite loops. Build a new result or iterate in reverse when removing elements.
- Forgetting empty or single-element cases: Always consider what happens when the input is empty, has one element, or all elements are the same.
- String immutability: In many languages strings are immutable, so repeated concatenation can be O(n²). Use a list or StringBuilder instead.
Practice Problems
These problems are organized by difficulty. Start with the easy problems to build confidence, then move to medium and hard as the patterns become more familiar.Easy
Medium
Was this helpful?
Company
Practice
© 2026 aloalgo. All rights reserved.