Palindrome

Palindromes can be read in both directions. A palindrome has the same letters on both ends of the string. It is a form of word puzzle.

The string "civic" is a palindrome, but "perls" is not. How can you determine if a string is a palindrome in the C# language?

Example

This program introduces the IsPalindrome boolean method. In the method body, we determine the minimum and maximum indexes inside the string.

Then We scan from the minimum forward, and from the maximum backward, at the same time.

And If the characters are different, we return false. If we are done scanning, we return true.

Note If your input strings are always lowercase, it would be better to remove the char.ToLower transformations.

using System;

class Program
{
    /// <summary>
    /// Determines whether the string is a palindrome.
    /// </summary>
    public static bool IsPalindrome(string value)
    {
        int min = 0;
        int max = value.Length - 1;
        while (true)
        {
            if (min > max)
            {
                return true;
            }
            char a = value[min];
            char b = value[max];
            if (char.ToLower(a) != char.ToLower(b))
            {
                return false;
            }
            min++;
            max--;
        }
    }

    static void Main()
    {
        string[] array =
        {
            "civic",
            "deified",
            "deleveled",
            "devoved",
            "dewed",
            "Hannah",
            "kayak",
            "level",
            "madam",
            "racecar",
            "radar",
            "redder",
            "refer",
            "repaper",
            "reviver",
            "rotator",
            "rotor",
            "sagas",
            "solos",
            "sexes",
            "stats",
            "tenet",

            "Dot",
            "Net",
            "Perls",
            "Is",
            "Not",
            "A",
            "Palindrome",
            ""
        };

        foreach (string value in array)
        {
            Console.WriteLine("{0} = {1}", value, IsPalindrome(value));
        }
    }
}civic = True
deified = True
deleveled = True
devoved = True
dewed = True
Hannah = True
kayak = True
level = True
madam = True
racecar = True
radar = True
redder = True
refer = True
repaper = True
reviver = True
rotator = True
rotor = True
sagas = True
solos = True
sexes = True
stats = True
tenet = True
Dot = False
Net = False
Perls = False
Is = False
Not = False
A = True
Palindrome = False
 = True

Sentences

This program is the same as the simpler palindrome method except for some small changes. The important change is inside IsPalindrome. There are two additional while-loops.

Note If a char is determined to be a non-letter non-digit character, we begin skipping forward or backward to one that should be checked.

So Punctuation and spaces do not affect the result—sentences are handled correctly.

using System;

class Program
{
    /// <summary>
    /// Determines whether the string is a palindrome.
    /// </summary>
    public static bool IsPalindrome(string value)
    {
        int min = 0;
        int max = value.Length - 1;
        while (true)
        {
            if (min > max)
            {
                return true;
            }
            char a = value[min];
            char b = value[max];

            // Scan forward for a while invalid.
            while (!char.IsLetterOrDigit(a))
            {
                min++;
                if (min > max)
                {
                    return true;
                }
                a = value[min];
            }

            // Scan backward for b while invalid.
            while (!char.IsLetterOrDigit(b))
            {
                max--;
                if (min > max)
                {
                    return true;
                }
                b = value[max];
            }

            if (char.ToLower(a) != char.ToLower(b))
            {
                return false;
            }
            min++;
            max--;
        }
    }

    static void Main()
    {
        string[] array =
        {
            "A man, a plan, a canal: Panama.",
            "A Toyota. Race fast, safe car. A Toyota.",
            "Cigar? Toss it in a can. It is so tragic.",
            "Dammit, I'm mad!",
            "Delia saw I was ailed.",
            "Desserts, I stressed!",
            "Draw, O coward!",
            "Lepers repel.",
            "Live not on evil.",
            "Lonely Tylenol.",
            "Murder for a jar of red rum.",
            "Never odd or even.",
            "No lemon, no melon.",
            "Senile felines.",
            "So many dynamos!",
            "Step on no pets.",
            "Was it a car or a cat I saw?",

            "Dot Net Perls is not a palindrome.",
            "Why are you reading this?",
            "This article is not useful.",
            "...",
            "...Test"
        };

        foreach (string value in array)
        {
            Console.WriteLine("{0} = {1}", value, IsPalindrome(value));
        }
    }
}A man, a plan, a canal: Panama. = True
A Toyota. Race fast, safe car. A Toyota. = True
Cigar? Toss it in a can. It is so tragic. = True
Dammit, I'm mad! = True
Delia saw I was ailed. = True
Desserts, I stressed! = True
Draw, O coward! = True
Lepers repel. = True
Live not on evil. = True
Lonely Tylenol. = True
Murder for a jar of red rum. = True
Never odd or even. = True
No lemon, no melon. = True
Senile felines. = True
So many dynamos! = True
Step on no pets. = True
Was it a car or a cat I saw? = True
Dot Net Perls is not a palindrome. = False
Why are you reading this? = False
This article is not useful. = False
... = True
...Test = False

Performance

What is the advantage of using two sub-loops to skip forward and back? This approach means you do not need to allocate any new strings.

And You can check the original string data without converting it. Avoiding string allocations makes a program faster.

Info A slower approach strips all spaces and punctuation from the source string. Then, you could use the simpler palindrome method.

We introduced a simple C# method that tests for palindromes. Many palindromes are composed of multiple words and have spaces and punctuation. These can all be tested.