Take K of Each Character From Left and Right

Take K of Each Character From Left and Right - Problem

Take K of Each Character From Left and Right

You're given a string s containing only the characters 'a', 'b', and 'c', along with a non-negative integer k.

The Challenge: Each minute, you can remove either the leftmost or rightmost character from the string. Your goal is to collect at least k of each character ('a', 'b', and 'c') in the minimum number of minutes possible.

Return the minimum minutes needed, or -1 if it's impossible to collect k of each character.

Example: For string "aabaaaacaaac" and k = 2, you need at least 2 'a's, 2 'b's, and 2 'c's. By taking characters from both ends strategically, you can achieve this in 8 minutes.

Input & Output

example_1.py — Basic Case

$ Input: s = "aabaaaacaaac", k = 2

› Output: 8

💡 Note: We need at least 2 'a's, 2 'b's, and 2 'c's. Take 3 characters from left ('a', 'a', 'b') and 5 from right ('a', 'a', 'a', 'c', 'c'). This gives us 5 'a's, 1 'b', and 2 'c's from left+right combined, but we only took 1 'b' from left, so we need to adjust. Optimal: take 8 characters total.

example_2.py — Edge Case

$ Input: s = "a", k = 1

› Output: -1

💡 Note: The string only contains 'a' but we need at least 1 of each character ('a', 'b', 'c'). Since there are no 'b' or 'c' characters, it's impossible.

example_3.py — Zero Requirement

$ Input: s = "abc", k = 0

› Output: 0

💡 Note: We need 0 of each character, so we don't need to take any characters. Return 0 minutes.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of only characters 'a', 'b', and 'c'
0 ≤ k ≤ s.length
The string may not contain all three characters

Visualization

Tap to expand

Understanding the Visualization

Count Total

First, count total characters and verify if solution exists

Sliding Window

Use window to represent middle section we want to leave

Expand & Check

Expand window right, check if remaining chars satisfy k requirement

Shrink if Invalid

If invalid, shrink window from left until valid

Track Maximum

Keep track of maximum valid window size found

Key Takeaway

🎯 Key Insight: Transform the problem from 'minimize characters taken' to 'maximize characters left in middle' using sliding window technique!

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a sliding window approach with a key insight: instead of minimizing characters taken from ends, maximize the middle substring we can leave untouched. This transforms the problem into finding the longest window where the remaining characters still satisfy the k requirement. Time complexity: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(n²)	O(1)	Try all possible combinations of taking characters from left and right
Sliding Window (Optimal)	O(n)	O(1)	Use sliding window to find the longest middle section we can leave untouched

Brute Force (Try All Combinations) — Algorithm Steps

Count total occurrences of each character
If any character appears less than k times, return -1
For each possible left_count (0 to n):
- Count characters taken from left
- Try taking from right until we have k of each character
- Track minimum total characters taken

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Left=0

Take 0 from left, find minimum needed from right

Try Left=1

Take 1 from left, find minimum needed from right

Continue

Keep trying until we find the minimum total

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <limits.h>

int takeCharacters(char* s, int k) {
    if (k == 0) return 0;
    
    int n = strlen(s);
    int totalCount[3] = {0, 0, 0};
    
    // Count total characters
    for (int i = 0; i < n; i++) {
        totalCount[s[i] - 'a']++;
    }
    
    // Check if possible
    if (totalCount[0] < k || totalCount[1] < k || totalCount[2] < k) {
        return -1;
    }
    
    int minMinutes = INT_MAX;
    
    // Try all possible left counts
    for (int left = 0; left <= n; left++) {
        int leftCount[3] = {0, 0, 0};
        
        // Count characters from left
        for (int i = 0; i < left; i++) {
            leftCount[s[i] - 'a']++;
        }
        
        // Try taking from right
        int rightCount[3] = {0, 0, 0};
        int right = 0;
        
        // Take from right until we have enough of each
        while (right < n - left) {
            if (leftCount[0] + rightCount[0] >= k && 
                leftCount[1] + rightCount[1] >= k && 
                leftCount[2] + rightCount[2] >= k) {
                break;
            }
            rightCount[s[n - 1 - right] - 'a']++;
            right++;
        }
        
        // Check if we have enough
        if (leftCount[0] + rightCount[0] >= k && 
            leftCount[1] + rightCount[1] >= k && 
            leftCount[2] + rightCount[2] >= k) {
            if (left + right < minMinutes) {
                minMinutes = left + right;
            }
        }
    }
    
    return minMinutes == INT_MAX ? -1 : minMinutes;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions from left, we may need to check up to n positions from right

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for counters

✓ Linear Space

43.4K Views

High Frequency

~18 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler