Sem motivo específico, decidi procurar um algoritmo que produza todas as opções possíveis de k inteiros entre 1 ... n, em que a ordem entre o k inteiro não importa (o n escolhe k coisinha

Pelo exato mesmo motivo, o que não é de todo, eu também o implementei em C #. Minha pergunta é

Você vê algum erro no meu algoritmo ou código? E, mais importante,pode sugerir um algoritmo melhor?

Preste mais atenção ao algoritmo do que ao próprio código. Não é o código mais bonito que já escrevi, apesar de saber se você vê um err

EDITAR Alogirthm explicou -

Temos índices k.Isso cria k aninhadopar loops, onde o índice do loop i é índices [i]. Simula kpar loops em que os índices [i + 1] pertencem a um loop aninhado dentro do loop de índices [iindices [i] roda dos índices [i - 1] + 1 para 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);
            }
        }
    }
}

Peço desculpas pela longa pergunta, ela pode ser adequada para um post no blog, mas quero a opinião da comunidade aqu

Obrigado
Asaf