Sin ninguna razón en particular, decidí buscar un algoritmo que produzca todas las opciones posibles de k enteros entre 1 ... n, donde el orden entre los k enteros no importa (la n elige k cosita).

De la misma razón exacta, que no es ninguna razón, también lo implementé en C #. Mi pregunta es

¿Ves algún error en mi algoritmo o código? Y más importante,Puedes sugerir un algoritmo mejo

Presta más atención al algoritmo que al código en sí. No es el código más bonito que he escrito, aunque sí se nota si ve un error.

EDITAR Alogirthm explicó -

Tenemos k índices. Esto crea k anidadopar bucles, donde el índice del bucle i son índices [i]. Simula kpar bucles donde los índices [i + 1] pertenecen a un bucle anidado dentro del bucle de índices [i].indices [i] se ejecuta desde índices [i - 1] + 1 hasta n - k + i + 1.

CÓDIGO

public class AllPossibleCombination
{
    int n, k;
    int[] indices;
    List<int[]> combinations = null;

    public AllPossibleCombination(int n_, int k_)
    {
        if (n_ <= 0)
        {
            throw new ArgumentException("n_ must be in N+");
        }
        if (k_ <= 0)
        {
            throw new ArgumentException("k_ must be in N+");
        }
        if (k_ > n_)
        {
            throw new ArgumentException("k_ can be at most n_");
        }

        n = n_;
        k = k_;
        indices = new int[k];
        indices[0] = 1;
    }

    /// <summary>
    /// Returns all possible k combination of 0..n-1
    /// </summary>
    /// <returns></returns>
    public List<int[]> GetCombinations()
    {
        if (combinations == null)
        {
            combinations = new List<int[]>();
            Iterate(0);
        }
        return combinations;
    }

    private void Iterate(int ii)
    {
        //
        // Initialize
        //
        if (ii > 0)
        {
            indices[ii] = indices[ii - 1] + 1;
        }

        for (; indices[ii] <= (n - k + ii + 1); indices[ii]++)
        {
            if (ii < k - 1)
            {
                Iterate(ii + 1);
            }
            else
            {
                int[] combination = new int[k];
                indices.CopyTo(combination, 0);
                combinations.Add(combination);
            }
        }
    }
}

Me disculpo por la larga pregunta, podría ser adecuada para una publicación de blog, pero sí quiero la opinión de la comunidad aquí.

Gracias
Asaf