String Compression - Solution & Explanation
Problem Statement
Given an array of characters chars, compress it using the following algorithm:
Begin with an empty string s. For each group of consecutive repeating characters in chars:
- If the group's length is
1, append the character tos. - Otherwise, append the character followed by the group's length.
The compressed string s should not be returned separately, but instead, be stored in the input character array chars. Note that group lengths that are 10 or longer will be split into multiple characters in chars.
After you are done modifying the input array, return the new length of the array.
You must write an algorithm that uses only constant extra space.
Example 1:
Input: chars = ["a","a","b","b","c","c","c"] Output: Return 6, and the first 6 characters of the input array should be: ["a","2","b","2","c","3"] Explanation: The groups are "aa", "bb", and "ccc". This compresses to "a2b2c3".
Example 2:
Input: chars = ["a"] Output: Return 1, and the first character of the input array should be: ["a"] Explanation: The only group is "a", which remains uncompressed since it's a single character.
Example 3:
Input: chars = ["a","b","b","b","b","b","b","b","b","b","b","b","b"] Output: Return 4, and the first 4 characters of the input array should be: ["a","b","1","2"]. Explanation: The groups are "a" and "bbbbbbbbbbbb". This compresses to "ab12".
Constraints:
1 <= chars.length <= 2000chars[i]is a lowercase English letter, uppercase English letter, digit, or symbol.
Approach Overview
Problem Overview: Given an array of characters, compress it in-place so consecutive repeating characters are replaced with the character followed by its count. The result must be written back into the same array and the new length returned.
Approach 1: Brute Force Method (O(n) time, O(n) space)
Scan the array and build a separate compressed representation using a temporary string or list. Iterate through the characters, count how many times the current character repeats, and append the character followed by the count (only if the count is greater than 1). After processing the entire array, copy the compressed result back into the original array. This approach is straightforward and helps verify the logic for grouping consecutive characters, but it uses extra memory proportional to the input size.
This method relies purely on sequential iteration over the string and simple counting logic. No special data structures are required beyond a temporary buffer. The algorithm still runs in O(n) time because each character is processed once, but the auxiliary storage leads to O(n) space usage.
Approach 2: Optimized Two-Pointer Compression (O(n) time, O(1) space)
The optimal solution uses the two pointers technique to compress characters directly inside the input array. Maintain a read pointer to scan the array and a write pointer to place the compressed output. For each group of identical characters, count how many times it repeats by advancing the read pointer.
Once the group ends, write the character at the write pointer. If the count is greater than 1, convert the count into digits and write each digit sequentially into the array. Because the write pointer always moves forward and the read pointer scans each character once, the algorithm runs in O(n) time with O(1) extra space.
This approach is a classic in-place string manipulation pattern using string processing and two-pointer traversal. The key insight is separating reading and writing positions so compression never overwrites unread characters.
Recommended for interviews: The in-place two-pointer approach is what interviewers expect. It demonstrates control over pointer manipulation, careful iteration, and memory-efficient design. Starting with the brute force version shows you understand the grouping logic, but implementing the optimized version proves you can convert that idea into an O(1) space solution.
Approach 1: Brute Force Method
This straightforward approach involves examining every possible combination to find the solution. While not optimal, this method is simple to understand and implement. However, its time complexity can be high for large datasets, making it inefficient for extensive inputs.
The solution examines every possible pair of numbers within the array. It's simple, but not efficient for large datasets.
Complexity
Time Complexity: O(n^2), Space Complexity: O(1)
Approach 2: Optimized Sort and Two-Pointer Technique
This technique involves first sorting the array, which allows us to use the two-pointer method to efficiently find the required pairs. This approach is significantly better than brute force for larger datasets.
The array is sorted using qsort function in C. Two indices are then used to efficiently find the solution in linear time post sorting.
Complexity
Time Complexity: O(n log n), Space Complexity: O(1)
Approach 3: Default Approach
Try this approach in the editor →Complexity Comparison
| Approach | Complexity |
|---|---|
| Brute Force Method | Time Complexity: O(n^2), Space Complexity: O(1) |
| Optimized Sort and Two-Pointer Technique | Time Complexity: O(n log n), Space Complexity: O(1) |
| Default Approach | — |
Detailed Complexity Analysis
| Approach | Time | Space | When to Use |
|---|---|---|---|
| Brute Force Method | O(n) | O(n) | Good for understanding compression logic or when modifying the original array is not required. |
| Optimized Two-Pointer Compression | O(n) | O(1) | Best choice for interviews and production when in-place modification and constant space are required. |
Video Solution
String Compression problem - Lecture 32 | Leetcode 443 • Apna College • 150,748 views views
Watch 9 more video solutions →Frequently Asked Questions
Is String Compression easy or hard?
String Compression Python/Java solution
How to solve String Compression in O(n)?
What is the best approach for String Compression?
Is String Compression asked at Google/Amazon/Meta?
What data structure is used in String Compression?
What is the time complexity of String Compression?
Ready to solve this problem?
Practice String Compression with our built-in code editor and test cases.
Practice on FleetCodeProblem Info
Table of Contents
Practice this problem
Open in Editor