एक सूची के सभी क्रमपरिवर्तन

Question

मैं इस

var result= 
    new List<List<int>>{ 
     new List<int>{0, 1, 2}, 
     new List<int>{0, 2, 1}, 
     new List<int>{1, 0, 2}, 
     new List<int>{1, 2, 0}, 
     new List<int>{2, 0, 1}, 
     new List<int>{2, 1, 0} 
    }; 

की तरह इस

var list=new List<int>{0, 1, 2}; 

की तरह एक सूची ले और एक परिणाम प्राप्त करने में सक्षम होना चाहते हैं मुझे याद आ रही के साथ सेट में कोई दिलचस्पी नहीं हूँ संख्याएं, मौजूद संख्याओं के संयोजन। कोई विचार?

---

इसके अलावा, मैं Getting all possible combinations from a list of numbers तरह समाधान में पहले से ही देखा है, और वे फिट नहीं है।

भी मुझे इस

var result= 
    new List<List<int>> { 
     // [[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]] 
     // serialized the result to JSON so it would be quicker. 
    }; 

की तरह कुछ देता है कि और यह संयोजनों के सभी थूक से बाहर नहीं है।

---

Answer 1

आकार के लिए पर इन विस्तार तरीकों का प्रयास करें:

public static IEnumerable<IEnumerable<T>> Permute<T>(this IEnumerable<T> sequence) 
{ 
    if (sequence == null) 
    { 
     yield break; 
    } 

    var list = sequence.ToList(); 

    if (!list.Any()) 
    { 
     yield return Enumerable.Empty<T>(); 
    } 
    else 
    { 
     var startingElementIndex = 0; 

     foreach (var startingElement in list) 
     { 
      var remainingItems = list.AllExcept(startingElementIndex); 

      foreach (var permutationOfRemainder in remainingItems.Permute()) 
      { 
       yield return startingElement.Concat(permutationOfRemainder); 
      } 

      startingElementIndex++; 
     } 
    } 
} 

private static IEnumerable<T> Concat<T>(this T firstElement, IEnumerable<T> secondSequence) 
{ 
    yield return firstElement; 
    if (secondSequence == null) 
    { 
     yield break; 
    } 

    foreach (var item in secondSequence) 
    { 
     yield return item; 
    } 
} 

private static IEnumerable<T> AllExcept<T>(this IEnumerable<T> sequence, int indexToSkip) 
{ 
    if (sequence == null) 
    { 
     yield break; 
    } 

    var index = 0; 

    foreach (var item in sequence.Where(item => index++ != indexToSkip)) 
    { 
     yield return item; 
    } 
}