C# 用repetition获得k元素的所有组合

我想得到所有可能的重复组合的列表

e、 g

为此，我使用改进的方法，这是工作良好

public static IEnumerable<IEnumerable<T>> CombinationsWithRepeat<T>(this IEnumerable<T> elements, int k)
{
    return k == 0 ? new[] { new T[0] } : elements.SelectMany((e, i) => elements.CombinationsWithRepeat(k - 1).Select(c => (new[] { e }).Concat(c)));
}

给你：

    const int SelectionSize = 4;

    private static long _variationsCount = 0;
    private static int[] _objects;
    private static int[] _arr;

    static void Main(string[] args)
    {
        _objects = new int[]{1,2,3,4,5,6,7,8,9,10};
        _arr = new int[SelectionSize];

        GenerateVariations(0);
        Console.WriteLine("Total variations: {0}", _variationsCount);
    }

    static void GenerateVariations(int index)
    {
        if (index >= SelectionSize)
            Print();
        else
            for (int i = 0; i < _objects.Length; i++)
            {
                _arr[index] = i;
                GenerateVariations(index + 1);
            }
    }

    private static void Print()
    {
        //foreach (int pos in arr)
        //{
        //    Console.Write(objects[pos] + " ");
        //}
        //Console.WriteLine();
        _variationsCount++;
    }

const int SelectionSize=4；
私有静态长变量cont=0；
私有静态int[]_对象；
专用静态int[]\u arr；
静态void Main（字符串[]参数）
{
_objects=newint[]{1,2,3,4,5,6,7,8,9,10}；
_arr=新整数[SelectionSize]；
代际差异（0）；
WriteLine（“总变量：{0}”，_variationScont）；
}
静态空隙生成偏差（整数指数）
{
如果（索引>=选择大小）
打印（）；
其他的
对于（int i=0；i<\u objects.Length；i++）
{
_arr[index]=i；
发电差（指数+1）；
}
}
私有静态void Print（）
{
//foreach（arr中的int pos）
//{
//Console.Write（对象[pos]+“”）；
//}
//Console.WriteLine（）；
_variationScont++；
}

---

即使选择大小为10（大约需要2分钟），它也可以工作。但请记住，控制台打印速度非常慢，这就是我将其注释掉的原因。如果要打印列表，可以使用stringbuilder，仅在程序完成时打印。

函数中没有问题。如果不尝试将生成的IEnumerable放入内存（例如调用ToArray（）），则不会出现内存异常

下面的例子很好用

class Program
{
    static void Main(string[] args)
    {
        var input = Enumerable.Range(1, 60);

        using (var textWriter = File.AppendText("result.txt"))
        {
            foreach (var combination in input.CombinationsWithRepeat(10))
            {
                foreach (var digit in combination)
                {
                    textWriter.Write(digit);
                }
                textWriter.WriteLine();
            }
        }
    }
}

public static class Extensions
{
    public static IEnumerable<IEnumerable<T>> CombinationsWithRepeat<T>(this IEnumerable<T> elements, int k)
    {
        return k == 0 ? new[] { new T[0] } : elements.SelectMany((e, i) => elements.CombinationsWithRepeat(k - 1).Select(c => (new[] { e }).Concat(c)));
    }
}

类程序
{
静态void Main（字符串[]参数）
{
var输入=可枚举范围（1,60）；
使用（var textWriter=File.AppendText（“result.txt”））
{
foreach（输入中的var组合。组合SwithRepeat（10））
{
foreach（组合中的var数字）
{
textWriter.Write（数字）；
}
textWriter.WriteLine（）；
}
}
}
}
公共静态类扩展
{
公共静态IEnumerable组合swithrepeat（此IEnumerable元素，int k）
{
返回k==0？new[]{new T[0]}:elements.SelectMany（（e，i）=>elements.CombinationsWithRepeat（k-1）.Select（c=>（new[]{e}）.Concat（c））；
}
}

但即使在hardrive上，您也没有足够的空间来存储结果。有60^10个组合。每个组合使用10-20个字节

---

您希望如何使用函数的结果？

是否已修复

K=10

？如果是这样，您是否尝试过10个嵌套for循环（丑陋，但可能有效）？@Corak-no

K

也可以是不同的数字-该部分必须是动态的，因为查看可能会有所帮助。您需要将

TinySet

从

Int32

调整为

Int64

来存储数据点，否则它可能只能生成所有604661760000000000项……啊，对不起，这似乎没有重复。不过，它可能会为您指出一个有用的方向。不过，“最简单”的方法是让T4为

K

的不同值创建方法，然后使用拟合方法。又一次：丑陋，但有效。太棒了！稍微建议增加灵活性：

public类组合{public composition（IEnumerable items）{mItems=items.ToArray（）；}private readonly T[]mItems；private T[]mResult；public void getcompositions（int k，Action Action）{mResult=new T[k]；GenerateVariations（0，k，Action）；}private void GenerateVariations（int-index，int-k，Action-Action）{if（index>=k）{Action（mResult）；}else{foreach（mItems中的var项）{mResult[index]=item；GenerateVariations（index+1，k，Action）；}}}}}}

你说得对，我有一个

ToList（）

并在内存中具体化了整个列表。您在

Main

中的调用非常有效！我将数据存储在数据库中。但您仍然没有足够的空间存储结果）

    const int SelectionSize = 4;

    private static long _variationsCount = 0;
    private static int[] _objects;
    private static int[] _arr;

    static void Main(string[] args)
    {
        _objects = new int[]{1,2,3,4,5,6,7,8,9,10};
        _arr = new int[SelectionSize];

        GenerateVariations(0);
        Console.WriteLine("Total variations: {0}", _variationsCount);
    }

    static void GenerateVariations(int index)
    {
        if (index >= SelectionSize)
            Print();
        else
            for (int i = 0; i < _objects.Length; i++)
            {
                _arr[index] = i;
                GenerateVariations(index + 1);
            }
    }

    private static void Print()
    {
        //foreach (int pos in arr)
        //{
        //    Console.Write(objects[pos] + " ");
        //}
        //Console.WriteLine();
        _variationsCount++;
    }

class Program
{
    static void Main(string[] args)
    {
        var input = Enumerable.Range(1, 60);

        using (var textWriter = File.AppendText("result.txt"))
        {
            foreach (var combination in input.CombinationsWithRepeat(10))
            {
                foreach (var digit in combination)
                {
                    textWriter.Write(digit);
                }
                textWriter.WriteLine();
            }
        }
    }
}

public static class Extensions
{
    public static IEnumerable<IEnumerable<T>> CombinationsWithRepeat<T>(this IEnumerable<T> elements, int k)
    {
        return k == 0 ? new[] { new T[0] } : elements.SelectMany((e, i) => elements.CombinationsWithRepeat(k - 1).Select(c => (new[] { e }).Concat(c)));
    }
}