Iterative implementation of K of N variations
Your code is wrong: if I test it with n=3, k=3 I get


  (1 1 1), (1 1 2), (1 1 3), (1 2 2), (1 2 3), (1 3 3), (2 5 4), (3 7 6)


However, you're on the right lines. Assuming that you want (or at least don't mind) to return each combination in ascending order, the way that I find intuitive to think about it is as a set of k nested loops:

for (combination[0] = 1; combination[0] &lt;= n; combination[0]++)
    for (combination[1] = combination[0]; combination[1] &lt;= n; combination[1]++)
        ...
            for (combination[k] = combination[k-1]; combination[k] &lt;= n; combination[k]++)
                PrintCombination(combination);


To turn that into an iterative approach, you count but when you overflow then instead of resetting to 0 you reset to the final value which doesn't overflow. I agree with Kore's now deleted answer that you should use Enumerable.Repeat to initialise, and I also think you should make the generation method generate rather than print, so it comes down to

    private static IEnumerable&lt;int[]&gt; FindCombinations(int n, int k)
    {
        var combination = Enumerable.Repeat(1, k).ToArray();
        while (true)
        {
            // generate current combination
            yield return (int[])combination.Clone();

            // find index which isn't going to overflow
            int index = k - 1;
            while (combination[index] == n)
            {
                if (--index &lt; 0) yield break;
            }

            // increment and fill right
            for (int finalDigit = combination[index] + 1; index &lt; n; index++)
            {
                combination[index] = finalDigit;
            }
        }
    }


The performance is O(n) per combination returned, and that is optimal (just cloning the answer to return it is already O(n), and even if we don't clone and guarantee elsewhere that we won't modify the array, we'll still surely want to use it).