Thursday Code Puzzler: Is This A Palindrome

This is how Groovy codes the reverse function:

public static String reverse(String self) {
    return new StringBuilder(self).reverse().toString();
}

1. What are the limits to the domain of the problem? In this case the string which is to be checked can attain the following values
   a. string size is 0, (null or empty ): In this case the behavior of the solution should be explained.
   b. string size is infinte : In this case the behavior of the solution should be explained, may be we want to memoize the answers to longer problems and for the smaller problems we will re-compute them on the fly
2. Another factor to consider is, "how often will this exercise be performed? or is this business logic or deployment/ops logic?". If this is a one off exercise or will be repeated only occasionally, then we can safely substitute optimizations with readability.
3. Another factor, is this a utility function? Can this functionality be resused else where? If this functionality can indeed be reused then we want to consider, liskov substitution and open-close principle etc.

import java.util.HashMap;

public final class PalindromeChecker{
    private static HashMap<Integer, Boolean> cache;
    public static void main(String[] args){
        for(String arg: args){
            System.out.printf("Argument %1$s %2$s", arg, isPalindrome(arg)?" is a palindrome":" is not a palindrome");
        }
    }

    public static final boolean isPalindrome(String arg){
        if (arg == null) return false;
        int length = arg.length();
        Boolean toReturn = Boolean.FALSE;
        if (length > THRESHOLD && (toReturn = cache.get(arg.hashCode())) return 
        for(int cntr = 0, limit = length / 2; cntr < limit; cntr++){
           if (arg.charAt(cntr) != arg.charAt(length - 1 - cntr))return false;
        }
        return true;
    }
}

	private static boolean isPalindrome(String word){
		return new StringBuilder(word).reverse().toString().equalsIgnoreCase(word);
	}

public class PalindromeTest {

	public static void main(String[] args) {
		String str = "abcdefghijklmnoponmlkjihgfedcba";

		boolean isPalindrome = true;
		for (int i = 0; i < str.length(); i++) {
			int len = (str.length() - 1) - i;
			// Avoid extra looping
			if (str.charAt(i) != str.charAt(len)) {
				isPalindrome = false;
				break;
			}
		}
		System.out.println("str: " + str);
		System.out.println("rev: " + new StringBuilder(str).reverse());
		System.out.println("isPalindram: " + isPalindrome);
	}
}

@Dino VV : My apologies for the copy paste error!

Here is the corrected code.

import java.util.HashMap;

public final class PalindromeChecker{

	private static HashMap<Integer, Boolean> cache;
    
	public static void main(String[] args){
        for(String arg: args){
            System.out.printf("Argument %1$s %2$s", arg, isPalindrome(arg)?" is a palindrome":" is not a palindrome");
        }
    }

    public static final Boolean isPalindrome(String arg){
        
    	if (arg == null) return Boolean.FALSE;

        Boolean toReturn = Boolean.TRUE;
        int hashCode = arg.hashCode();
        if (toReturn = cache.get(hashCode) != null ) return toReturn;
        
        toReturn = Boolean.TRUE;
        int length = arg.length();
        for(int cntr = 0, limit = length / 2; cntr < limit; cntr++){
           if (arg.charAt(cntr) != arg.charAt(length - 1 - cntr)){
        	   toReturn = Boolean.FALSE;
        	   break;
           }
        }
        cache.put(hashCode, toReturn);
        return toReturn;
    }
    
}

Right. The stirngs "0-42L" and "0-43-" have the same hashCode of 45721201.

function isPalindrome(str)
{
	if(typeof(str) !== 'string') {
		return false;
	}
		
	var length = str.length,
		isEven = length % 2 == 0,
		compareLength = isEven ? length/2 : (length-1)/2;
	
	for(var i = 0; i < compareLength; i++)
	{
		if(str[i] != str[length-i-1])
			return false;
	}
	return true;
}

This is simple optimized java code to check if a string is palindrome. Please comment.

public boolean isPalindrome(String str){
        boolean flag = false;
        boolean singleCharFlag = false;
        String strFirstChar = Character.toString(str.charAt(0));
        boolean endswith = str.endsWith(strFirstChar);
        
        if(endswith){
            int strLength = str.length();
            if(strLength == 1){ singleCharFlag = true; }
            if(singleCharFlag){ return true; }
            str = str.substring(1, strLength-1);
            flag = true;
        }else{
            return false;
        }
        
        if("".equals(str)){
            return flag;
        }
        
        flag = isPalindrom(str);
        return flag;
    }

You are almost right, but what about "abcCBA" ?