Prime numbers, Prime Factors and LCM
IsPrime

public static bool IsPrime(int n)
{
    for (int i = 2; i &lt;= n; i++)
    {
        if (n % i == 0)
        {
            if (i == n)
                return true;
            else
                return false;
        }
    }
    return false;
}


Under what circumstances can the final return false be reached? Why not handle those special cases explicitly, and then simplify the loop body by reducing it?

public static bool IsPrime(int n)
{
    if (n &lt; 1) throw new ArgumentException("n");
    if (n == 1) return false;

    for (int i = 2; i &lt; n; i++)
    {
        if (n % i == 0) return false;
    }
    return true;
}


Of course, there are better ways of testing primality than trial division, but that's beside the point.

PrimeFactors

public static int[] PrimeFactors(int n)
{
    var factors = new List&lt;int&gt;();
    for (int i = 2; i &lt;= n; i++)
    {
        while (n % i == 0 &amp;&amp; IsPrime(i))
        {
            factors.Add(i);
            n = n / i;
        }
    }
    return factors.ToArray();
}


Any particular reason for returning int[] instead of IEnumerable&lt;int&gt;?

What's the purpose of the IsPrime call there? It's easy to prove that it always returns true (and so the IsPrime method isn't needed at all).

As a point of style, I prefer op= methods, but this is really subjective.

The loop guard might be more intelligible as n &gt; 1.

public static IEnumerable&lt;int&gt; PrimeFactors(int n)
{
    var factors = new List&lt;int&gt;();
    for (int i = 2; n &gt; 1; i++)
    {
        while (n % i == 0)
        {
            factors.Add(i);
            n /= i;
        }
    }
    return factors;
}


CreateCounterHash

private static Dictionary&lt;int, int&gt; CreateCounterHash(IEnumerable&lt;int&gt; mFactors)
{
    Dictionary&lt;int, int&gt; hash = new Dictionary&lt;int, int&gt;();
    foreach (var factor in mFactors)
    {
        if (hash.ContainsKey(factor))
            hash[factor]++;
        else
            hash.Add(factor, 1);
    }
    return hash;
}


Why does the return type use the implementation Dictionary rather than the interface IDictionary?

Why hard-code the type? You don't do anything with it other than equality checking, so it could be IDictionary&lt;T, int&gt; CreateCounterHash&lt;T&gt;(IEnumerable&lt;T&gt; elts) (and then could potentially be an extension method of IEnumerable&lt;T&gt;).

ContainsKey followed by a get is a minor inefficiency. Since TryGetValue will give default(int) (i.e. 0) if the key isn't, found, this can be fixed:

private static IDictionary&lt;T, int&gt; CreateCounterHash&lt;T&gt;(IEnumerable&lt;T&gt; elts)
{
    Dictionary&lt;T, int&gt; hash = new Dictionary&lt;T, int&gt;();
    foreach (var elt in elts)
    {
        int currCount;
        hash.TryGetValue(elt, out currCount);
        hash[elt] = currCount + 1;
    }
    return hash;
}


LCM

public static int LeastCommonMultipleByPrimeFactorization(int m, int n)
{
    //retrieve prime factors for both numbers
    int[] mFactors = PrimeFactors(m);
    int[] nFactors = PrimeFactors(n);

    //generate hash code to get counter for each factor 
    var mFactorsCountHash = CreateCounterHash(mFactors);
    var nFactorsCountHash = CreateCounterHash(nFactors);

    var primeFactors = new List&lt;int&gt;();
    primeFactors.AddRange(mFactors);
    primeFactors.AddRange(nFactors);

    int result = 1;

    //On each distinct factor... check either which number factors 
    foreach (int factor in primeFactors.Distinct())
    {
        int mfactorCount = 0;
        int nfactorCount = 0;
        if (mFactorsCountHash.ContainsKey(factor))
        {
            mfactorCount = mFactorsCountHash[factor];
        }

        if (nFactorsCountHash.ContainsKey(factor))
        {
            nfactorCount = nFactorsCountHash[factor];
        }

        int numberOfCount = mfactorCount &gt; nfactorCount ? mfactorCount : nfactorCount;
        result = factor * result * numberOfCount;
    }

    return result;
}


Looks buggy: factor * numberOfCount will only be correct when numberOfCount == 1 or factor == 2 &amp;&amp; numberOfCount == 2.

Also a tad repetitive. Can't you merge the two counts earlier?

public static IDictionary&lt;K, V&gt; MergeDictionaries&lt;K, V&gt;(IDictionary&lt;K, V&gt; d1,
                                                        IDictionary&lt;K, V&gt; d2,
                                                        Func&lt;V, V, V&gt; mergeFunc)
{
    // Left as an exercise
    // Only call mergeFunc when both dictionaries contain the key
}


You can also use a bit of Linq to do the aggregate, so the LCM simplifies to

public static int LeastCommonMultipleByPrimeFactorization(int m, int n)
{
    //retrieve prime factors for both numbers
    int[] mFactors = PrimeFactors(m);
    int[] nFactors = PrimeFactors(n);

    //generate hash code to get counter for each factor 
    var mFactorsCountHash = CreateCounterHash(mFactors);
    var nFactorsCountHash = CreateCounterHash(nFactors);

    var combinedCounts = MergeDictionaries(mFactorsCountHash, nFactorsCountHash, Math.Max);
    return combinedCounts.Aggregate(1, (prod, primeWithMult) =&gt; prod * pow(primeWithMult.Key, primeWithMult.Value));
}