Palindrome-testing Java program for an interview

Question

In an interview I was asked to write a function that would take an input word and return true if the word is a palindrome. At first I used an approach using StringBuilder but the interviewer said that wasn't allowed and to use a for loop instead. I scored 7/9 so I'm guessing it's possible to improve this:

public static boolean isPalinedrome(String word) {

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

I added the following to the main() section to test

String input = "racecar";
if(isPalinedrome(input)) {
    System.out.println(input + " is a palinedrome");
} else {
    System.out.println(input + " is not a palinedrome");
}

The way I test it seems to be ugly. Is there a standard way to test a new function? I guess if you're in an advanced enough environment you would have test cases for JUnit to run against it, but anything simpler that could be done in an interview with a cloud IDE?

Answer 1

It's enough to loop until word.length() / 2, as this will compare the first half with the second half, so no need to go until the end.

As you use word.length() multiple times, you could extract it to a helper variable.

There is a typo in the method name.

As for testing, yes, JUnit is the way to go. In a cloud IDE, you could create a helper method that takes a single string, calls isPalindrome and prints the result. That way you can test multiple cases easily, by adding one line per case. It's important to try to cover corner cases and potentially interesting cases, not just the "happy path". For example:

• palindrome with even length
• palindrome with odd length
• single letter
• empty string
• non-palindromes

During an interview, it might also be worth mentioning the trade-off between comparing characters using .charAt, or using the array of characters returned by .toCharArray.

Answer 2

JUnit tests would be a rather nice way to go here, as you correctly assume. It does not take much:

• import org.junit.Test
• statically import your asserts (e.g. org.junit.Assert.assertEquals)
• annotate your test with @Test

and you're good to go.

Pity your interviewer went for the for loop, palindromes can be nicely solved by recursion (pointing out the performance and memory usage drawbacks, of course.. )

import static org.junit.Assert.assertEquals;

import org.junit.Test;

public class PalindromeTesterClass {

    @Test
    public void shouldRecognizeNull() {
        assertEquals(false, PalindromeTesterClass.isPalindrome(null));
    }

    @Test
    public void shouldRecognizeEmptyString() {
        assertEquals(true, PalindromeTesterClass.isPalindrome(""));
    }

    @Test
    public void shouldRecognizeOneCharacterPalindrome() {
        assertEquals(true, PalindromeTesterClass.isPalindrome("a"));
    }

    @Test
    public void shouldRecognizeTwoCharacterPalindrome() {
        assertEquals(true, PalindromeTesterClass.isPalindrome("aa"));
    }

    @Test
    public void shouldRecognizeTwoCharacterNonPalindrome() {
        assertEquals(false, PalindromeTesterClass.isPalindrome("ab"));
    }

    @Test
    public void shouldRecognizePalindrome() {
        assertEquals(true, PalindromeTesterClass.isPalindrome("amanaplanacanalpanama"));
    }

    @Test
    public void shouldRecognizeNonPalindrome() {
        assertEquals(false, PalindromeTesterClass.isPalindrome("noPalindrome"));
    }

    public static boolean isPalindrome(String word) {
        if (word == null) {
            // assuming a null value is no palindrome
            return false;
        } else if (word.length() < 2) {
            // assuming both "" and "x" are palindromes
            return true;
        } else {
            // a word is a palindrome if it starts and ends in the same letter..
            if (!word.endsWith(word.substring(0, 1))) {
                return false;
            }
            // .. and everything in between the first and the last letter is a palindrome
            return isPalindrome(word.substring(1, word.length() - 1));
        }
    }
}

Answer 3

At the very least, you should compare code points, not chars. In Java, char doesn't necessarily represent a whole character, so for out-of-order comparison it won't make sense.

Answer 4

fastest solution

 public static boolean isPalindrome(String input) {
    int n = input.length();
    for (int i = 0; i < (n / 2); ++i) {
        if (input.charAt(i) != input.charAt(n - i - 1)) {
            return false;
        }
    }
    return true;
}