First string from the given array whose reverse is also present in the same array

Given a string array str[], the task is to find the first string from the given array whose reverse is also present in the same array. If there is no such string then print -1.
Examples:

Input: str[] = {“geeks”, “for”, “skeeg”} 
Output: geeks 
“geeks” is the first string from the array whose reverse is also present in the array i.e. “skeeg”.
Input: str[] = {“there”, “you”, “are”} 
Output: -1 

Approach: Traverse the array element by element and for every string, check whether there is any string that appears after the current string in the array and is equal to the reverse of it. If yes then print the current string else print -1 in the end.
Below is the implementation of the above approach: 

C++

// CPP implementation of the approach
#include<bits/stdc++.h>
using namespace std;

    // Function that returns true if s1
    // is equal to reverse of s2
    bool isReverseEqual(string s1, string s2)
    {

        // If both the strings differ in length
        if (s1.length() != s2.length())
            return false;

        int len = s1.length();
        for (int i = 0; i < len; i++)

            // In case of any character mismatch
            if (s1[i] != s2[len - i - 1])
                return false;

        return true;
    }

    // Function to return the first word whose
    // reverse is also present in the array
    string getWord(string str[], int n)
    {

        // Check every string
        for (int i = 0; i < n - 1; i++)

            // Pair with every other string
            // appearing after the current string
            for (int j = i + 1; j < n; j++)

                // If first string is equal to the
                // reverse of the second string
                if (isReverseEqual(str[i], str[j]))
                    return str[i];

        // No such string exists
        return "-1";
    }

    // Driver code
    int main()
    {
        string str[] = { "geeks", "for", "skeeg" };

        cout<<(getWord(str, 3));
    }

// This code is contributed by
// Surendra_Gangwar

Java

// Java implementation of the approach
class GFG {

    // Function that returns true if s1
    // is equal to reverse of s2
    static boolean isReverseEqual(String s1, String s2)
    {

        // If both the strings differ in length
        if (s1.length() != s2.length())
            return false;

        int len = s1.length();
        for (int i = 0; i < len; i++)

            // In case of any character mismatch
            if (s1.charAt(i) != s2.charAt(len - i - 1))
                return false;

        return true;
    }

    // Function to return the first word whose
    // reverse is also present in the array
    static String getWord(String str[], int n)
    {

        // Check every string
        for (int i = 0; i < n - 1; i++)

            // Pair with every other string
            // appearing after the current string
            for (int j = i + 1; j < n; j++)

                // If first string is equal to the
                // reverse of the second string
                if (isReverseEqual(str[i], str[j]))
                    return str[i];

        // No such string exists
        return "-1";
    }

    // Driver code
    public static void main(String[] args)
    {
        String str[] = { "geeks", "for", "skeeg" };
        int n = str.length;

        System.out.print(getWord(str, n));
    }
}

Python3

# Python implementation of the approach

# Function that returns true if s1
# is equal to reverse of s2
def isReverseEqual(s1, s2):

    # If both the strings differ in length
    if len(s1) != len(s2):
        return False

    l = len(s1)

    for i in range(l):

        # In case of any character mismatch
        if s1[i] != s2[l-i-1]:
            return False
    return True

# Function to return the first word whose
# reverse is also present in the array
def getWord(str, n):

    # Check every string
    for i in range(n-1):

        # Pair with every other string
        # appearing after the current string
        for j in range(i+1, n):

            # If first string is equal to the
            # reverse of the second string
            if (isReverseEqual(str[i], str[j])):
                return str[i]

    # No such string exists
    return "-1"


# Driver code
if __name__ == "__main__":
    str = ["geeks", "for", "skeeg"]
    print(getWord(str, 3))

# This code is contributed by
# sanjeev2552

C#

// C# implementation of the approach
using System;

class GFG
{

    // Function that returns true if s1
    // is equal to reverse of s2
    static bool isReverseEqual(String s1, String s2)
    {

        // If both the strings differ in length
        if (s1.Length != s2.Length)
            return false;

        int len = s1.Length;
        for (int i = 0; i < len; i++)

            // In case of any character mismatch
            if (s1[i] != s2[len - i - 1])
                return false;

        return true;
    }

    // Function to return the first word whose
    // reverse is also present in the array
    static String getWord(String []str, int n)
    {

        // Check every string
        for (int i = 0; i < n - 1; i++)

            // Pair with every other string
            // appearing after the current string
            for (int j = i + 1; j < n; j++)

                // If first string is equal to the
                // reverse of the second string
                if (isReverseEqual(str[i], str[j]))
                    return str[i];

        // No such string exists
        return "-1";
    }

    // Driver code
    public static void Main(String[] args)
    {
        String []str = { "geeks", "for", "skeeg" };
        int n = str.Length;

        Console.Write(getWord(str, n));
    }
}

// This code has been contributed by 29AjayKumar

PHP

<?php
// PHP implementation of the approach

// Function that returns true if s1
// is equal to reverse of s2
function isReverseEqual($s1, $s2)
{

    // If both the strings differ in length
    if (strlen($s1) != strlen($s2))
        return false;

    $len = strlen($s1);
    for ($i = 0; $i < $len; $i++)

        // In case of any character mismatch
        if ($s1[$i] != $s2[$len - $i - 1])
            return false;

    return true;
}

// Function to return the first word whose
// reverse is also present in the array
function getWord($str, $n)
{

    // Check every string
    for ($i = 0; $i < $n - 1; $i++)

        // Pair with every other string
        // appearing after the current string
        for ($j = $i + 1; $j < $n; $j++)

            // If first string is equal to the
            // reverse of the second string
            if (isReverseEqual($str[$i], $str[$j]))
                return $str[$i];

    // No such string exists
    return "-1";
}

// Driver code
$str = array( "geeks", "for", "skeeg" );
$n = count($str);

print(getWord($str, $n));

// This code is contributed by mits
?>

Javascript

<script>
// JavaScript implementation of the approach


    // Function that returns true if s1
    // is equal to reverse of s2
    function isReverseEqual(s1, s2)
    {

        // If both the strings differ in length
        if (s1.length != s2.length)
            return false;

        let len = s1.length;
        for (let i = 0; i < len; i++)

            // In case of any character mismatch
            if (s1[i] != s2[len - i - 1])
                return false;

        return true;
    }

    // Function to return the first word whose
    // reverse is also present in the array
    function getWord(str, n)
    {

        // Check every string
        for (let i = 0; i < n - 1; i++)

            // Pair with every other string
            // appearing after the current string
            for (let j = i + 1; j < n; j++)

                // If first string is equal to the
                // reverse of the second string
                if (isReverseEqual(str[i], str[j]))
                    return str[i];

        // No such string exists
        return "-1";
    }

    // Driver code

        let str = [ "geeks", "for", "skeeg" ];

        document.write(getWord(str, 3));




// This code is contributed by Surbhi Tyagi.
</script>

Output:

geeks

Time Complexity: O(n³), as nested loops are used
Auxiliary Space: O(1), as no extra space is used

Efficient Approach: O(n) approach. This approach requires a Hashmap to store words as traversed. As we traverse, if reverse of current word found in the map, then reversed word is the first occurrence that is the answer. If not found at the end of traversal, return -1. 
Below is the implementation of the above approach: 

C++

#include <bits/stdc++.h>
using namespace std;

// Method that returns first occurrence of reversed word.
string getReversed(string words[], int length)
{

  // Hashmap to store word as we traverse
  map<string,bool> reversedWordMap;
  for(int i = 0; i < length; i++)
  {

    string reversedString = words[i];
    reverse(reversedString.begin(),reversedString.end());

    // check if reversed word exists in map.
    if (reversedWordMap.find(reversedString) !=
        reversedWordMap.end() and reversedWordMap[reversedString])
      return reversedString;
    else

      // else put the word in map
      reversedWordMap[words[i]] = true;
  }
  return "-1";
}

// Driver code
int main()
{
    string words[] = {"some", "geeks", "emos", "for", "skeeg"};
    int length = sizeof(words) / sizeof(words[0]);
    cout << getReversed(words, length);
    return 0;
}

// This code is contributed by divyesh072019

Java

import java.util.HashMap;
import java.util.Map;

public class ReverseExist {

    // Driver Code
    public static void main(String[] args) {
        String[] words = {"some", "geeks", "emos", "for", "skeeg"};
        System.out.println(getReversed(words, words.length));
    }

    // Method that returns first occurrence of reversed word.
    private static String getReversed(String[] words, int length) {

        // Hashmap to store word as we traverse
        Map<String, Boolean> reversedWordMap = new HashMap<>();

        for (String word : words) {
            StringBuilder reverse = new StringBuilder(word);
            String reversed = reverse.reverse().toString();

            // check if reversed word exists in map.
            Boolean exists = reversedWordMap.get(reversed);
            if (exists != null && exists.booleanValue()) {
                return reversed;
            } else {
                // else put the word in map
                reversedWordMap.put(word, true);
            }

        }
        return "-1";
    }
}
// Contributed by srika21m

Python3

# Method that returns first occurrence of reversed word.
def getReversed(words, length):

  # Hashmap to store word as we traverse
  reversedWordMap = {}
  for word in words:
    reversedString = word[::-1]

    # check if reversed word exists in map.
    if (reversedString in reversedWordMap and reversedWordMap[reversedString]):
      return reversedString
    else:

      # else put the word in map
      reversedWordMap[word] = True
  return "-1"

# Driver Code
if __name__ == "__main__":
  words = ["some", "geeks", "emos", "for", "skeeg"]
  print(getReversed(words, len(words)))

  # This code is contributed by chitranayal

C#

using System;
using System.Collections.Generic;
class GFG
{

    // Method that returns first occurrence of reversed word.
    static string getReversed(string[] words, int length)
    {

      // Hashmap to store word as we traverse
      Dictionary<string, bool> reversedWordMap =
        new Dictionary<string, bool>();
      for(int i = 0; i < length; i++)
      {

        char[] reversedString = words[i].ToCharArray();
        Array.Reverse(reversedString);

        // check if reversed word exists in map.
        if (reversedWordMap.ContainsKey(new string(reversedString)) &&
            reversedWordMap[new string(reversedString)])
          return new string(reversedString);
        else

          // else put the word in map
          reversedWordMap[words[i]] = true;
      }
      return "-1";
    }

  // Driver code
  static void Main()
  {
    string[] words = {"some", "geeks", "emos", "for", "skeeg"};
    int length = words.Length;
    Console.Write(getReversed(words, length));
  }
}

// This code is contributed by divyeshrabadiya07

Javascript

<script>

// Method that returns first occurrence of reversed word.
function  getReversed(words,length)
{
    // Hashmap to store word as we traverse
        let reversedWordMap = new Map();

        for (let word=0;word<words.length;word++) {
            let reverse = words[word].split("");
            let reversed = reverse.reverse().join("");

            if (reversedWordMap.has(reversed) &&
            reversedWordMap.get(reversed))
                  return reversed;
            else

                  // else put the word in map
                  reversedWordMap.set(words[word] , true);


        }
        return "-1";
}

// Driver code
let words=["some", "geeks", "emos", "for", "skeeg"];
document.write(getReversed(words, words.length));

// This code is contributed by rag2127
</script>

Output:

some

Time Complexity: O(nlogn)

Auxiliary Space: O(n)