Determining numeric palindromes

I do not do C# but I can offer another way of approaching the problem:

As our range of numbers is \$[100\cdot100, 999\cdot999] = [10000, 998001]\$, assume a palindromic number on the form \$abccba\$.

The largest \$abccba < 998001\$ is \$k = abccba = 997799\$. We need to determine if \$k\$ can be written as the product of two 3-digit numbers. Using a prime table (or generate one with a sieve at program start) see if any prime number \$p\$ where \$\min\left(\frac{k}{100}, 999\right) \lt p\le k\$ evenly divides \$k\$.

If you can find such a prime then we know that \$\frac{k}{p} \lt 100 \$ and any remaining factors are too small or that \$p \gt 999\$ and we have a factor that is too large. So we can discard \$k\$ and decrement \$c\$ by one to form the next smaller palindrome, eg. \$k=996699\$, and keep trying smaller palindromes.

If you reach \$p\lt \min\left(\frac{k}{100}, 999\right) \$ without finding any prime that evenly divides \$k\$ we need to convince ourselves that the remaining factors can be grouped so both are three digits.

There are a few ways to convince ourselves that the above. One way is trial division by simply trying all divisors \$d\$ such that \$100\le d \le \max\left(\frac{k}{100}, 999\right)\$ and checking what the other factor is.

Another more elegant way is to use the fact that we know that there is no prime factor larger than \$p\le\min\left(\frac{k}{100}, 999\right)\$ and find the largest prime factor \$p_{max}\le\min\left(\frac{k}{100}, 999\right)\$ and let \$r_i = \frac{k}{p_{max}}\$.

Let the prime factors of \$r_i\$ be \$p_i\$ and let \$Q=\prod_{\forall i:p_i<\frac{999}{p_{max}}}p_i\$. At this point you have the largest prime factor of \$k\$ as \$p_{max}\$ and all prime factors of \$r_i=\frac{k}{p_{max}}\$ that are too big to be together with \$p_{max}\$ multiplied together as \$Q\$.

Now, factor \$\frac{r_i}{Q}\$ into primes \$P_k\$. Each of the \$P_k\$ primes has to be multiplied into either \$Q\$ or \$p_{max}\$. Iteratively try all combinations (and exit early for impossible branches) until you find one that is satisfactory or retry next smallest palindrome if no combination was found.

Note: This may well be slower than trial multiplication but it's another way to approach the problem and it may give birth to other ideas.

Considering other answers, here is my updated solution :

class P004
{
    private const int NumberOfDigits = 3;
    private readonly static int UpperBound = (int)Math.Pow(10, NumberOfDigits) - 1;
    private readonly static int LowerBound = (int)Math.Pow(10, NumberOfDigits -1);

    static void Main(string[] args)
    {
        int currentMax = 0;
        for (int i = UpperBound; i >= LowerBound; i--)
        {
            for (int k = i - 1; k >= currentMax / i; k--)
            {
                int num = i * k;
                if (IsPalindrome(num))
                {
                    if (currentMax < num) 
                    {
                        currentMax = num;
                    }
                }
            }
        }

        Console.WriteLine(currentMax);
        Console.ReadLine();
    }

    static bool IsPalindrome(long testNumber)
    {
        var n = testNumber;
        var rev = 0L;
        while (testNumber > 0)
        {
            var dig = testNumber % 10;
            rev = rev * 10 + dig;
            testNumber = testNumber / 10;
        }
        return n == rev;
    }

}

Don't know if it helps, but here is my solution, in a more "Linq" way :

    private const int NumberOfDigits = 3;
    static void Main(string[] args)
    {
        var r = from x in NumbersWithNDigits(NumberOfDigits, (int)Math.Pow(10, NumberOfDigits - 1))
                from y in NumbersWithNDigits(NumberOfDigits, x + 1) 
                let p = x*y
                let pStr = p.ToString()
                where pStr == new string(pStr.Reverse().ToArray())
                select new { x,y, p };

        Console.WriteLine(r.Max(s=>s.p));

        Console.ReadLine();
    }


    static IEnumerable<int> NumbersWithNDigits(int n, int lowerBound)
    {
        int upperBound =(int) Math.Pow(10,n) -1;

        return Enumerable.Range(lowerBound, upperBound - lowerBound + 1);
    }

The code may be a bit faster by replacing the Enumerable.Range with a classic for loop, but with only 1000 numbers to enumerate, it's not a critical issue.

I second @MikeNakis.
Additionally:

If you only want the largest, why not check from the top down? Just mind the pitfall that the first found might not be the largest.
(583 x 995 = 580085; 517 x 995 = 514415; 913 x 993 = 906609; 121 x 991 = 119911)

private int? GetLargestNumericPalindrome(int minBound, int maxBound) {
    int largestFound = minBound - 1;
    for (int i = maxBound; i >= minBound; i--) {
        // "taking advantage of the fact that A*B = B*A"
        // So we don't need to check N*maxBound since we already checked maxBound*N...
        // So only checking from N*N downwards.
        for (int k = i; k >= minBound; k--) {
            int num = i*k;
            if (num <= largestFound) {
                break; // Any other values of k for this i will also be lower.
            }
            if (IsPalindrome(num)) {
                largestFound = num;
                if(k > minBound) {
                    // Black magic. Prove with logic and THEN uncomment this next line.
                    //minBound = k;
                }
                break;
            }
        }
    }
    if(largestFound < minBound) {
        return null;
    }
    return largestFound;
}

private bool IsPalindrome(int num) {
    // Use OP's implementation.
    // Consider @MikeNakis's comments.
    throw new NotImplementedException();
}

Building on @Neves, but filtering with multiples of 10 and leveraging the inner for loop to reduce multiplications:

private int? GetLargestNumericPalindrome(int minBound, int maxBound) {
    int largestFound = 0;
    for (int i = maxBound; i >= minBound; i--) {
        // Normally, numbers don't have leading zeros, 
        // so palindromes don't have trailing zeros.
        // Testing this up front seems worthwhile (almost a 10% improvement?).
        if (i % 10 == 0) {
            continue;
        }
        int smallestWorthChecking = i * minBound;
        if (smallestWorthChecking <= largestFound) {
            smallestWorthChecking = largestFound + 1;
        }
        // "taking advantage of the fact that A*B = B*A"
        // So we don't need to check N*maxBound since we already checked maxBound*N...
        // So only checking from N*N downwards.
        for (int num = i*i; num >= smallestWorthChecking; num -= i) {
            // ... palindromes don't have trailing zeros.
            if (num % 10 != 0 && IsPalindrome(num)) {
                largestFound = num;
                break;
            }
        }
    }
    if(largestFound == 0) {
        return null;
    }
    return largestFound;
}

synthesizing ideas from @MikeNakis -- no need to reverse/match the whole, and @SteveB -- keeping it numeric

static bool IsPalindrome(long testNumber)
{
    var reversed = 0L;
    var forward = testNumber
    while (reversed < forward)
    {
        var digit = forward % 10;
        reversed = reversed * 10 + digit;
        forward = forward / 10;
    }
    // Here, reversed can have at most 1 more digit than forward
    // Test for even palindromes, forward and reversed identical,
    // or odd palindromes, reversed adds 1 extra digit
    return forward == reversed || forward == reversed / 10;
}

In addition to Mike Nakis's great suggestions, I think the IsPalindrome function can be made more simple and readable like this:

static bool IsPalindrome(long testNumber)
{
    var stringRepresentation = testNumber.ToString("d");

    return stringRepresentation == Reverse(stringRepresentation);
}

private static string Reverse(string stringRepresentation)
{
    var charArray = stringRepresentation.ToCharArray();
    Array.Reverse(charArray);

    return new string(charArray);
}

This also reduced the total execution time on my machine from 416ms to 246ms.