Maximize the Confusion of an Exam - Practice Coding Problems

Maximize the Confusion of an Exam - Problem

A teacher is preparing a true/false exam to maximize student confusion by creating the longest possible sequence of consecutive identical answers. The exam consists of n questions, where each answer is either 'T' (True) or 'F' (False).

You are given a string answerKey representing the original answers, and an integer k representing the maximum number of answers you can change. Your goal is to find the maximum length of consecutive identical answers (all T's or all F's) after making at most k changes.

Example: If answerKey = "TTFTTFTT" and k = 1, you could change one 'F' to 'T' to get "TTTTTFTT", creating a sequence of 5 consecutive T's.

Input & Output

example_1.py — Basic case with k=1

$ Input: answerKey = "TTFF", k = 2

› Output: 4

💡 Note: We can change both F's to T's to get "TTTT", or change both T's to F's to get "FFFF". Either way gives us 4 consecutive identical answers.

example_2.py — Mixed string with limited changes

$ Input: answerKey = "TFFT", k = 1

› Output: 3

💡 Note: We can change the middle F to T to get "TTFT" (3 consecutive T's at start), or change a T to F to get "TFFF" (3 consecutive F's at end). Maximum is 3.

example_3.py — All same characters

$ Input: answerKey = "TTTT", k = 2

› Output: 4

💡 Note: The string already has 4 consecutive T's, so no changes needed. We don't need to use any of our k=2 changes.

Constraints

n == answerKey.length
1 ≤ n ≤ 5 × 10⁴
answerKey[i] is either 'T' or 'F'
0 ≤ k ≤ n

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with empty window, trying to maximize T's

Expand

Expand right pointer, count F's (characters to change)

Contract

When F count > k, shrink from left until valid

Track Maximum

Keep track of largest valid window size seen

Repeat for F's

Do the same process trying to maximize F's

Key Takeaway

🎯 Key Insight: Sliding window allows us to efficiently find the longest subarray where minority characters ≤ k, avoiding the need to check all possible subarrays.

Asked in

a Amazon 25 G Google 18 ⊞ Microsoft 15 f Meta 12

The optimal solution uses the sliding window technique with two pointers. We try to maximize consecutive T's and consecutive F's separately, using at most k changes for the minority character in each window. The algorithm runs in O(n) time and O(1) space, making it highly efficient for large inputs.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Answer	O(n log n)	O(1)	Binary search on the length, check if achievable with sliding window
Brute Force (Check All Subarrays)	O(n³)	O(1)	Check every possible subarray and count changes needed
Sliding Window (Two Pointers)	O(n)	O(1)	Use sliding window technique to find longest valid subarray

Binary Search on Answer — Algorithm Steps

Binary search on length from 1 to n
For each mid length, check if achievable
Use sliding window to check: can we make any substring of length 'mid' uniform with ≤ k changes?
If yes, try larger length; if no, try smaller length

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize search range

Set left=1, right=n (string length)

Test middle length

For mid = (left+right)/2, check if achievable

Validate with sliding window

Use sliding window to check if any substring of length mid works

Adjust search range

If achievable, search right half; else search left half

Code -

solution.c — C

bool checkChar(char* answerKey, int k, int length, char target) {
    int count = 0;
    int n = strlen(answerKey);
    
    // Check first window
    for (int i = 0; i < length; i++) {
        if (answerKey[i] != target) {
            count++;
        }
    }
    if (count <= k) return true;
    
    // Slide the window
    for (int i = length; i < n; i++) {
        if (answerKey[i] != target) {
            count++;
        }
        if (answerKey[i - length] != target) {
            count--;
        }
        if (count <= k) return true;
    }
    return false;
}

bool canAchieveLength(char* answerKey, int k, int length) {
    return checkChar(answerKey, k, length, 'T') || 
           checkChar(answerKey, k, length, 'F');
}

int maxConsecutiveAnswers(char* answerKey, int k) {
    int left = 1, right = strlen(answerKey);
    int result = 1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (canAchieveLength(answerKey, k, mid)) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(log n) binary search iterations, each taking O(n) to validate

⚡ Linearithmic

Space Complexity

O(1)

Only using variables for binary search and sliding window

✓ Linear Space

42.3K Views

Medium Frequency

~15 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

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler