Maximize the Confusion of an Exam - Problem

A teacher is writing a test with n true/false questions, with 'T' denoting true and 'F' denoting false. He wants to confuse the students by maximizing the number of consecutive questions with the same answer (multiple trues or multiple falses in a row).

You are given a string answerKey, where answerKey[i] is the original answer to the i^th question. In addition, you are given an integer k, the maximum number of times you may perform the following operation:

Change the answer key for any question to 'T' or 'F' (i.e., set answerKey[i] to 'T' or 'F').

Return the maximum number of consecutive 'T's or 'F's in the answer key after performing the operation at most k times.

Input & Output

Example 1 — Basic Case

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

› Output: 4

💡 Note: We can change at most 2 characters. Change both F's to T's to get "TTTT" with length 4, or change both T's to F's to get "FFFF" with length 4.

Example 2 — Mixed Pattern

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

› Output: 3

💡 Note: We can change 1 character. Change the middle F to T to get "TTFT" or "TFTT", giving us a maximum consecutive length of 3 T's.

Example 3 — No Changes Needed

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

› Output: 8

💡 Note: All characters are already the same, so we don't need any changes. The entire string has length 8.

Constraints

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

Visualization

Tap to expand

Asked in

F Facebook 35 a Amazon 28 G Google 22

The key insight is to use sliding window technique to find the longest substring where we can change at most k characters. Apply sliding window twice: once for maximizing T's and once for F's. Best approach is sliding window with Time: O(n), Space: O(1).

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Binary Search Answer

⏱️ Time: N/A Space: N/A

Brute Force - Check All Substrings

⏱️ Time: O(n³) Space: O(1)

For every possible substring, calculate how many changes are needed to make all characters the same (either all T's or all F's). Keep track of the longest valid substring.

Sliding Window - Two Passes

⏱️ Time: O(n) Space: O(1)

Apply sliding window twice: once to find the longest substring of T's (changing at most k F's), and once for F's (changing at most k T's). Return the maximum of both results.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int maxLength(const char* answerKey, char target, int k) {
    int len = strlen(answerKey);
    int left = 0;
    int changes = 0;
    int max_len = 0;
    
    for (int right = 0; right < len; right++) {
        // Expand window
        if (answerKey[right] != target) {
            changes++;
        }
        
        // Shrink window if too many changes
        while (changes > k) {
            if (answerKey[left] != target) {
                changes--;
            }
            left++;
        }
        
        // Update maximum length
        max_len = max(max_len, right - left + 1);
    }
    
    return max_len;
}

int solution(const char* answerKey, int k) {
    // Try both T and F, return maximum
    return max(maxLength(answerKey, 'T', k), maxLength(answerKey, 'F', k));
}

int main() {
    char answerKey[100001];
    int k;
    
    fgets(answerKey, sizeof(answerKey), stdin);
    // Remove newline if present
    int len = strlen(answerKey);
    if (len > 0 && answerKey[len-1] == '\n') {
        answerKey[len-1] = '\0';
    }
    
    scanf("%d", &k);
    
    int result = solution(answerKey, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ Linear Space

32.0K Views

Medium Frequency

~15 min Avg. Time

892 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