Valid Palindrome IV - Practice Coding Problems

Valid Palindrome IV - Problem

You are given a 0-indexed string s consisting of only lowercase English letters. Your task is to determine if you can transform this string into a palindrome by performing exactly one or two character changes.

In one operation, you can change any character of s to any other lowercase English letter. The challenge is that you must use exactly 1 or 2 operations - no more, no less!

Return true if you can make s a palindrome after performing exactly one or two operations, or false otherwise.

Example: For s = "abcdecba", you need exactly 1 change (the middle 'd' → any letter) to make it palindromic, so return true.

Input & Output

example_1.py — Basic Case

$ Input: s = "abcdecba"

› Output: true

💡 Note: We can change s[3] = 'd' to 'e' (or s[4] = 'e' to 'd') to make "abceecba" which is a palindrome. This requires exactly 1 operation.

example_2.py — Two Operations

$ Input: s = "abc"

› Output: true

💡 Note: We can change s[0] = 'a' to 'c' and s[2] = 'c' to 'a' to make "cba" which becomes "cbc" (palindrome). Or change s[0] to 'b' and s[2] to 'b' to make "bbb". This requires exactly 2 operations.

example_3.py — Already Palindrome

$ Input: s = "racecar"

› Output: false

💡 Note: The string is already a palindrome, so it requires 0 operations. Since we need exactly 1 or 2 operations, we return false.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of only lowercase English letters
Must use exactly 1 or 2 operations (not 0, not 3+)

Visualization

Tap to expand

Understanding the Visualization

Place Mirror Line

Imagine a mirror line in the center of the string

Compare Reflections

Check if each character matches its mirror reflection

Count Broken Pairs

Each mismatch represents a 'broken' mirror pair

Validate Repair Cost

We can only afford to fix exactly 1-2 broken pairs

Key Takeaway

🎯 Key Insight: Each mismatched pair represents one operation needed. We need exactly 1-2 mismatches to satisfy the constraint of using exactly 1-2 operations.

Asked in

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

The optimal solution uses two pointers to count mismatched character pairs from both ends of the string. Since we need exactly 1 or 2 operations, we return true only when there are exactly 1 or 2 mismatched pairs. This runs in O(n) time with O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(n³)	O(n)	Try changing every possible 1-2 character combinations and check if result is palindromic
Two Pointers (Optimal)	O(n)	O(1)	Count mismatched character pairs from both ends to determine if exactly 1-2 operations needed

Brute Force (Try All Combinations) — Algorithm Steps

For each position i, try changing s[i] to every other lowercase letter
Check if the resulting string is a palindrome
For each pair of positions (i,j), try changing both s[i] and s[j] to every combination of letters
Check if any resulting string is a palindrome
Return true if any valid palindrome is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Single Changes

For each position, try all 26 possible character replacements

Check Palindrome

Test if each modification creates a palindrome

Try Double Changes

For each pair of positions, try all 26×26 combinations

Return Result

Return true if any valid palindrome is found

Code -

solution.c — C

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

bool isPalindrome(char* s, int len) {
    int left = 0, right = len - 1;
    while (left < right) {
        if (s[left] != s[right]) return false;
        left++;
        right--;
    }
    return true;
}

bool canMakePaliWithOneOrTwoOps(char* s) {
    int n = strlen(s);
    char modified[1001];
    
    // Try changing exactly 1 character
    for (int i = 0; i < n; i++) {
        for (char c = 'a'; c <= 'z'; c++) {
            if (c != s[i]) {
                strcpy(modified, s);
                modified[i] = c;
                if (isPalindrome(modified, n)) {
                    return true;
                }
            }
        }
    }
    
    // Try changing exactly 2 characters
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            for (char c1 = 'a'; c1 <= 'z'; c1++) {
                for (char c2 = 'a'; c2 <= 'z'; c2++) {
                    if (c1 != s[i] || c2 != s[j]) {
                        strcpy(modified, s);
                        modified[i] = c1;
                        modified[j] = c2;
                        if (isPalindrome(modified, n)) {
                            return true;
                        }
                    }
                }
            }
        }
    }
    
    return false;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    // Remove newline and quotes
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = 0;
    }
    printf("%s\n", canMakePaliWithOneOrTwoOps(s) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) combinations to try × O(n) palindrome check for each

⚠ Quadratic Growth

Space Complexity

O(n)

Space for creating modified strings during checking

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~15 min Avg. Time

850 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