CODEWITHSUNDEEP
javaarraysstringcharpalindrome
DarkLeafyGreen
DarkLeafyGreen

Reputation: 70416

Check string for palindrome

A palindrome is a word, phrase, number or other sequence of units that can be read the same way in either direction.

To check whether a word is a palindrome I get the char array of the word and compare the chars. I tested it and it seems to work. However I want to know if it is right or if there is something to improve.

Here is my code:

public class Aufg1 {
    public static void main(String[] args) {
        String wort = "reliefpfpfeiller";
        char[] warray = wort.toCharArray(); 
        System.out.println(istPalindrom(warray));       
    }

    public static boolean istPalindrom(char[] wort){
        boolean palindrom = false;
        if(wort.length%2 == 0){
            for(int i = 0; i < wort.length/2-1; i++){
                if(wort[i] != wort[wort.length-i-1]){
                    return false;
                }else{
                    palindrom = true;
                }
            }
        }else{
            for(int i = 0; i < (wort.length-1)/2-1; i++){
                if(wort[i] != wort[wort.length-i-1]){
                    return false;
                }else{
                    palindrom = true;
                }
            }
        }
        return palindrom;
    }
}

Upvotes: 95

Views: 382822

Answers (30)

SagarS
SagarS

Reputation: 11

Using Stack it can be done in following way:

String s = "RADAR";
        Stack<Character> myStack = new Stack<Character>();
        char[] myStrArr = s.toCharArray();
        for(Character c: myStrArr) {
            myStack.push(c);
        }
        int i = myStack.size();
        String `enter code here`result = "";
        for(int j = 0;j<i;j++) {
            result += myStack.pop();
        }
        System.out.println(result.equalsIgnoreCase(s)?"PALINDROME":"NOT PALINDROME");

Upvotes: 0

mhash17
mhash17

Reputation: 379

I could not resist the Recursion:

public static boolean isPalindrom(String s) {
    if(s.length()<2 || (s.length()<3 && s.charAt(0)==s.charAt(1)))
        return true;
    else if(s.charAt(0)==s.charAt(s.length()-1))
        return isPalindrom(s.substring(1, s.length()-1));
    return false;
}

Upvotes: 0

Oleg Cherednik
Oleg Cherednik

Reputation: 18245

  • Time complexity: O(n)
  • Space complexity: O(1)
public static boolean isPalindrome(String str) {
    for (int i = 0, j = str.length() - 1; i < j; i++, j--)
        if (str.charAt(i) != str.charAt(j))
        // for case insesitive comapre
        // if (Character.toLowerCase(str.charAt(i)) != Character.toLowerCase(str.charAt(j)))
            return false;

    return true;
}

Upvotes: 0

Ankit Kumar Rajpoot
Ankit Kumar Rajpoot

Reputation: 5600

Palindrome with recursion(JavaScript)

    var isPalindrome = function(str) {
        if(str.length <=1) return true;
        if (str[0] !== str[str.length-1]) return false;
        return isPalindrome(str.slice(1,-1));
    }

isPalindrome(aba)

Upvotes: 0

Capt. Michael
Capt. Michael

Reputation: 113

Besides the way using StringBuilder/StringBuffer to reverse the string and check it still equals the original one, here's a way by for loop.

private boolean isPalindrome(String word) {
    if (word == null || word.isEmpty()) {
        return false;
    }

    int length = word.length();
    int middleIndex = length / 2;

    for (int index = 0; index < middleIndex; index++) {
        if (word.charAt(index) != word.charAt(length - index - 1)) {
            return false;
        }
    }

    return true;
}

Upvotes: 0

Jakha
Jakha

Reputation: 11

I created a new time complexitey Java solution 7 ms, and very easy! I take the desired numbers and letters from the ASCII table, do not touch the rest, and finally return true or false, checking that the two strings are equal to each other.

StringBuilder newString = new StringBuilder();

    s = s.toLowerCase();

    for (char ch : s.toCharArray()) {

        if (97 <= (int) ch && (int) ch <= 122 || 48 <= (int)ch && (int)ch <= 57) {

            newString.append(ch);
        }
    }

    String nextS = new StringBuilder(newString).reverse().toString();
    
    return nextS.equals(newString.toString());

Upvotes: 0

Gorakh Nath
Gorakh Nath

Reputation: 9848

We can reduce the loop to half of the length:

function isPallindrome(s) {
  let word= s.toLowerCase();
  let length = word.length -1;
  let isPallindrome= true;
  for(let i=0; i< length/2 ;i++){
    if(word[i] !== word[length -i]){
      isPallindrome= false;
      break;
    }
  }
  return isPallindrome;
}

Upvotes: 0

ch Noman
ch Noman

Reputation: 19

public class palindrome {

    public static void main(String[] args) {

        Scanner scanner=new Scanner(System.in);
        System.out.println("Enter the line you want to check palindrome:");
        String s= scanner.nextLine();

        StringTokenizer separate = new StringTokenizer(s, " ");
        System.out.println("\nPalindrome Words are: ");
        while(separate.hasMoreTokens()) {
            String word = separate.nextToken();
            String reversedWord = new StringBuilder(word).reverse().toString().toLowerCase();
            if ((word.toLowerCase().equals(reversedWord))){
                System.out.println(word);
            }
        }
    }
}

Upvotes: 0

bluesony
bluesony

Reputation: 479

Why not just : 

boolean isPalindrom(String s) {
        char[] myChars = s.toCharArray();
        for (int i = 0; i < myChars.length/2; i++) {
            if (myChars[i] != myChars[myChars.length - 1 - i]) {
                return false;
            }
        }
        return true;
}

Upvotes: 1

lczapski
lczapski

Reputation: 4120

Using Stream API: 

private static boolean isPalindrome(char[] warray) {
    return IntStream.range(0, warray.length - 1)
            .takeWhile(i -> i < warray.length / 2)
            .noneMatch(i -> warray[i] != warray[warray.length - 1 - i]);
}

Upvotes: 0

ykb
ykb

Reputation: 59

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

public class Solution {

    public static void main(String[] args) {

        Scanner sc=new Scanner(System.in);
        String A=sc.next();
        char[] array = A.toCharArray();
        String str = "";
        for(int i=A.length()-1;i>=0;i--){
            str = str + array[i];
        }
        if(A.equalsIgnoreCase(str))System.out.println("Yes");
        else System.out.println("No");
    }
}

Upvotes: 0

duyuanchao
duyuanchao

Reputation: 4303

/**
 * Check whether a word is a palindrome
 *
 * @param word the word
 * @param low  low index
 * @param high high index
 * @return {@code true} if the word is a palindrome;
 * {@code false} otherwise
 */
private static boolean isPalindrome(char[] word, int low, int high) {
    if (low >= high) {
        return true;
    } else if (word[low] != word[high]) {
        return false;
    } else {
        return isPalindrome(word, low + 1, high - 1);
    }
}

/**
 * Check whether a word is a palindrome
 *
 * @param the word
 * @return {@code true} if the word is a palindrome;
 * @code false} otherwise
 */
private static boolean isPalindrome(char[] word) {
    int length = word.length;
    for (int i = 0; i <= length / 2; i++) {
        if (word[i] != word[length - 1 - i]) {
            return false;
        }
    }
    return true;
}

public static void main(String[] args) {
    char[] word = {'a', 'b', 'c', 'b', 'a' };
    System.out.println(isPalindrome(word, 0, word.length - 1));
    System.out.println(isPalindrome(word));
}

Upvotes: 0

Keith OYS
Keith OYS

Reputation: 2305

Alternatively, recursion.

For anybody who is looking for a shorter recursive solution, to check if a given string satisfies as a palindrome:

private boolean isPalindrome(String s) {
    int length = s.length();

    if (length < 2) // If the string only has 1 char or is empty
        return true;
    else {
        // Check opposite ends of the string for equality
        if (s.charAt(0) != s.charAt(length - 1))
            return false;
        // Function call for string with the two ends snipped off
        else
            return isPalindrome(s.substring(1, length - 1));
    }
}

OR even shorter, if you'd like:

private boolean isPalindrome(String s) {
    int length = s.length();
    if (length < 2) return true;
    return s.charAt(0) != s.charAt(length - 1) ? false :
            isPalindrome(s.substring(1, length - 1));
}

Upvotes: 20

zarpio
zarpio

Reputation: 7338

In PHP

function isPalindrome($string) {
    return (strrev($string) == $string) ? true : false;
}

var_dump(isPalindrome('madam')); //bool(true)
var_dump(isPalindrome('dell')); //bool(false)
var_dump(isPalindrome('1221')); //bool(true)

Upvotes: 0

user147373
user147373

Reputation: 

public class Palindromes {
    public static void main(String[] args) {
         String word = "reliefpfpfeiller";
         char[] warray = word.toCharArray(); 
         System.out.println(isPalindrome(warray));       
    }

    public static boolean isPalindrome(char[] word){
        if(word.length%2 == 0){
            for(int i = 0; i < word.length/2-1; i++){
                if(word[i] != word[word.length-i-1]){
                    return false;
                }
            }
        }else{
            for(int i = 0; i < (word.length-1)/2-1; i++){
                if(word[i] != word[word.length-i-1]){
                    return false;
                }
            }
        }
        return true;
    }
}

Upvotes: 4

Pratik Patil
Pratik Patil

Reputation: 3753

  • This implementation works for numbers and strings.
  • Since we are not writing anything, so there is no need to convert the string into the character array.
public static boolean isPalindrome(Object obj)
{
    String s = String.valueOf(obj);

    for(int left=0, right=s.length()-1; left < right; left++,right--)
    {
        if(s.charAt(left++) != s.charAt(right--))
            return false;
    }
    return true;
}

Upvotes: 1

Mohsen Mousavi
Mohsen Mousavi

Reputation: 173

 public boolean isPalindrome(String input) {
    char[] inputChars = input.toCharArray();
    int inputLength = inputChars.length;
    int inputMid = inputLength / 2;

    for (int i = 0; i <= inputMid; i++) {
        if (inputChars[i] != inputChars[inputLength - i - 1]) {
             return false;
        } 
    }
    return true;
}

The method determines whether a string input is a palindrome. In this method the loop iterates for half of the input length resulting in less performance concern and more concise application.

Upvotes: 0

Felix
Felix

Reputation: 687

Amazing how many different solutions to such a simple problem exist! Here's another one. 

private static boolean palindrome(String s){
    String revS = "";
    String checkS = s.toLowerCase();
    String[] checkSArr = checkS.split("");

    for(String e : checkSArr){
        revS = e + revS;
    }

    return (checkS.equals(revS)) ? true : false;
}

Upvotes: 0

Madhusudhan R
Madhusudhan R

Reputation: 321

package basicprogm;

public class pallindrome {

  public static void main(String[] args) {
    // TODO Auto-generated method stub

    String s= "madam" ;
    //to store the values that we got in loop
    String t="";
    for(int i=s.length()-1;i>=0;i--){
      t=t+s.charAt(i);
    }
    System.out.println("reversed word is "+ t);

    if (t.matches(s)){
      System.out.println("pallindrome");
    }
    else{
      System.out.println("not pallindrome");
    }
  }
}

Upvotes: 0

george mano
george mano

Reputation: 6168

For-loop contains sub.length() / 2 - 1 . It has to be subtracted with 1 as the element in the middle of the string does not have to checked.

For example, if we have to check an string with 7 chars (1234567), then 7/2 => 3 and then we subtrack 1, and so the positions in the string will become (0123456). The chars checked with be the 0, 1, 2 element with the 6, 5, 4 respectively. We do not care about the element at the position 3 as it is in the exact middle of the string. 

 private boolean isPalindromic(String sub) {
        for (int i = 0; i <= sub.length() / 2 - 1; i++) {
            if (sub.charAt(i) != sub.charAt(sub.length() - 1 - i)) {
                return false;
            }
        }
        return true;
    }

Upvotes: 0

Keshav Gera
Keshav Gera

Reputation: 11244

enter image description here

import java.util.Collections;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class GetAllPalindromes 
{
    static Scanner in;

    public static void main(String[] args) 
    {
        in = new Scanner(System.in);
        System.out.println("Enter a string \n");
        String abc = in.nextLine();
        Set a = printAllPalindromes(abc);
        System.out.println("set is   " + a);
    }

    public static Set<CharSequence> printAllPalindromes(String input) 
    {
        if (input.length() <= 2) {
            return Collections.emptySet();
        }

        Set<CharSequence> out = new HashSet<CharSequence>();
        int length = input.length();

        for (int i = 1; i < length - 1; i++) 
        {
            for (int j = i - 1, k = i + 1; j >= 0 && k < length; j--, k++) 
            {
                if (input.charAt(j) == input.charAt(k)) {
                    out.add(input.subSequence(j, k + 1));
                } else {
                    break;
                }
            }
        }
        return out;
    }
}

**Get All Palindrome in s given string**

Output D:\Java>java GetAllPalindromes Enter a string

Hello user nitin is my best friend wow !

Answer is set is [nitin, nitin , wow , wow, iti]

D:\Java>

Upvotes: -1

Abhilash Muthuraj
Abhilash Muthuraj

Reputation: 2028

Checking palindrome for first half of the string with the rest, this case assumes removal of any white spaces.

public int isPalindrome(String a) {
        //Remove all spaces and non alpha characters
        String ab = a.replaceAll("[^A-Za-z0-9]", "").toLowerCase();
        //System.out.println(ab);

        for (int i=0; i<ab.length()/2; i++) {
            if(ab.charAt(i) != ab.charAt((ab.length()-1)-i)) {
                return 0;
            }
        }   
        return 1;
    }

Upvotes: 3

Chandara Chea
Chandara Chea

Reputation: 339

 public static boolean isPalindrome(String word) {
    String str = "";
    for (int i=word.length()-1; i>=0;  i--){
        str = str + word.charAt(i);
    }
   if(str.equalsIgnoreCase(word)){
       return true;
   }else{
       return false;
   }

}

Upvotes: 1

Marc
Marc

Reputation: 2603

I worked on a solution for a question that was marked as duplicate of this one. Might as well throw it here...

The question requested a single line to solve this, and I took it more as the literary palindrome - so spaces, punctuation and upper/lower case can throw off the result.

Here's the ugly solution with a small test class:

public class Palindrome {
   public static boolean isPalendrome(String arg) {
         return arg.replaceAll("[^A-Za-z]", "").equalsIgnoreCase(new StringBuilder(arg).reverse().toString().replaceAll("[^A-Za-z]", ""));
   }
   public static void main(String[] args) {
      System.out.println(isPalendrome("hiya"));
      System.out.println(isPalendrome("star buttons not tub rats"));
      System.out.println(isPalendrome("stab nail at ill Italian bats!"));
      return;
   }
}

Sorry that it is kind of nasty - but the other question specified a one-liner.

Upvotes: 3

wumpz
wumpz

Reputation: 9131

And here a complete Java 8 streaming solution. An IntStream provides all indexes til strings half length and then a comparision from the start and from the end is done.

public static void main(String[] args) {
    for (String testStr : Arrays.asList("testset", "none", "andna", "haah", "habh", "haaah")) {
        System.out.println("testing " + testStr + " is palindrome=" + isPalindrome(testStr));
    }
}

public static boolean isPalindrome(String str) {
    return IntStream.range(0, str.length() / 2)
            .noneMatch(i -> str.charAt(i) != str.charAt(str.length() - i - 1));
}

Output is:

testing testset is palindrome=true
testing none is palindrome=false
testing andna is palindrome=true
testing haah is palindrome=true
testing habh is palindrome=false
testing haaah is palindrome=true

Upvotes: 4

aayushi
aayushi

Reputation: 359

Using stack, it can be done like this

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
import java.util.*;

public class Solution {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str=in.nextLine();
        str.replaceAll("\\s+","");
        //System.out.println(str);
        Stack<String> stack=new Stack<String>();
        stack.push(str);
        String str_rev=stack.pop();
        if(str.equals(str_rev)){
            System.out.println("Palindrome"); 
        }else{
             System.out.println("Not Palindrome");
        }
    }
}

Upvotes: 1

capt.swag
capt.swag

Reputation: 10661

Recently I wrote a palindrome program which doesn't use StringBuilder. A late answer but this might come in handy to some people.

public boolean isPalindrome(String value) {
    boolean isPalindrome = true;
    for (int i = 0 , j = value.length() - 1 ; i < j ; i ++ , j --) {
        if (value.charAt(i) != value.charAt(j)) {
            isPalindrome = false;
        }
    }
    return isPalindrome;
}

Upvotes: 1

rashedcs
rashedcs

Reputation: 3725

Code Snippet:

import java.util.Scanner;

 class main
 {
    public static void main(String []args)
    {
       Scanner sc = new Scanner(System.in);
       String str = sc.next();
       String reverse = new StringBuffer(str).reverse().toString();

        if(str.equals(reverse))
            System.out.println("Pallindrome");
        else
            System.out.println("Not Pallindrome");
     }
}

Upvotes: 0

juanmf
juanmf

Reputation: 2004

here, checking for the largest palindrome in a string, always starting from 1st char.

public static String largestPalindromeInString(String in) {
    int right = in.length() - 1;
    int left = 0;
    char[] word = in.toCharArray();
    while (right > left && word[right] != word[left]) {
        right--;
    }
    int lenght = right + 1;
    while (right > left && word[right] == word[left]) {

        left++;
        right--;

    }
    if (0 >= right - left) {
        return new String(Arrays.copyOf(word, lenght ));
    } else {
        return largestPalindromeInString(
                new String(Arrays.copyOf(word, in.length() - 1)));
    }
}

Upvotes: 0

john Smith
john Smith

Reputation: 1605

IMO, the recursive way is the simplest and clearest.

public static boolean isPal(String s)
{   
    if(s.length() == 0 || s.length() == 1)
        return true; 
    if(s.charAt(0) == s.charAt(s.length()-1))
       return isPal(s.substring(1, s.length()-1));                
   return false;
}

Upvotes: 0

Related Questions