C# (i++) 置换[i]=值[tx[i].秒]; 返回置换; } 无效掉期(参考U x,参考U y) { var-tmp=x; x=y; y=tmp; } 变量长度=项目长度; //构建身份转换 var transform=new(int-First,int
(i++) 置换[i]=值[tx[i].秒]; 返回置换; } 无效掉期(参考U x,参考U y) { var-tmp=x; x=y; y=tmp; } 变量长度=项目长度; //构建身份转换 var transform=new(int-First,int-Second)[length]; 对于(变量i=0;iC# (i++) 置换[i]=值[tx[i].秒]; 返回置换; } 无效掉期(参考U x,参考U y) { var-tmp=x; x=y; y=tmp; } 变量长度=项目长度; //构建身份转换 var transform=new(int-First,int,c#,linq,permutation,C#,Linq,Permutation,(i++) 置换[i]=值[tx[i].秒]; 返回置换; } 无效掉期(参考U x,参考U y) { var-tmp=x; x=y; y=tmp; } 变量长度=项目长度; //构建身份转换 var transform=new(int-First,int-Second)[length]; 对于(变量i=0;i=0&&transform[decreasingpart]。第一个>=transform[decreasingpart+1]。第一个) --递减部分; //整个序列按降序排列,已完成 if
公共静态IList置换(不可变列表维度)
{
IList结果=新列表();
步骤(ImmutableList.Create(),维度,结果);
返回结果;
}
私有静态无效步骤(ImmutableList previous,
不可变列表rest,
(测试结果)
{
如果(休息,我空着)
{
结果。添加(上一个);
返回;
}
var first=剩余[0];
rest=rest.RemoveAt(0);
foreach(第一个变量标签)
{
步骤(上一步。添加(标签)、休息、结果);
}
}
看看,你意识到这可能会很快变得很大,对吗?你介意我问你为什么需要制定每一个可能的时间表吗?是的,我意识到这将非常迅速地增长。这是优化例程的一部分。最棘手的部分是扩大正在考虑的可能性。我的问题大小大约是P,第二个例子的第四行应该是(p1,T),是吗?请注意,这样的项目的数量等于T边的P维金字塔晶格中的节点数量(因此,如果P是3,T是5,那么这就是最长边上有五个点的三维金字塔中的点数量。)一个侧面有15个点的20维金字塔中有大量的点。从(非常)粗略的近似来看,这件事中的点和宇宙中的基本粒子一样多。为了可读性,我更喜欢查询理解语法——与yield实现相比,会有任何明显的缺陷吗?@erash:两者都不是特别高效或低效的。这几乎是一个偏好的问题。如果序列元素的范围是从0到k,序列的长度是n,那么输出中的序列数由以下公式给出:(n+(k− 1))! / (k)− 1)! / N通过搜索“带重复的组合”可以找到许多证据,就像这篇维基百科文章一样
If p1.Index > p2.Index then p1.Schedule >= p2.Schedule.
public class PotentialSchedule()
{
public PotentialSchedule(int[] schedulePermutation)
{
_schedulePermutation = schedulePermutation;
}
private readonly int[] _schedulePermutation;
}
private int _numberProducts = ...;
public IEnumerator<PotentialSchedule> GetEnumerator()
{
int[] permutation = new int[_numberProducts];
//Generate all permutation combinations here -- how?
yield return new PotentialSchedule(permutation);
}
public IEnumerable<PotentialSchedule> GetEnumerator()
{
var query = from p1 in Enumerable.Range(0,T)
from p2 in Enumerable.Range(p2,T)
select new { P1 = p1, P2 = p2};
foreach (var result in query)
yield return new PotentialSchedule(new int[] { result.P1, result.P2 });
}
static partial class Permutation
{
/// <summary>
/// Generates permutations.
/// </summary>
/// <typeparam name="T">Type of items to permute.</typeparam>
/// <param name="items">Array of items. Will not be modified.</param>
/// <param name="comparer">Optional comparer to use.
/// If a <paramref name="comparer"/> is supplied,
/// permutations will be ordered according to the
/// <paramref name="comparer"/>
/// </param>
/// <returns>Permutations of input items.</returns>
public static IEnumerable<IEnumerable<T>> Permute<T>(T[] items, IComparer<T> comparer)
{
int length = items.Length;
IntPair[] transform = new IntPair[length];
if (comparer == null)
{
//No comparer. Start with an identity transform.
for (int i = 0; i < length; i++)
{
transform[i] = new IntPair(i, i);
};
}
else
{
//Figure out where we are in the sequence of all permutations
int[] initialorder = new int[length];
for (int i = 0; i < length; i++)
{
initialorder[i] = i;
}
Array.Sort(initialorder, delegate(int x, int y)
{
return comparer.Compare(items[x], items[y]);
});
for (int i = 0; i < length; i++)
{
transform[i] = new IntPair(initialorder[i], i);
}
//Handle duplicates
for (int i = 1; i < length; i++)
{
if (comparer.Compare(
items[transform[i - 1].Second],
items[transform[i].Second]) == 0)
{
transform[i].First = transform[i - 1].First;
}
}
}
yield return ApplyTransform(items, transform);
while (true)
{
//Ref: E. W. Dijkstra, A Discipline of Programming, Prentice-Hall, 1997
//Find the largest partition from the back that is in decreasing (non-icreasing) order
int decreasingpart = length - 2;
for (;decreasingpart >= 0 &&
transform[decreasingpart].First >= transform[decreasingpart + 1].First;
--decreasingpart) ;
//The whole sequence is in decreasing order, finished
if (decreasingpart < 0) yield break;
//Find the smallest element in the decreasing partition that is
//greater than (or equal to) the item in front of the decreasing partition
int greater = length - 1;
for (;greater > decreasingpart &&
transform[decreasingpart].First >= transform[greater].First;
greater--) ;
//Swap the two
Swap(ref transform[decreasingpart], ref transform[greater]);
//Reverse the decreasing partition
Array.Reverse(transform, decreasingpart + 1, length - decreasingpart - 1);
yield return ApplyTransform(items, transform);
}
}
#region Overloads
public static IEnumerable<IEnumerable<T>> Permute<T>(T[] items)
{
return Permute(items, null);
}
public static IEnumerable<IEnumerable<T>> Permute<T>(IEnumerable<T> items, IComparer<T> comparer)
{
List<T> list = new List<T>(items);
return Permute(list.ToArray(), comparer);
}
public static IEnumerable<IEnumerable<T>> Permute<T>(IEnumerable<T> items)
{
return Permute(items, null);
}
#endregion Overloads
#region Utility
public static IEnumerable<T> ApplyTransform<T>(
T[] items,
IntPair[] transform)
{
for (int i = 0; i < transform.Length; i++)
{
yield return items[transform[i].Second];
}
}
public static void Swap<T>(ref T x, ref T y)
{
T tmp = x;
x = y;
y = tmp;
}
public struct IntPair
{
public IntPair(int first, int second)
{
this.First = first;
this.Second = second;
}
public int First;
public int Second;
}
#endregion
}
class Program
{
static void Main()
{
int pans = 0;
int[] digits = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
Stopwatch sw = new Stopwatch();
sw.Start();
foreach (var p in Permutation.Permute(digits))
{
pans++;
if (pans == 720) break;
}
sw.Stop();
Console.WriteLine("{0}pcs, {1}ms", pans, sw.ElapsedMilliseconds);
Console.ReadKey();
}
}
for each binaryNumber in ar{
for i = 0 to n-1{
if binaryNumber(i) = 1
permunation.add(products(i))
}
permunations.add(permutation)
}
using System;
using System.Collections.Generic;
using System.Linq;
static class Program
{
static IEnumerable<T> Prepend<T>(T first, IEnumerable<T> rest)
{
yield return first;
foreach (var item in rest)
yield return item;
}
static IEnumerable<IEnumerable<int>> M(int p, int t1, int t2)
{
if (p == 0)
yield return Enumerable.Empty<int>();
else
for (int first = t1; first <= t2; ++first)
foreach (var rest in M(p - 1, first, t2))
yield return Prepend(first, rest);
}
public static void Main()
{
foreach (var sequence in M(4, 0, 2))
Console.WriteLine(string.Join(", ", sequence));
}
}
0, 0, 0, 0
0, 0, 0, 1
0, 0, 0, 2
0, 0, 1, 1
0, 0, 1, 2
0, 0, 2, 2
0, 1, 1, 1
0, 1, 1, 2
0, 1, 2, 2
0, 2, 2, 2
1, 1, 1, 1
1, 1, 1, 2
1, 1, 2, 2
1, 2, 2, 2
2, 2, 2, 2
- all sequences starting with 0 followed by sequences of length 2 drawn from 0 to 2.
- all sequences starting with 1 followed by sequences of length 2 drawn from 1 to 2.
- all sequences starting with 2 followed by sequences of length 2 drawn from 2 to 2.
static IEnumerable<T> Singleton<T>(T first)
{
yield return first;
}
static IEnumerable<IEnumerable<int>> M(int p, int t1, int t2)
{
return p == 0 ?
Singleton(Enumerable.Empty<int>()) :
from first in Enumerable.Range(t1, t2 - t1 + 1)
from rest in M(p - 1, first, t2)
select Prepend(first, rest);
}
IEnumerable<int> Range(int n, int m) {
for(var i = n; i < m; ++i) {
yield return i;
}
}
enum PermutationsOption {
None,
SkipEmpty,
SkipNotDistinct
}
private IEnumerable<IEnumerable<T>> Permutations<T>(IEnumerable<T> elements, PermutationsOption option = PermutationsOption.None, IEqualityComparer<T> equalityComparer = default(IEqualityComparer<T>)) {
var elementsList = new List<IEnumerable<T>>();
var elementsIndex = 0;
var elementsCount = elements.Count();
var elementsLength = Math.Pow(elementsCount + 1, elementsCount);
if (option.HasFlag(PermutationsOption.SkipEmpty)) {
elementsIndex = 1;
}
if (elements.Count() > 0) {
do {
var elementStack = new Stack<T>();
for (var i = 0; i < elementsCount; ++i) {
var ind = (int)(elementsIndex / Math.Pow(elementsCount + 1, i) % (elementsCount + 1));
if (ind == 0) {
continue;
}
elementStack.Push(elements.ElementAt(ind - 1));
}
var elementsCopy = elementStack.ToArray() as IEnumerable<T>;
if (option.HasFlag(PermutationsOption.SkipNotDistinct)) {
elementsCopy = elementsCopy.Distinct();
elementsCopy = elementsCopy.ToArray();
if (elementsList.Any(p => CompareItemEquality(p, elementsCopy, equalityComparer))) {
continue;
}
}
elementsList.Add(elementsCopy);
} while (++elementsIndex < elementsLength);
}
return elementsList.ToArray();
}
private bool CompareItemEquality<T>(IEnumerable<T> elements1, IEnumerable<T> elements2, IEqualityComparer<T> equalityComparer = default(IEqualityComparer<T>)) {
if (equalityComparer == null) {
equalityComparer = EqualityComparer<T>.Default;
}
return (elements2.Count() == elements2.Count()) && (elements2.All(p => elements1.Contains(p, equalityComparer)));
}
public static void Main()
{
var distributions = Distributions(4, 3);
PrintSequences(distributions);
}
/// <summary>
/// Entry point for the other recursive overload
/// </summary>
/// <param name="length">Number of elements in the output</param>
/// <param name="range">Number of distinct values elements can take</param>
/// <returns></returns>
static List<int[]> Distributions(int length, int range)
{
var distribution = new int[range];
var distributions = new List<int[]>();
Distributions(0, length, distribution, 0, distributions);
distributions.Reverse();
return distributions;
}
/// <summary>
/// Recursive methode. Not to be called directly, only from other overload
/// </summary>
/// <param name="index">Value of the (possibly) last added element</param>
/// <param name="length">Number of elements in the output</param>
/// <param name="distribution">Distribution among element distinct values</param>
/// <param name="sum">Exit condition of the recursion. Incremented if element added from parent call</param>
/// <param name="distributions">All possible distributions</param>
static void Distributions(int index,
int length,
int[] distribution,
int sum,
List<int[]> distributions)
{
//Uncomment for exactness check
//System.Diagnostics.Debug.Assert(distribution.Sum() == sum);
if (sum == length)
{
distributions.Add(distribution.Reverse().ToArray());
for (; index < distribution.Length; index++)
{
sum -= distribution[index];
distribution[index] = 0;
}
return;
}
if (index < distribution.Length)
{
Distributions(index + 1, length, distribution, sum, distributions);
distribution[index]++;
Distributions(index, length, distribution, ++sum, distributions);
}
}
static void PrintSequences(List<int[]> distributions)
{
for (int i = 0; i < distributions.Count; i++)
{
for (int j = distributions[i].Length - 1; j >= 0; j--)
for (int k = 0; k < distributions[i][j]; k++)
Console.Write("{0:D1} ", distributions[i].Length - 1 - j);
Console.WriteLine();
}
}
public static class PermutationExtensions
{
/// <summary>
/// Generates permutations.
/// </summary>
/// <typeparam name="T">Type of items to permute.</typeparam>
/// <param name="items">Array of items. Will not be modified.</param>
/// <returns>Permutations of input items.</returns>
public static IEnumerable<T[]> Permute<T>(this T[] items)
{
T[] ApplyTransform(T[] values, (int First, int Second)[] tx)
{
var permutation = new T[values.Length];
for (var i = 0; i < tx.Length; i++)
permutation[i] = values[tx[i].Second];
return permutation;
}
void Swap<U>(ref U x, ref U y)
{
var tmp = x;
x = y;
y = tmp;
}
var length = items.Length;
// Build identity transform
var transform = new(int First, int Second)[length];
for (var i = 0; i < length; i++)
transform[i] = (i, i);
yield return ApplyTransform(items, transform);
while (true)
{
// Ref: E. W. Dijkstra, A Discipline of Programming, Prentice-Hall, 1997
// Find the largest partition from the back that is in decreasing (non-increasing) order
var decreasingpart = length - 2;
while (decreasingpart >= 0 && transform[decreasingpart].First >= transform[decreasingpart + 1].First)
--decreasingpart;
// The whole sequence is in decreasing order, finished
if (decreasingpart < 0)
yield break;
// Find the smallest element in the decreasing partition that is
// greater than (or equal to) the item in front of the decreasing partition
var greater = length - 1;
while (greater > decreasingpart && transform[decreasingpart].First >= transform[greater].First)
greater--;
// Swap the two
Swap(ref transform[decreasingpart], ref transform[greater]);
// Reverse the decreasing partition
Array.Reverse(transform, decreasingpart + 1, length - decreasingpart - 1);
yield return ApplyTransform(items, transform);
}
}
}
public static IList<IList<T>> Permutation<T>(ImmutableList<ImmutableList<T>> dimensions)
{
IList<IList<T>> result = new List<IList<T>>();
Step(ImmutableList.Create<T>(), dimensions, result);
return result;
}
private static void Step<T>(ImmutableList<T> previous,
ImmutableList<ImmutableList<T>> rest,
IList<IList<T>> result)
{
if (rest.IsEmpty)
{
result.Add(previous);
return;
}
var first = rest[0];
rest = rest.RemoveAt(0);
foreach (var label in first)
{
Step(previous.Add(label), rest, result);
}
}