Programmatically check if a number is a palindrome

Question

This sounds like homework, yes it is (of someone else), I asked a friend of mine who is learning C# to lend me some of his class exercises to get the hang of it.

So as the title says: How can I check if a number is a Palindrome?

I'm not asking for source code (although its very useful), but rather that someone explained how should the code should work, so that it can be applied to many different languages.

---

The Solution:

@statikfx searched SO for this and found the solution.

 n = num;
 while (num > 0)
 {
      dig = num % 10;
      rev = rev * 10 + dig;
      num = num / 10;
 }
// If (n == rev) then num is a palindrome

Answer 1

I check for palindromes by converting the integer to a string, then reversing the string, then comparing equality. This will be the best approach for you since you're just starting out.

Since you're working in C# and this is homework, I'll use very obscure-looking Python that won't help you:

def is_palindrome(i):
    s = str(i)
    return s[::-1] == s

Convert that to C# and you'll have your answer.

Answer 2

Main idea:

Input number: 12321
Splitting the digits of the number, put them into an array
=> array [1, 2, 3, 2, 1]
Check if array[x] = array[arr_length - x] for all x = 0..arr_length / 2
If check passed => palindrome

Answer 3

There are many ways. Probably the simplest is to have 2 indexes, i at beginning and j at end of number. You check to see if a[i] == a[j]. If so, increment i and decrement j. You stop when i > j. When looping if you ever reach a point where a[i] != a[j], then it's not a palindrome.

Answer 4

Here's some working code. The first function tests if a number is palidromic by converting it to a string then an IEnumerable and testing if it is equal to its reverse. This is enough to answer your question. The main function simply iterates over the integers testing them one by one.

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

class Program
{
    public static bool IsPalindromic(long l)
    {
        IEnumerable<char> forwards = l.ToString().ToCharArray();
        return forwards.SequenceEqual(forwards.Reverse());
    }

    public static void Main()
    {
        long n = 0;
        while (true)
        {
            if (IsPalindromic(n))
                Console.WriteLine("" + n);
            n++;
        }
    }
}

Update: Here is a more direct method of generating palindromes. It doesn't test numbers individually, it just generates palindromes directly. It's not really useful for answering your homework, but perhaps you will find this interesting anyway:

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

class Program
{
    public static void Main()
    {
        bool oddLength = true;
        ulong start = 1;
        while (true)
        {
            for (ulong i = start; i < start * 10; ++i)
            {
                string forwards = i.ToString();
                string reverse = new string(forwards.ToCharArray()
                                                    .Reverse()
                                                    .Skip(oddLength ? 1 : 0)
                                                    .ToArray());
                Console.WriteLine(forwards + reverse);
            }
            oddLength = !oddLength;
            if (oddLength)
                start *= 10;
        }
    }
}

Answer 5

My solution:

bool IsPalindrome(string str)
{
    if(str.Length == 1 || str.Length == 0) return true;
    return str[0] == str[str.Length-1] && IsPalindrome(str.Substring(1,str.Length-2));
}

Answer 6

Here's some pseudocode:

function isPalindrome(number) returns boolean
  index = 0
  while number != 0
    array[index] = number mod 10
    number = number div 10
    index = index + 1

  startIndex = 0;
  endIndex = index - 1

  while startIndex > endIndex
    if array[endIndex] != array[startIndex]
      return false
    endIndex = endIndex - 1
    startIndex = startIndex + 1

  return true

Note that that's for base 10. Change the two 10s in the first while loop for other bases.

Answer 7

The following function will work for both numbers as well as for strings.

public bool IsPalindrome(string stringToCheck)
{
   char[] rev = stringToCheck.Reverse().ToArray();
   return (stringToCheck.Equals(new string(rev), StringComparison.OrdinalIgnoreCase));
}

zamirsblog.blogspot.com

Answer 8

in theory you want to convert the number to a string. then convet the string to an array of characters and loop the array comparing character (i) with character (array length - i) if the two characters are not equal exit the loop and return false. if it makes it all the way through the loop it is a Palindrome.

Answer 9

Interesting. I'd probably convert the number to a string, and then write a recursive function to decide whether any given string is a palendrome.

Answer 10

 int n = check_textbox.Text.Length;
        int check = Convert.ToInt32(check_textbox.Text);
        int m = 0;
        double latest=0;
        for (int i = n - 1; i>-1; i--)
        {
                double exp = Math.Pow(10, i);
                double rem = check / exp;
                string rem_s = rem.ToString().Substring(0, 1);
                int ret_rem = Convert.ToInt32(rem_s);
                double exp2 = Math.Pow(10, m);
                double new_num = ret_rem * exp2;
                m=m+1;
                latest = latest + new_num;
                double my_value = ret_rem * exp;
                int myvalue_int = Convert.ToInt32(my_value);
                check = check - myvalue_int;
        }
        int latest_int=Convert.ToInt32(latest);
        if (latest_int == Convert.ToInt32(check_textbox.Text))
        {
            MessageBox.Show("The number is a Palindrome      number","SUCCESS",MessageBoxButtons.OK,MessageBoxIcon.Information);
        }
        else
        {
            MessageBox.Show("The number is not a Palindrome number","FAILED",MessageBoxButtons.OK,MessageBoxIcon.Exclamation);
        }

Answer 11

public class Main {

    public static boolean Ispalindromic(String word) {

        if (word.length() < 2) {
            return true;
        }
        else if (word.charAt(0) != word.charAt(word.length() - 1)) {
            return false;
        } else {
            Ispalindromic(word.substring(1, word.length() - 1));
        }
        return true;
    }

    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        String word = sc.nextLine();
        System.out.println(Ispalindromic(word) ? "it is palidromic" : "it is not palidromic");
    }
}

Answer 12

This is my solution coming from a beginner:

        Console.Write("Enter a number to check if palindrome: ");
        bool palindrome = true;
        int x = int.Parse(Console.ReadLine());
        /* c is x length minus 1 because when counting the strings 
        length it starts from 1 when it should start from 0*/
        int c = x.ToString().Length - 1;
        string b = x.ToString();
        for (int i = 0; i < c; i++)
            if (b[i] != b[c - i])
                palindrome = false;
        if (palindrome == true)
            Console.Write("Yes");
        else Console.Write("No");
        Console.ReadKey();

Answer 13

You need to reverse the number then compare the result to the original number. If it matches, you have a palindrome. It should work irrespective of the number being even, odd or symmetric.

public static bool IsNumberAPalindrome(long num)
{
   return long.Parse(string.Join("", num.ToString().ToCharArray().Reverse().ToArray())) == num ? true : false;
}

Answer 14

The implementation is bellow:

public bool IsPalindrome(int x) {
    string test = string.Empty;
    string res = string.Empty;

    test = x.ToString();
    var reverse = test.Reverse();

    foreach (var c in reverse)
    {
        res += c.ToString();
    }

    return test == res;
}

Answer 15

1. You have a string, it can have integers, it can have characters, does not matter.
2. You convert this string to an array, depending on what types of characters the strings consist of, this may use to toCharArray method or any other related method.
3. You then use the reverse method that .NET provides to reverse your array, now you have two arrays, the original one and the one you reversed.
4. You then use the comparison operator (NOT THE ASSIGNMENT OPERATOR!) to check if the reversed one is the same as the original.

Answer 16

something like this

bool IsPalindrome(int num)
{
    var str = num.ToString();
    var length = str.Length;
    
    for (int i = 0, j = length - 1; length/2 > i; i++, j-- ){
        if (str[i] != str[j])
            return false;
    }
    return true;
}

you could even optimise it