Existence of a Substring in a String and Its Reverse

Existence of a Substring in a String and Its Reverse - Problem

Given a string s, you need to determine if there exists any substring of length 2 that appears in both the original string and its reverse.

For example, if s = "abcd", its reverse is "dcba". You need to check if any 2-character substring from the original string also exists in the reversed string.

Goal: Return true if such a common substring exists, false otherwise.

Note: A substring is a contiguous sequence of characters within a string. The same substring can appear multiple times and at different positions.

Input & Output

example_1.py — Basic Case

$ Input: s = "leetcode"

› Output: true

💡 Note: The substring "ee" appears in both the original string "leetcode" and its reverse "edocteel" (at positions different from each other).

example_2.py — No Match Case

$ Input: s = "abcdef"

› Output: false

💡 Note: Original: "abcdef", Reversed: "fedcba". No 2-character substring from original ("ab", "bc", "cd", "de", "ef") appears in reversed ("fe", "ed", "dc", "cb", "ba").

example_3.py — Palindrome Case

$ Input: s = "abcba"

› Output: true

💡 Note: The substring "ab" from original appears as "ba" in reverse, and "bc" from original appears as "cb" in reverse. Both are valid matches.

Constraints

1 ≤ s.length ≤ 1000
s consists of lowercase English letters only
Note: If string length < 2, return false as no 2-character substring exists

Visualization

Tap to expand

Understanding the Visualization

Read the Secret Message

You have a secret message written on paper

Use the Magic Mirror

Hold the message up to a special mirror that shows the reverse

Smart Detective Work

Instead of writing down all codes from both sides, you read the original and immediately check if each 2-letter code's reverse was already seen

Eureka Moment

The moment you find a match, you've solved the case!

Key Takeaway

🎯 Key Insight: The detective doesn't need to write down all reversed codes separately. Instead, for each original code, they immediately check if they've seen its reverse before. This one-pass approach is both elegant and efficient!

Asked in

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

The optimal solution uses a one-pass hash table approach with O(n) time complexity. For each 2-character substring, we check if its reverse already exists in our hash set. If found, we return true immediately. If not, we add the current substring to the set. This elegant approach combines the benefits of hash table lookup with early termination, making it the most efficient solution for this problem.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table	O(n)	O(n)	First pass stores all 2-char substrings from original string in hash set, second pass checks reversed substrings
Brute Force (Nested Loops)	O(n²)	O(1)	Generate all 2-character substrings from both original and reversed string, then compare each pair
One-Pass Hash Table (Optimal)	O(n)	O(n)	Process original string once, checking if reverse of each substring already exists or storing it for future matches

Two-Pass Hash Table — Algorithm Steps

Create the reversed version of the input string
First pass: Extract all 2-character substrings from the original string and store them in a hash set
Second pass: Extract all 2-character substrings from the reversed string
For each reversed substring, check if it exists in the hash set
Return true immediately if a match is found, false if no matches after complete iteration

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Table

Store all 2-character substrings from original string

Process Reversed String

Extract substrings from reversed string and check against hash table

Hash Lookup

O(1) lookup time for each reversed substring

Return Result

Return true on first match found

Code -

solution.c — C

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

#define MAX_SUBSTRINGS 1000

struct HashEntry {
    char substr[3];
    bool exists;
};

struct HashEntry hashTable[MAX_SUBSTRINGS];
int hashSize = 0;

int hash(char* str) {
    return (str[0] * 31 + str[1]) % MAX_SUBSTRINGS;
}

void addSubstring(char* substr) {
    int index = hash(substr);
    while (hashTable[index].exists && strcmp(hashTable[index].substr, substr) != 0) {
        index = (index + 1) % MAX_SUBSTRINGS;
    }
    if (!hashTable[index].exists) {
        strcpy(hashTable[index].substr, substr);
        hashTable[index].exists = true;
        hashSize++;
    }
}

bool findSubstring(char* substr) {
    int index = hash(substr);
    while (hashTable[index].exists) {
        if (strcmp(hashTable[index].substr, substr) == 0) {
            return true;
        }
        index = (index + 1) % MAX_SUBSTRINGS;
    }
    return false;
}

bool findSubstringInReverse(char* s) {
    int len = strlen(s);
    if (len < 2) {
        return false;
    }
    
    // Initialize hash table
    memset(hashTable, 0, sizeof(hashTable));
    hashSize = 0;
    
    // First pass: store all 2-char substrings from original
    char substr[3];
    substr[2] = '\0';
    for (int i = 0; i < len - 1; i++) {
        substr[0] = s[i];
        substr[1] = s[i + 1];
        addSubstring(substr);
    }
    
    // Second pass: check reversed string substrings
    for (int i = len - 1; i > 0; i--) {
        substr[0] = s[i];
        substr[1] = s[i - 1];
        if (findSubstring(substr)) {
            return true;
        }
    }
    
    return false;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

First pass takes O(n) to store all substrings, second pass takes O(n) to check all reversed substrings against hash set (O(1) lookup)

✓ Linear Growth

Space Complexity

O(n)

Hash set can store up to O(n) different 2-character substrings in worst case

⚡ Linearithmic Space

42.4K 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-Pass Hash Table — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler