✨ Shield now has support for Avalonia UI

Palindrome Programs in C# – Complete Guide

Sep 4, 2023 | .NET, C#

Dear fellow coder, let’s take a journey together into the intriguing world of palindrome programs in C#. Ever stumbled upon a word that reads the same forwards and backwards? Amazing, right? Congratulations, you’ve just encountered a palindrome. Whether it’s a string or number, C# provides us with robust techniques to check if a value is a palindrome. Buckle up, from understanding the basics to creating an intricate palindrome program, this guide has got you covered.

Understanding Palindrome in C#

Welcome aboard the palindrome express! In this section, we will decode the essence of a palindrome and its critical role in C#. Ready to dive in?

Fundamentals of Palindromes and their Role in C#

A palindrome, in its simplest form, remains identical whether you read it forward or backward. A prime example? Let’s take “madam”. I mean, isn’t it fascinating how regardless of reading direction, it stays the same?

Alright, but how does this fit into our coder’s realm of C#? Well, in coding, strings or numbers that read the same in either direction are considered palindromes. In some cases, your program may need to determine if a number or string is a palindrome. That’s where things get interesting!

Dealing with String Palindromes in C#

Let’s embark on another exciting journey, shall we? In the wild and vast territory of C#, we’re about to delve deeper into handling string palindromes. The key achievement we’re targeting here is to understand how to check if a given string forms a palindrome in C#. Hold on tight; it’s going to be both informative and fun!

In C#, seeking out palindromes can involve using in-built methods such as Array.Reverse() or manual methods using loops, comparing each character from the start and end. Let’s talk about the former method first.

string str = "madam";
char[] cArray = str.ToCharArray();
Array.Reverse(cArray);
string revStr = new string(cArray);

Console.WriteLine(str == revStr ? "The string is a palindrome." : "No, it's not a palindrome.");

Here, we first convert our string into a char array using ToCharArray() method, then we call Array.Reverse() to reverse our char array. We create a new string from this reversed array. If our initial string matches this reversed string, we have a palindrome.

For our fellow purists who like to keep things manual, how about a method that doesn’t involve using in-built methods? Below is an instance of it.

string str = "madam";
int len = str.Length;
bool isPalindrome = true;

for(int i = 0; i < len / 2; i++) {
    if(str[i] != str[len - 1 - i]) {
        isPalindrome = false;
        break;
    }
}
Console.WriteLine(isPalindrome ? "The string is a palindrome." : "No, it's not a palindrome.");

In this method, we create a boolean variable isPalindrome and set it to true as initial value. We then loop halfway through our string, comparing the element at the current index with its corresponding element from the end. If we find a mismatch, we break from the loop and set isPalindrome to false.

Checking for Non-Palindromes in C#

While getting hands-on experience with palindromes gives you the thrill; a good programmer always stays vigilant for the less glamorous non-palindromes, or should we say, “not palindrome C#”. How do you think we uncover such strings?

Well, our previous code snippets for string palindrome do the heavy lifting here as well. Remember when we found a mismatch while comparing characters from start and end and broke the loop? That’s when we encountered a non-palindrome. The string “Hello”, for example, would fail the palindrome test.

Here’s how we can modify our manual method to identify non-palindromes:

string str = "Hello";
int len = str.Length;
bool isPalindrome = true;

for(int i = 0; i < len / 2; i++) {
    if(str[i] != str[len - 1 - i]) {
        isPalindrome = false;
        break;
    }
}
Console.WriteLine(isPalindrome ? "The string is a palindrome." : "No, it's not a palindrome. Gotcha non-palindrome!");

Did you notice the execution? The string “Hello” doesn’t pass the palindrome test, thereby confirming it as a non-palindrome.

Checking for Palindromes in C#

Alright, was creating the palindrome program a breeze or what? Now, comes the intriguing part: checking if a programmed string or number is a palindrome.

Take this example:

int n, r, sum=0, temp;
Console.Write("Enter the Number: ");
n = int.Parse(Console.ReadLine());
temp = n;  

while(n>0)    
{    
    r=n%10;    
    sum=(sum*10)+r;    
    n=n/10;  
}    
if(temp==sum)    
   Console.Write("Number is Palindrome.");    
else      
   Console.Write("Number is not Palindrome");
}

In this code, we divide the number by 10 in each iteration and add remainder to the sum variable multiplied by 10. Finally, we compare the sum with the original number to determine if it’s a palindrome.

Working with Number Palindromes in C#

In the computational sphere, palindromes often creep into more places than just strings. Yes, they have their share of fun with numeric sequences too! If the mystery of “number palindrome C#” intrigued you, let’s probe further into number palindromes in C#.

Coding a Number Palindrome in C#

Step into the number palindrome’s territory in C#, a puzzle that will put your coding abilities to the test! We’ll create a program to identify these symmetric marvels.

Here’s an example of a number palindromic sequence:

int number, remainder, reverseNumber = 0, temp;     

Console.Write("Enter a number : ");  
number = int.Parse(Console.ReadLine());  
temp = number;  

while (number > 0)  
{  
    remainder = number % 10; //Process to get the remainder of the number  
    reverseNumber = (reverseNumber * 10) + remainder; //Create the reverse number  
    number = number / 10;  //Reduce the number for the next iteration  
}   

if(temp == reverseNumber)  
    Console.Write("Entered number is a Palindrome.\n");  
else  
    Console.Write("Entered number is not a Palindrome.\n"); 

What does this code do? It prompts you to enter a number. It then creates a reversed copy of that number by repeatedly taking the remainder of your number when divided by 10 (this gets us the last digit) and adding it onto what we’ve built so far. Then the code reduces your number by removing this last digit, ready for the next iteration.

The magic gang of number = number / 10; and reverseNumber = (reverseNumber * 10) + remainder; is what makes this possible. Once we have the reversed number, it’s a simple equality check to see if the original number and the reversed number are the same!

Wait, let’s make the issues a bit more challenging and compelling. We can extend our program to handle a range of numbers and return all palindromic numbers within that range.

Console.Write("Enter a starting number : ");  
int start = int.Parse(Console.ReadLine());

Console.Write("Enter an ending number : ");  
int end = int.Parse(Console.ReadLine());

for(int i=start; i<=end; i++)
{
    int number, remainder, reverseNumber = 0, temp;
    number = i;
    temp = number;

    while(number>0)  
    {  
        remainder = number % 10;  
        reverseNumber = (reverseNumber * 10) + remainder;  
        number = number / 10;  
    }   

    if(temp == reverseNumber)  
        Console.WriteLine(i + " is a Palindrome.\n");
}

This time, our program takes a starting and ending number as input and uses a loop to check for all palindrome numbers within that range.

Have we wowed you yet? Palindromes, both in strings and numbers, are incredible tools to spice up your C# coding journey. Now, how about putting these new tricks you learned into practice? After all, aren’t things more fun when you’ve mastered them?

Learning is a never-ending journey, especially in coding. But remember, every expert was once a beginner who didn’t quit. So keep going, keep striving, and keep decoding! Happy coding!

You May Also Like