Simple script to find the largest number palindrome

Question

I have made a simple C# script that will find the largest palindrome made by the product of two numbers. These numbers will be between a minimum and maximum value, inputted by int.Parse(Console.ReadLine()). Is there a way to make this better?

It is brute force, however I tried to make it use fewer numbers if one combination gives a smaller palindrome. The numbers are generated in a for loop.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.Diagnostics;

namespace ProjectEuler
{
    class Solution
    {
        static void Main( /*I am not sure what the point is for String args. If anybody can explain?*/ )
        {
            Console.Clear();
            Console.WriteLine("What would the maiximum value be for these numbers?");
            int max = int.Parse(Console.ReadLine());

            Console.WriteLine("\nWhat would the minimum value be for these numbers?");
            int min = int.Parse(Console.ReadLine());

            int largestNumb1 = 0;
            int largestNumb2 = 0;
            int generatedPalindrome = 0;

            for (int number1 = max; number1 >= min; number1--)
            {
                for (int number2 = max; number2 >= min; number2--)
                {
                    string generatedNumber = (number1 * number2).ToString();
                    if (IsPalindrome(generatedNumber))
                    {
                        if (int.Parse(generatedNumber) > generatedPalindrome)
                        {
                            generatedPalindrome = number1 * number2;
                            largestNumb1 = number1;
                            largestNumb2 = number2;
                            //This is mainly done to increase 'subtle' performance, by skipping numbers
                            //that will never give a larger number than the previous palindrome
                            number1--;
                            number2 = max;
                        }
                        else if (int.Parse(generatedNumber) < generatedPalindrome)
                        {
                            //This is mainly done to increase 'subtle' performance, by skipping numbers
                            //that will never give a larger number than the previous palindrome
                            number1--;
                            number2 = max;
                        }
                    }
                }
            }
            PrintAnswer(generatedPalindrome, largestNumb1, largestNumb2);
        }

        static bool IsPalindrome(string generatedNumber)
        {
            char[] answerChar = generatedNumber.ToCharArray();
            Array.Reverse(answerChar);
            string reversedString = new string(answerChar);

            if (generatedNumber == reversedString)
            {
                return true;
            }
            else
            {
                return false;
            }

        }

        static void PrintAnswer(int generatedPalindrome, int largestNumb1, int largestNumb2)
        {
            Console.Clear();
            if (generatedPalindrome != 0)
            {
                Console.WriteLine("Largest possible palindrome given limit: {0}\nNumbers used: {1} & {2}", generatedPalindrome, largestNumb1, largestNumb2);
                Console.ReadLine();
            }
            else
            {
                Console.WriteLine("Sorry, but no valid palindrome was generated given your values.\nWould you like to try again? (y)");
                if (Console.ReadLine() == "y")
                {
                    Main();
                }
                else
                {
                    return;
                }
            }
        }
    }
}

Answer 1

For getting integers (or any other data that needs to be validated) from the user, sometimes it's best to create a separate function that you can call. For example:

static int GetIntFromUser(string prompt)
{
    int input;

    while (true)
    {
        if (prompt != null) Console.Write(prompt);
        if (int.TryParse(Console.ReadLine(), out input)) break;
        Console.WriteLine("Sorry, {0} is not a valid integer. Please try again.", input);
    }

    return input;
}

Then you can use it like:

int max = GetIntFromUser("Enter the maximum value for these numbers: ");
int min = GetIntFromUser("Enter the minimum value for these numbers: "); 

Answer 2

Your IsPalindrome method is inefficient. It's unnecessary to reverse the char array and compare with the origin. You need one pointer starting from the head and another pointer going from the tail of the array, when arr[head] doesn't equal to arr[tail], you breaks the loop and return false, which means the number is not a palindrome.

And some more polishing things:

1. The code will not check the input of the user, "abc" will make the application crash because int.Parse throws an exception.

2. It confuses a lot if you change the value of the looping variables (number1 & number2) inside the loop. Since a * b = b * a, you can make number2 loops from number1 ~ min.

Answer 3

One improvement, the inner loop doesn't need to check with values already used(10 * 3 == 3 * 10). Start the inner loop from number1-1:

for (int number2 = number1 - 1; number2 >= min; number2--)

Checking for largest palindrome can be much simpler using a temporary variable. And as was mentioned reversing a char array is less efficient than checking the digits from each end:

static long largestPalindrome(int max, int min, out int num1, out int num2)
{
    int i = max;
    int j = 0;
    min--;
    long largestPalindrome = 0;
    long result = 0;
    num1 = 0;
    num2 = 0;
    //If you look at the inner loop, j starts at i-1. This way the inner loop doesn't look
    // at combinations that have already been looked at. By declaring the loop variable 
    //outside the loop you can use the variable after the loop is finished, if necessary.
    // This also means that you don't need to declare it inside the loop and that portion
    // can stay empty.
    for (; i > min; i--)
    {
        for (j = i - 1; j > min; j--)
        {
            result = j * i;
            if (result < largestPalindrome)
            {
                break;
            }
            if (isPalindrome(result) && result > largestPalindrome)
            {
                largestPalindrome = result;
                num1 = i;
                num2 = j;
            }
        }
    }

    return largestPalindrome;
}
static bool isPalindrome(long num)
{
    //This function will loop through half the string comparing each digit in the front 
    //half with the corresponding digit in the back half, and exit if they're not equal.
    //Since this loops through only half the digits, this is more efficient than 
    //`Array.Reverse`, since that loops through all the digits.
    //Side note:  Even or odd number of digits is handled correctly.
    var temp = num.ToString();
    int limit = temp.Length / 2;
    int lastIndex = temp.Length-1;
    for(int i = 0; i < limit;i++)
    {
        if(temp[i] != temp[lastIndex - i])
        {
            return false;
        }
    }
    return true;
}

I am not sure what the point is for String args. If anybody can explain?

Those are to accept command line arguments.