Check if a String is a Palindrome

This one looks simple. The interviewer asks you to check if a word reads the same forwards and backwards. But what they really want to see is whether you reach for extra memory by reflex, or whether you can solve it in place with two pointers. So let us talk it through the way you would in the room.

🔄 The Problem

You are given a string. You have to tell if it is a palindrome. A palindrome is a string that reads the same from the front and from the back. So “madam” read backwards is still “madam”. But “hello” backwards is “olleh”, which is different.

Here is what the input and output look like:

Input:  "madam"
Output: true

Input:  "hello"
Output: false

🐢 The Simple Approach (and why it is not the best)

The first idea most people get is easy. Just reverse the string. Then check if the reversed string equals the original one. If they match, it is a palindrome.

That works, and it is correct. But see the problem. To reverse the string, you build a whole new string in memory. So for a string of length n, you spend extra O(n) space just to hold the copy. The interviewer will ask, “can you do it without making a copy?”. And that is the real test here.

🎯 The Better Approach: Two Pointers

Here is the trick. You do not need a copy at all. You put one pointer at the start of the string. You put another pointer at the end. Then you compare those two characters.

If they are the same, you move the left pointer one step right. And you move the right pointer one step left. Then you compare again. You keep going until the two pointers meet in the middle.

If at any point the two characters do not match, you stop right away and return false. If you reach the middle without finding a mismatch, then it is a palindrome. This is the two-pointer technique. You never build a second string, so you use only O(1) extra space.

Think of it like two people checking a row of seats. One starts from the left end. The other starts from the right end. They walk toward each other and check that each pair of seats matches. The moment a pair does not match, they know something is wrong and they stop.

Steps to Check a Palindrome

1. Put a pointer left at index 0 and a pointer right at the last index.
2. While left is less than right, compare the characters at the two pointers.
3. If the characters are different, return false right away.
4. If they are the same, move left one step right and right one step left.
5. When the loop ends without a mismatch, return true.

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

// Returns true if the string reads the same both ways
bool isPalindrome(const char *s) {
    int left = 0;
    int right = (int)strlen(s) - 1;
    while (left < right) {
        if (s[left] != s[right]) return false; // mismatch found
        left++;   // move left pointer inward
        right--;  // move right pointer inward
    }
    return true; // reached the middle with no mismatch
}

int main(void) {
    printf("%s\n", isPalindrome("madam") ? "true" : "false");
    printf("%s\n", isPalindrome("hello") ? "true" : "false");
    return 0;
}

true
false

#include <iostream>
#include <string>
using namespace std;

// Returns true if the string reads the same both ways
bool isPalindrome(const string &s) {
    int left = 0;
    int right = (int)s.size() - 1;
    while (left < right) {
        if (s[left] != s[right]) return false; // mismatch found
        left++;   // move left pointer inward
        right--;  // move right pointer inward
    }
    return true; // reached the middle with no mismatch
}

int main() {
    cout << (isPalindrome("madam") ? "true" : "false") << endl;
    cout << (isPalindrome("hello") ? "true" : "false") << endl;
    return 0;
}

true
false

public class Palindrome {
    // Returns true if the string reads the same both ways
    static boolean isPalindrome(String s) {
        int left = 0;
        int right = s.length() - 1;
        while (left < right) {
            if (s.charAt(left) != s.charAt(right)) return false; // mismatch found
            left++;   // move left pointer inward
            right--;  // move right pointer inward
        }
        return true; // reached the middle with no mismatch
    }

    public static void main(String[] args) {
        System.out.println(isPalindrome("madam"));
        System.out.println(isPalindrome("hello"));
    }
}

true
false

# Returns True if the string reads the same both ways
def is_palindrome(s):
    left = 0
    right = len(s) - 1
    while left < right:
        if s[left] != s[right]:   # mismatch found
            return False
        left += 1                 # move left pointer inward
        right -= 1                # move right pointer inward
    return True                   # reached the middle with no mismatch

print(is_palindrome("madam"))
print(is_palindrome("hello"))

True
False

// Returns true if the string reads the same both ways
function isPalindrome(s) {
  let left = 0;
  let right = s.length - 1;
  while (left < right) {
    if (s[left] !== s[right]) return false; // mismatch found
    left++;   // move left pointer inward
    right--;  // move right pointer inward
  }
  return true; // reached the middle with no mismatch
}

console.log(isPalindrome("madam"));
console.log(isPalindrome("hello"));

true
false

⏱️ Time and Space Complexity

Both approaches look at every character once, so the time is the same. The big difference is the memory. The two-pointer way wins because it never makes a copy.

🧩 Key Takeaways

• ✅ A palindrome reads the same from the front and from the back.
• ✅ Reversing and comparing works but costs O(n) extra space for the copy.
• ✅ The two-pointer method checks from both ends inward in O(n) time and O(1) space.
• ✅ Stop and return false the moment two characters do not match.
• ✅ For the case-insensitive version, skip non-letters and compare in lowercase.

🚀 What’s Next?

• Reverse a String — uses the same two-pointer idea.