如何从迭代法过渡到递归法
本文关键字：过渡到 递归 迭代 | 更新日期: 2023-09-27 18:18:44
我有一个迭代的c#循环，它填充了多达5列的checkboard模式。
这些值是成对的，它总是一个标题和每个列的多个值，并且它将这些值组合成一个非重复的组合。
从我能想到的最简单的解决方案开始，在看了它之后，我认为一定有一个更好的方法来解决这个问题，通过递归的方式。
下面是我到目前为止尝试的一个例子:
List<EtOfferVariant> variants = new List<EtOfferVariant>();
_containers[0].Variant.ForEach(first =>
{
if (_containers.Count > 1)
{
_containers[1].Variant.ForEach(second =>
{
if (_containers.Count > 2)
{
_containers[2].Variant.ForEach(third =>
{
EtOfferVariant va = new EtOfferVariant();
va.OfferVariant1Type = _containers[0].VariantKey;
va.OfferVariant1 = first;
va.OfferVariant2Type = _containers[1].VariantKey;
va.OfferVariant2 = second;
va.OfferVariant3Type = third;
va.OfferVariant3 = _containers[3].VariantKey;
variants.Add(va);
});
}
else
{
EtOfferVariant va = new EtOfferVariant();
va.OfferVariant1Type = _containers[0].VariantKey;
va.OfferVariant1 = first;
va.OfferVariant2Type = second;
va.OfferVariant2 = _containers[1].VariantKey;
variants.Add(va);
}
});
}
else
{
EtOfferVariant va = new EtOfferVariant();
va.OfferVariant1Type = _containers[0].VariantKey;
va.OfferVariant1 = first;
variants.Add(va);
}
});
容器由字符串列表(值)和键(标题)组成。
这是一个缩短版OfferVariant在实际示例中最多计数为5。
我不能改变初始的checkboard结构，因为它是由现有的数据库给出的。
下面是2个容器的数据输入和输出示例:
容器1:
- 关键:派
- 价值观:
- 覆盆子 草莓
容器2:
- 关键:喝
- 价值观:
- 可乐, 咖啡
生成的输出将由包含
的4行组成编辑，因为它很容易被误解，正如这里所示
结果将是由4列组成的数据库中的一行
Column 1 | Column 2 | Column 3 | Column 4
Pie | Raspberry | Drink | Cola
Pie | Raspberry | Drink | Coffee
Pie | Strawberry| Drink | Cola
Pie | Strawberry| Drink | Coffee
EtOfferVariant是一个ORM Poco，包含以下列
感谢您的回复，马丁·利弗西奇在精神上引导了我，但它并不是一个纯粹的笛卡尔积，因为它被归为平面积和中国的方法给了我最后一点在正确的方向，我解决了这个问题，现在
在第一步中，我为第一个变量 生成初始行 List<EtOfferVariant> row = new List<EtOfferVariant>();
_containers.First().Variant.ForEach(o =>
{
row.Add(new EtOfferVariant() { OfferVariant1 = o, OfferVariant1Type = _containers.First().VariantKey });
});
return BuildVariants(row);
然后通过
运行 private List<EtOfferVariant> BuildVariants(List<EtOfferVariant> row, int containerIndex = 1)
{
List<EtOfferVariant> final = new List<EtOfferVariant>();
row.ForEach(y =>
{
for (int i = 0; i < _containers[containerIndex].Variant.Count; i++)
{
var ret = MultiplyFromPrevious(y);
FillByIndex(ret, _containers[containerIndex].Index, _containers[containerIndex].VariantKey, _containers[containerIndex].Variant[i]);
final.Add(ret);
}
});
containerIndex++;
if (containerIndex < _containers.Count)
return BuildVariants(final, containerIndex);
return final;
}
再次感谢中国
private EtOfferVariant MultiplyFromPrevious(EtOfferVariant variant)
{
EtOfferVariant ret = new EtOfferVariant();
ret.OfferVariant1 = variant.OfferVariant1;
ret.OfferVariant2 = variant.OfferVariant2;
ret.OfferVariant3 = variant.OfferVariant3;
ret.OfferVariant4 = variant.OfferVariant4;
ret.OfferVariant5 = variant.OfferVariant5;
ret.OfferVariant1Type = variant.OfferVariant1Type;
ret.OfferVariant2Type = variant.OfferVariant2Type;
ret.OfferVariant3Type = variant.OfferVariant3Type;
ret.OfferVariant4Type = variant.OfferVariant4Type;
ret.OfferVariant5Type = variant.OfferVariant5Type;
return ret;
}
我还将列拆分为一个单独的方法，但它除了获取索引并将值映射到对象之外，没有什么特别的
再次感谢大家，这真的很容易发送代码
我想你只是想减少重复的代码。在这种情况下，只需添加您所知道的数据，并在构建完成后添加变体即可。唯一的问题是，您需要一个复制构造函数来复制以前运行的值。
List<EtOfferVariant> variants = new List<EtOfferVariant>();
_containers[0].Variant.ForEach(first =>
{
EtOfferVariant va = new EtOfferVariant();
va.OfferVariant1Type = _containers[0].VariantKey;
va.OfferVariant1 = first;
if (_containers.Count > 1)
{
_containers[1].Variant.ForEach(second =>
{
va = new EtOfferVariant(va);
va.OfferVariant2Type = _containers[1].VariantKey;
va.OfferVariant2 = second;
if (_containers.Count > 2)
{
_containers[2].Variant.ForEach(third =>
{
va = new EtOfferVariant(va);
va.OfferVariant3Type = third;
va.OfferVariant3 = _containers[3].VariantKey;
variants.Add(va);
});
} else
variants.Add(va);
});
} else
variants.Add(va);
});
…
public EtOfferVariant(EtOfferVariant va){
this.OfferVariant1Type = va.OfferVariant1Type;
this.OfferVariant2Type = va.OfferVariant2Type;
this.OfferVariant3Type = va.OfferVariant3Type;
this.OfferVariant1 = va.OfferVariant1;
this.OfferVariant2 = va.OfferVariant2;
this.OfferVariant3 = va.OfferVariant3;
}
如果你首先转换容器中的字典，似乎你可以通过笛卡尔积得到想要的结果。
var containers = new List<Dictionary<string, IEnumerable<string>>>
{
new Dictionary<string, IEnumerable<string>>() {{"Pie", new [] {"Raspberry", "Strawbery"}}},
new Dictionary<string, IEnumerable<string>>() {{"Drink", new [] {"Cola", "Coffee"}}},
new Dictionary<string, IEnumerable<string>>() {{"Bread", new [] {"Bagel", "Pretzel", "Scone"}}},
};
var flatten = containers.Select(dict => dict.SelectMany(c => c.Value.Select(v => new {type = c.Key, name = v})));
foreach (var combo in CartesianProduct(flatten))
{
Console.WriteLine(string.Join(", ", combo.Select(c => c.type + ": " + c.name)));
}
笛卡尔积法from https://stackoverflow.com/a/3098381/44620
public static IEnumerable<IEnumerable<T>> CartesianProduct<T>(IEnumerable<IEnumerable<T>> sequences)
{
IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>() };
return sequences.Aggregate(
emptyProduct,
(accumulator, sequence) =>
from accseq in accumulator
from item in sequence
select accseq.Concat(new[] {item})
);
}
Pie: Raspberry, Drink: Cola, Bread: Bagel Pie: Raspberry, Drink: Cola, Bread: Pretzel Pie: Raspberry, Drink: Cola, Bread: Scone Pie: Raspberry, Drink: Coffee, Bread: Bagel Pie: Raspberry, Drink: Coffee, Bread: Pretzel Pie: Raspberry, Drink: Coffee, Bread: Scone Pie: Strawbery, Drink: Cola, Bread: Bagel Pie: Strawbery, Drink: Cola, Bread: Pretzel Pie: Strawbery, Drink: Cola, Bread: Scone Pie: Strawbery, Drink: Coffee, Bread: Bagel Pie: Strawbery, Drink: Coffee, Bread: Pretzel Pie: Strawbery, Drink: Coffee, Bread: Scone