Check if the given string is the same as its reflection in a mirror

0 0 4 minutes read

Given a string S containing only uppercase English characters. The task is to find whether S is the same as its reflection in a mirror.
Examples:

Input: str = "AMA"
Output: YES
AMA is same as its reflection in the mirror.

Input: str = "ZXZ"
Output: NO

Approach: The string obviously has to be a palindrome, but that alone is not enough. All characters in the string should be symmetric so that their reflection is also the same. The symmetric characters are AHIMOTUVWXY.

Store the symmetric characters in an unordered_set.
Traverse the string and check if there is any non-symmetric character present in the string. If yes then return false.
Else check if the string is palindrome or not. If the string is palindrome also then return true else return false.

Below is the implementation of the above approach:

C++

// C++ implementation of the 
// above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to check reflection
bool isReflectionEqual(string s)
{
    // Symmetric characters
    unordered_set<char> symmetric = { 'A', 'H', 'I', 'M',
                        'O', 'T', 'U', 'V', 'W', 'X', 'Y' };
 
    int n = s.length();
 
    for (int i = 0; i < n; i++)
        // If any non-symmetric character is
        // present, the answer is NO
        if (symmetric.find(s[i]) == symmetric.end())
            return false;
 
    string rev = s;
    reverse(rev.begin(), rev.end());
 
    // Check if the string is a palindrome
    if (rev == s)
        return true;
    else
        return false;
}
 
// Driver code
int main()
{
    string s = "MYTYM";
    if (isReflectionEqual(s))
        cout << "YES";
    else
        cout << "NO";
}

Java

// Java implementation of above approach
import java.util.*;
 
class GFG 
{
 
    static String Reverse(String s)
    {
        char[] charArray = s.toCharArray();
        reverse(charArray, 0, charArray.length - 1);
        return new String(charArray);
    }
 
    // Function to check reflection 
    static boolean isReflectionEqual(String s) 
    {
        HashSet<Character> symmetric = new HashSet<>();
 
        // Symmetric characters 
        symmetric.add('A');
        symmetric.add('H');
        symmetric.add('I');
        symmetric.add('M');
        symmetric.add('O');
        symmetric.add('T');
        symmetric.add('U');
        symmetric.add('V');
        symmetric.add('W');
        symmetric.add('X');
        symmetric.add('Y');
 
        int n = s.length();
 
        // If any non-symmetric character is
        for (int i = 0; i < n; i++) 
         
        // present, the answer is NO 
        {
            if (symmetric.contains(s.charAt(i)) == false) 
            {
                return false;
            }
        }
 
        String rev = s;
        s = Reverse(s);
 
        // Check if the String is a palindrome 
        if (rev.equals(s)) 
        {
            return true;
        } else {
            return false;
        }
    }
     
    // Reverse the letters of the word 
    static void reverse(char str[], int start, int end) 
    {
 
        // Temporary variable to store character 
        char temp;
        while (start <= end)
        {
            // Swapping the first and last character 
            temp = str[start];
            str[start] = str[end];
            str[end] = temp;
            start++;
            end--;
        }
    }
     
    // Driver code 
    public static void main(String[] args) 
    {
        String s = "MYTYM";
        if (isReflectionEqual(s))
        {
            System.out.println("YES");
        } 
        else
        {
            System.out.println("NO");
        }
    }
}
 
// This code contributed by Rajput-Ji

Python3

# Python3 implementation of the 
# above approach
 
# Function to check reflection
def isReflectionEqual(s):
 
    # Symmetric characters
    symmetric = dict()
 
    str1 = "AHIMOTUVWXY"
 
    for i in str1:
        symmetric[i] = 1
 
    n = len(s)
 
    for i in range(n):
         
        # If any non-symmetric character 
        # is present, the answer is NO
        if (symmetric[s[i]] == 0):
            return False
 
    rev = s[::-1]
 
    # Check if the is a palindrome
    if (rev == s):
        return True
    else:
        return False
 
# Driver Code
s = "MYTYM"
if (isReflectionEqual(s)):
    print("YES")
else:
    print("NO")
 
# This code is contributed by Mohit Kumar

C#

// C# implementation of the above approach 
using System;
using System.Collections.Generic ;
 
class GFG
{
 
    static string Reverse( string s )
    {
        char[] charArray = s.ToCharArray();
        Array.Reverse( charArray );
        return new string( charArray );
    }
     
    // Function to check reflection 
    static bool isReflectionEqual(string s) 
    { 
        HashSet<char> symmetric = new HashSet<char>();
         
        // Symmetric characters 
        symmetric.Add('A');
        symmetric.Add('H');
        symmetric.Add('I');
        symmetric.Add('M');
        symmetric.Add('O');
        symmetric.Add('T');
        symmetric.Add('U');
        symmetric.Add('V');
        symmetric.Add('W');
        symmetric.Add('X');
        symmetric.Add('Y');
     
        int n = s.Length; 
     
        for (int i = 0; i < n; i++) 
         
            // If any non-symmetric character is 
            // present, the answer is NO 
            if (symmetric.Contains(s[i]) == false) 
                return false; 
     
        string rev = s; 
        s = Reverse(s); 
     
        // Check if the string is a palindrome 
        if (rev == s) 
            return true; 
        else
            return false; 
    } 
 
    // Driver code 
    static public void Main() 
    { 
        string s = "MYTYM"; 
        if (isReflectionEqual(s)) 
            Console.WriteLine("YES"); 
        else
            Console.WriteLine("NO"); 
    } 
}
 
// This code is contributed by Ryuga

Javascript

<script>
 
// JavaScript implementation of above approach
     
    function Reverse(s)
    {
        let charArray = s.split("");
        reverse(charArray, 0, charArray.length - 1);
        return charArray.join("");
    }
     
    // Function to check reflection 
    function isReflectionEqual(s)
    {
        let symmetric = new Set();
   
        // Symmetric characters 
        symmetric.add('A');
        symmetric.add('H');
        symmetric.add('I');
        symmetric.add('M');
        symmetric.add('O');
        symmetric.add('T');
        symmetric.add('U');
        symmetric.add('V');
        symmetric.add('W');
        symmetric.add('X');
        symmetric.add('Y');
   
        let n = s.length;
   
        // If any non-symmetric character is
        for (let i = 0; i < n; i++) 
           
        // present, the answer is NO 
        {
            if (symmetric.has(s[i]) == false) 
            {
                return false;
            }
        }
   
        let rev = s;
        s = Reverse(s);
   
        // Check if the String is a palindrome 
        if (rev==(s)) 
        {
            return true;
        } else {
            return false;
        }
    }
     
    // Reverse the letters of the word
    function reverse(str,start,end)
    {
        // Temporary variable to store character 
        let temp;
        while (start <= end)
        {
            // Swapping the first and last character 
            temp = str[start];
            str[start] = str[end];
            str[end] = temp;
            start++;
            end--;
        }
    }
     
    // Driver code 
    let s = "MYTYM";
        if (isReflectionEqual(s))
        {
            document.write("YES");
        } 
        else
        {
            document.write("NO");
        }
     
 
// This code is contributed by unknown2108
 
</script>

Output:

YES

Time Complexity: O(N)
Auxiliary Space: O(1)

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 zambiatek!