Sentence Palindrome (Palindrome after removing spaces, dots, .. etc)

Write a program to check if a sentence is a palindrome or not. You can ignore white spaces and other characters to consider sentences as a palindrome.

Examples: 

Input : str = "Too hot to hoot."
Output : Sentence is palindrome.

Input : str = "Abc def ghi jklm."
Output : Sentence is not palindrome.

Note: There may be multiple spaces and/or dots between two words. 

Method#1: To find if a sentence is palindrome, compare each character from left and right. If they are equal, compare until left and right of string are equal or right becomes less than left. Remember to ignore white spaces and other characters in a string.  

Implementation:

C++

// CPP program to find if a sentence is
// palindrome
#include <bits/stdc++.h>
using namespace std;

// To check sentence is palindrome or not
bool sentencePalindrome(string str)
{
    int l = 0, h = str.length() - 1;

    // Lowercase string
    for (int i = 0; i <= h; i++)
        str[i] = tolower(str[i]);

    // Compares character until they are equal
    while (l <= h) {

        // If there is another symbol in left
        // of sentence
        if (!(str[l] >= 'a' && str[l] <= 'z'))
            l++;

        // If there is another symbol in right
        // of sentence
        else if (!(str[h] >= 'a' && str[h] <= 'z'))
            h--;

        // If characters are equal
        else if (str[l] == str[h])
            l++, h--;

        // If characters are not equal then
        // sentence is not palindrome
        else
            return false;
    }

    // Returns true if sentence is palindrome
    return true;
}

// Driver program to test sentencePalindrome()
int main()
{
    string str = "Too hot to hoot.";

    if (sentencePalindrome(str))
        cout << "Sentence is palindrome.";
    else
        cout << "Sentence is not palindrome.";

    return 0;
}

Java

// Java program to find if a sentence is
// palindrome
public class GFG
{
    // To check sentence is palindrome or not
    static boolean sentencePalindrome(String str)
    {
        int l = 0;
        int h = str.length()-1;

        // Lowercase string
        str = str.toLowerCase();

        // Compares character until they are equal
        while(l <= h)
        {

            char getAtl = str.charAt(l);
            char getAth = str.charAt(h);

            // If there is another symbol in left
            // of sentence
            if (!(getAtl >= 'a' && getAtl <= 'z'))
                l++;

            // If there is another symbol in right
            // of sentence
            else if(!(getAth >= 'a' && getAth <= 'z'))
                h--;

            // If characters are equal
            else if( getAtl == getAth)
            {
                l++;
                h--;
            }

            // If characters are not equal then
            // sentence is not palindrome
            else
                return false;
        }

        // Returns true if sentence is palindrome
        return true;
    }

    // Driver program to test sentencePallindrome()
    public static void main(String[] args)
    {
        String str = "Too hot to hoot.";
        if( sentencePalindrome(str))
          System.out.println("Sentence is palindrome");
        else
          System.out.println("Sentence is not" + " " +
                                         "palindrome");
    }
}

//This code is contributed by Sumit Ghosh

Python3

# Python program to find if a sentence is palindrome
# To check sentence is palindrome or not
def sentencePalindrome(s):
    l, h = 0, len(s) - 1

    # Lowercase string
    s = s.lower()

    # Compares character until they are equal
    while (l <= h):
        # If there is another symbol in left
        # of sentence
        if (not(s[l] >= 'a' and s[l] <= 'z')):
            l += 1

        # If there is another symbol in right
        # of sentence
        elif (not(s[h] >= 'a' and s[h] <= 'z')):
            h -= 1

        # If characters are equal
        elif (s[l] == s[h]):
            l += 1
            h -= 1

        # If characters are not equal then
        # sentence is not palindrome
        else:
            return False
    # Returns true if sentence is palindrome
    return True

# Driver program to test sentencePalindrome()
s = "Too hot to hoot."
if (sentencePalindrome(s)):
    print ("Sentence is palindrome.")
else:
    print ("Sentence is not palindrome.")

C#

// C# program to find if a
// sentence is palindrome
using System;

public class GFG
{

    // To check sentence is
    // palindrome or not
    static bool sentencePalindrome(String str)
    {
        int l = 0;
        int h = str.Length - 1;

        // Lowercase string
        str = str.ToLower();

        // Compares character until
        // they are equal
        while(l <= h)
        {

            char getAtl = str[l];
            char getAth = str[h];

            // If there is another symbol
            // in left of sentence
            if (!(getAtl >= 'a' &&
                  getAtl <= 'z'))
                l++;

            // If there is another symbol
            // in right of sentence
            else if(! (getAth >= 'a' &&
                       getAth <= 'z'))
                h--;

            // If characters are equal
            else if( getAtl == getAth)
            {
                l++;
                h--;
            }

            // If characters are not equal then
            // sentence is not palindrome
            else
                return false;
        }

        // Returns true if sentence
        // is palindrome
        return true;
    }

    // Driver Code
    public static void Main()
    {
        String str = "Too hot to hoot.";
        if( sentencePalindrome(str))
        Console.Write("Sentence is palindrome");
        else
        Console.Write("Sentence is not" + " " +
                                     "palindrome");
    }
}

// This code is contributed by Nitin Mittal.

PHP

<?php
// PHP program to find if a sentence is
// palindrome

// To check sentence is palindrome or not
function sentencePalindrome($str)
{
    $l = 0;
    $h = strlen($str)-1;

    // Lowercase string
    for ($i = 0; $i < $h; $i++)
        $str[$i] = strtolower($str[$i]);

    // Compares character until they are equal
    while ($l <= $h) {

        // If there is another symbol in left
        // of sentence
        if (!($str[$l] >= 'a' && $str[$l] <= 'z'))
            $l++;

        // If there is another symbol in right
        // of sentence
        else if (!($str[$h] >= 'a' && $str[$h] <= 'z'))
            $h--;

        // If characters are equal
        else if ($str[$l] == $str[$h])
        {
             $l++;
            $h--;
        }

        // If characters are not equal then
        // sentence is not palindrome
        else
            return false;
    }

    // Returns true if sentence is palindrome
    return true;
}

// Driver program to test sentencePalindrome()

$str = "Too hot to hoot.";

if (sentencePalindrome($str))
    echo "Sentence is palindrome.";
else
    echo "Sentence is not palindrome.";

return 0;
?>

Javascript

<script>
// Javascript program to find if a sentence is
// palindrome

    // To check sentence is palindrome or not
    function sentencePalindrome(str)
    {
        let l = 0;
        let h = str.length-1;

        // Lowercase string
        str = str.toLowerCase();

        // Compares character until they are equal
        while(l <= h)
        {

            let getAtl = str[l];
            let getAth = str[h];

            // If there is another symbol in left
            // of sentence
            if (!(getAtl >= 'a' && getAtl <= 'z'))
                l++;

            // If there is another symbol in right
            // of sentence
            else if(!(getAth >= 'a' && getAth <= 'z'))
                h--;

            // If characters are equal
            else if( getAtl == getAth)
            {
                l++;
                h--;
            }

            // If characters are not equal then
            // sentence is not palindrome
            else
                return false;
        }

        // Returns true if sentence is palindrome
        return true;
    }

    // Driver program to test sentencePallindrome()
    let str = "Too hot to hoot.";
    if( sentencePalindrome(str))
        document.write("Sentence is palindrome");
    else
        document.write("Sentence is not" + " " +
                                         "palindrome");


    //This code is contributed by avanitrachhadiya2155

</script>

Output

Sentence is palindrome.

Time Complexity: O(N) where N is the length of the sentence
Space Complexity: O(1)

Method#2: String.erase(), reverse method simultaneously

Following are steps for our idea:

• When user input an sentence, it is further passed inside a method which will evaluate the result or the logic part.
• Method uses following logic for evaluating the result:
  • It first convert all the latter in sentence to lowercase. 
  • It uses String.erase() method on sentence to erase the white-space in between the sentence.
  • Now it uses the reverse method to reverse the sentence. 
  • It checked the sentence and reversed sentence and return result.

Below are implementation of above idea.

C++

// CPP program to find if a sentence is
// palindrome
#include <bits/stdc++.h>
using namespace std;

// To check sentence is palindrome or not
bool isPalindrome(string str)
{
    // Transforming to lowercase
    transform(str.begin(), str.end(), str.begin(), ::tolower);

    // Removing the white-spaces
    str.erase(remove(str.begin(), str.end(), ' '), str.end());
    // Creating the copy to string
    string s1 = str;
    string s2 = str;
    // Reversing the string s1
    reverse(s1.begin(), s1.end());

    // Evaluating Result
    return s1 == s2;
}

// Driver program to test sentencePalindrome()
int main()
{
    string str = "Too hot to hoot";

    if (isPalindrome(str))
        cout << "Sentence is palindrome.";
    else
        cout << "Sentence is not palindrome.";

    return 0;
}

Java

import java.io.*;

// Java program to find if a sentence is
// palindrome
public class GFG
{
    // To check sentence is palindrome or not
    static boolean sentencePalindrome(String s)
    {
        if(s.isEmpty())         // if String s is empty return true
        return true;

    String str = s.toLowerCase();// convert the whole string into lower case alphabet

    //remove non-alphanumeric characters
    // replace the given string with empty string except the pattern [^a-zA-Z0-9]
    str = str.replaceAll("[^a-zA-Z0-9]", "");

    //The reverse() method of StringBuilder is used to reverse the characters in the StringBuilder.
    StringBuilder revstr = new StringBuilder(str);
    revstr.reverse();
    String rstr = revstr.toString();

    if(str.equals(rstr))//if string and reversed string both are equal return true
        return true;

    return false;               //else return false

}

    // Driver program to test sentencePallindrome()
    public static void main(String[] args)
    {
        String str = "Too hot to hoot.";
        if( sentencePalindrome(str))
        System.out.println("Sentence is palindrome");
        else
        System.out.println("Sentence is not" + " " +
                                        "palindrome");
    }
}

Python

# Python program to find if a sentence is
# palindrome
# To check sentence is palindrome or not
def isPalindrome(s):
    # Replacing the white-space in string
    s1 = s.replace(' ', '')
    # converting string to lowercase
    s1 = s1.lower()
    # Reversing the string
    s2 = s1[::-1];
    # Evaluating the result
    return True if s1 == s2 else False

# Driver program to test sentencePalindrome()
s = "Too hot to hoot"
if (isPalindrome(s)):
    print ("Sentence is palindrome.")
else:
    print ("Sentence is not palindrome.")

# This code is contributed by Sachin Bisht

C#

using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;

// C# program to find if a sentence is
// palindrome

class HelloWorld {

    // To check sentence is palindrome or not
    public static bool isPalindrome(string str)
    {

        // Removing the white-spaces
        str = str.Replace(" ", string.Empty);

        // Transforming to lowercase
        str = str.ToLower();

        // Creating the copy to string
        string s1 = str;
        string s2 = str;

        // Reversing the string s1
        char[] charArray = str.ToCharArray();
        Array.Reverse(charArray);
        s1 = new string(charArray);

        // Evaluating Result
        return s1 == s2;
    }


    static void Main() {
        string str = "Too hot to hoot";

        if (isPalindrome(str))
            Console.WriteLine("Sentence is palindrome.");
        else
            Console.WriteLine("Sentence is not palindrome.");
    }
}

// The code is contributed by Nidhi goel.

Javascript

// Javascript program to find if a sentence is
// palindrome

    // To check sentence is palindrome or not
    function isPalindrome(str)
    {
        // Replacing the white-space
        let s1 = str.split(' ').join('');
        // Converting string to lower-case
        s1 = s1.toLowerCase();
        // Reversing the string
        let s2 = s1.split('').reverse().join('');
        // Evaluating the result
        return true ? s1 == s2 : false;
    }

    // Driver program to test sentencePallindrome()
    let str = "Too hot to hoot";
    if( isPalindrome(str))
        console.log("Sentence is palindrome");
    else
        console.log("Sentence is not palindrome");


    //This code is contributed by avanitrachhadiya2155

Output

Sentence is palindrome.

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

Method: #3: Using Stack

Here we are using the stack to reverse the array and then check whether the sentence is palindrome or not.

C++

// C++ program for the above approach
#include <iostream>
#include <algorithm>
#include <stack>
using namespace std;

bool sentencePalindrome(string s)
{
    string str = "";
    for (char c : s){
        if (isalnum(c))
            str += tolower(c);
    }
    string reverse_str = str;
    reverse(reverse_str.begin(), reverse_str.end());
    return str == reverse_str;
}

int main()
{
    string str = "Too hot to hoot.";
    if (sentencePalindrome(str))
        cout << "Sentence is palindrome\n";
    else
        cout << "Sentence is not palindrome\n";
    return 0;
}

// This code is contributed by adityashatmfh

Java

import java.io.*;
import java.util.*;

class GFG {
    static boolean sentencePalindrome(String s)
    {
    char[] str = s.toCharArray();
    Stack<Character> stack = new Stack<>();
    for (int i = 0; i < s.length(); i++){
        if (Character.isLetterOrDigit(str[i]))
            stack.push(str[i]);
    }
    String string = "";
    String reverse = "";
    for (Character character : stack) {
        reverse += Character.toLowerCase(character);
    }
    while (!stack.isEmpty()){
        string += Character.toLowerCase(stack.pop());
    }
    return string.equals(reverse);
    }

public static void main(String[] args)
    {
        String str = "Too hot to hoot.";
        if( sentencePalindrome(str))
          System.out.println("Sentence is palindrome");
        else
          System.out.println("Sentence is not" + " " +
                                         "palindrome");
    }
}

Python3

# Python program for the above approach

def sentence_palindrome(s):
    str_ = ""
    for c in s:
        if c.isalnum():
            str_ += c.lower()
    reverse_str = str_[::-1]
    return str_ == reverse_str

if __name__ == "__main__":
    str_ = "Too hot to hoot."
    if sentence_palindrome(str_):
        print("Sentence is palindrome")
    else:
        print("Sentence is not palindrome")


# This code is contributed by prince

C#

using System;
using System.Collections.Generic;

class GFG {
    static bool sentencePalindrome(string s)
    {
        // Convert string to character array
        char[] str = s.ToCharArray();
        Stack<char> stack = new Stack<char>();

        // Push only letters and digits onto the stack
        for (int i = 0; i < s.Length; i++){
            if (Char.IsLetterOrDigit(str[i]))
                stack.Push(str[i]);
        }

        string originalString = "";
        string reverseString = "";

        // Create a string from the characters in the stack
        foreach (char character in stack) {
            reverseString += Char.ToLower(character);
        }

        // Pop characters from the stack to create a reversed string
        while (stack.Count > 0){
            originalString += Char.ToLower(stack.Pop());
        }

        // Compare the original and reversed strings
        return originalString.Equals(reverseString);
    }

    public static void Main(string[] args)
    {
        string str = "Too hot to hoot.";

        if(sentencePalindrome(str))
          Console.WriteLine("Sentence is palindrome");

          else
          Console.WriteLine("Sentence is not" + " " +
                                         "palindrome");
    }
}

Javascript

function sentencePalindrome(s) {
  let str = "";
  for (let i = 0; i < s.length; i++) {
    const c = s.charAt(i);
    if (c.match(/[a-zA-Z0-9]/))
      str += c.toLowerCase();
  }
  const reverse_str = str.split("").reverse().join("");
  return str === reverse_str;
}

const str = "Too hot to hoot.";
if (sentencePalindrome(str))
  console.log("Sentence is palindrome");
else
  console.log("Sentence is not palindrome");

Output

Sentence is palindrome

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

This article is contributed by nuclode. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.