How to find all combinations of 30 integers within 0-1000

Question

I am looking for a way to find all combinations of a 30 numbers in numbersArray which has numbers between 0-1000.

        For example 1st combination is: 0,1,2,3,4,5,6......29,30
        For example 2nd combination is: 0,2,3,4,5,6,7......30,31
        For example 2rd combination is: 0,3,4,5,6,7,8......31,32

Then continue to find all combinations. Any number must only appear once in the series of 30 numbers.

The very important detail here is if it is possible while create those combinations, then use them straight away. With other words, not storing the combinations first and then iterating through them again. Which would mean double amount of iterations?

Thank you!

    void findcombinations()
    {
        //Declaring the array with 1000 indexes
        //The number of indexes can be up to 100,000 indexes
        int[] numbersArray = new int[1000];
        for (int i = 0; i < numbersArray.Length; i++)
        {
            numbersArray[i] = i; //Assign number from 0-1000
        }

        //How to find all combinations of 30 numbers between: 0-1000?
        //For example 1st combination is: 0,1,2,3,5,6,7......29,30
        //For example 2nd combination is: 0,2,3,5,6,7,8......30,31
        //For example 2rd combination is: 0,3,5,6,7,8,9......31,32

        //How to dynamically find all combinations of a group of 30 numbers between 0-1000?
        
        //Not perheps exactly use the below approach because that would mean that we already have filled the
        //Array with the combinations.

        //I am trying to see if there is a dynamic approach where the combinations are produced right away so 
        //They can be used straight away as they are produced?
        int[,] allCombinations = new int[???,30]; ///??? How many combinations of 30 numbers 
        for (int i = 0; i < allCombinations.Length; i++)
        {
            for (int i2 = 0; i2 < allCombinations.GetLength(i); i2++)
            {
                //Do something with the combination of numbers here
            }
        }
    }

Answer 1

Here you have the solution:

using System;
using System.Collections.Generic;

namespace combinatory
{
    public class Combinations
    {
        private readonly int n;
        private readonly int k;
        private readonly int[] combination;

        public Combinations(int n, int k)
        {
            if (n <= 0) throw new ArgumentException("n argument must be greater than 0", nameof(n));
            if (k <= 0) throw new ArgumentException("k argument must be greater than 0", nameof(k));
            if (n < k) throw new ArgumentException("k argument must be greater or equals to n", nameof(k));

            this.n = n;
            this.k = k;

            combination = new int[k];

            for (int i = 0; i < k; i++)
            {
                combination[i] = i;
            }
        }

        public IEnumerable<int[]> Get()
        {
            yield return combination;
            while (TrySetNextCombination())
            {
                yield return combination;
            }
        }

        private bool TrySetNextCombination()
        {
            int incrementableIndex = findFirstIncrementableIndex();
            if (incrementableIndex < 0) return false;
            var value = combination[incrementableIndex];
            for (int i = incrementableIndex; i < k; i++)
            {
                combination[i] = ++value;
            }
            return true;
        }

        private int findFirstIncrementableIndex()
        {
            int index = k - 1;
            int threshold = n - 1;
            while (index >= 0)
            {
                if (combination[index] < threshold) return index;
                index--;
                threshold--;
            }
            return index;
        }
    }
}

The class Combinations has a constructor that takes n and k arguments. n is the number of elements in the set, k is the number of elements in the subset. It has the Get method, it enumerates all combinations. It is very memory efficient because it just need an array of k integers. The key point is to initialize the first combination and then calculate the next one.

This is how you can use it:

using System;

namespace combinatory
{
    class Program
    {
        static void Main(string[] args)
        {
            var combinations = new Combinations(6, 3);
            foreach (var comb in combinations.Get())
            {
                foreach (var v in comb)
                {
                    Console.Write(" ");
                    Console.Write(v);
                }
                Console.WriteLine();
            }
        }
    }
}

This is the output:

 0 1 2
 0 1 3
 0 1 4
 0 1 5
 0 2 3
 0 2 4
 0 2 5
 0 3 4
 0 3 5
 0 4 5
 1 2 3
 1 2 4
 1 2 5
 1 3 4
 1 3 5
 1 4 5
 2 3 4
 2 3 5
 2 4 5
 3 4 5

Answer 2

In fact, if you want just the number of combinations, there's a mathematical compution for this:

n! / (p! . (n - p)!)

Where n is the total number count (1000), and p is de picked count (30).

Source: https://en.m.wikipedia.org/wiki/Combination