Find First Palindromic String in the Array

Find First Palindromic String in the Array - Problem

You're given an array of strings and need to find the first palindromic string that appears in the array. A palindromic string reads the same forwards and backwards, like "racecar" or "level".

Goal: Return the first palindrome you encounter while traversing the array from left to right. If no palindromic string exists in the array, return an empty string "".

Examples of palindromes: "a", "aba", "madam", "noon"

Input: An array of strings words
Output: The first palindromic string found, or "" if none exists

Input & Output

example_1.py — Basic Case

$ Input: ["abc", "car", "ada", "racecar", "cool"]

› Output: "ada"

💡 Note: The first palindromic string in the array is "ada" at index 2. Even though "racecar" is also a palindrome, "ada" appears first.

example_2.py — No Palindrome

$ Input: ["notapalindrome", "raceacar"]

› Output: ""

💡 Note: Neither "notapalindrome" nor "raceacar" are palindromes, so we return an empty string.

example_3.py — Single Character

$ Input: ["def", "ghi"]

› Output: "def"

💡 Note: Single characters are always palindromes. "def" is the first string, and its first character "d" would make it... wait, "def" is not a palindrome. Actually "d", "e", "f" as individual characters are palindromes, but "def" as a whole is not. The correct answer would be "" for this input.

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 100
words[i] consists only of lowercase English letters

Visualization

Tap to expand

Understanding the Visualization

Start Investigation

Begin with the first word in your case files

Mirror Test

Use two magnifying glasses from opposite ends of the word

Compare Characters

Check if the characters under each magnifying glass match

Move Inward

If they match, move both magnifying glasses closer to the center

Conclusion

If all character pairs match, you found your palindrome mystery word!

Key Takeaway

🎯 Key Insight: By using two pointers moving inward, we only need to check half the characters and can detect non-palindromes early, making this the most efficient approach!

Asked in

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

The optimal solution uses the two pointers technique to check each string for palindrome property. For each string, we place one pointer at the beginning and one at the end, comparing characters while moving inward. This approach has O(n × m) time complexity and O(1) space complexity, making it both time and space efficient.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n * m)	O(1)	Check palindrome using two pointers from both ends moving inward
Brute Force (String Reversal)	O(n * m)	O(m)	Check each string by reversing it and comparing with original

Two Pointers (Optimal) — Algorithm Steps

Iterate through each string in the array
For each string, initialize left pointer at start and right pointer at end
Compare characters at left and right positions
If characters match, move both pointers inward
If characters don't match, string is not palindrome, move to next string
If pointers meet or cross, string is palindrome - return it
If no palindrome found, return empty string

Visualization

Tap to expand

Step-by-Step Walkthrough

Check 'racecar'

Start with pointers at 'r' and 'r' - they match!

Move inward

Pointers now at 'a' and 'a' - they match!

Continue checking

Pointers at 'c' and 'c' - they match!

Pointers meet

Pointers crossed - all characters matched, it's a palindrome!

Code -

solution.c — C

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

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

char* firstPalindrome(char** words, int wordsSize) {
    for (int i = 0; i < wordsSize; i++) {
        if (isPalindrome(words[i])) {
            return words[i];
        }
    }
    return "";
}

int main() {
    char* words[] = {"abc", "car", "ada", "racecar", "cool"};
    int wordsSize = 5;
    printf("%s\n", firstPalindrome(words, wordsSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

Where n is the number of strings and m is the average length of strings. In worst case, we check all characters of all strings, but often terminate early.

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables, no additional space proportional to input size.

✓ Linear Space

42.2K Views

Medium Frequency

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

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler