Zwei-Element-Teilmenge mit C#

Question

Ich versuche, eine 2-Element-Teilmenge aller Sätze im Code zu generieren. Eg. Wenn die Liste {1,2,3,4} enthält, sind 2-Element-Teilmengen {1,2}, {1,3}, {1,4}, {2,3}, {2,4}, {3,4}. Ich bin mit der Logik fest und kann nicht weiter gehen. Jede Hilfe wird geschätzt.

 class Program 
     { 
     static List<SortedSet<string>> _items = new List<SortedSet<string>>(); 
     static SortedSet<string> set = new SortedSet<string>(); 
     static void Main(string[] args) 
     { 
     int i, j, a, b; 
     string k; 
     Console.WriteLine("\n Enter the number of set to be used: "); 
     i = Convert.ToInt32(Console.ReadLine()); 
     for (j = 1; j <= i; j++) 
     { 
      SortedSet<string> set = new SortedSet<string>(); 
      do 
      { 
       Console.WriteLine("Enter first element in set {0}:", j); 
       k = Console.ReadLine(); 
       if (k != "stop") 
        set.Add(k); 
      } while (k != "stop"); 
      _items.Add(set); 
     } 
     } 

     public void DisplayTwoElementSets(List<string> set) 
     { 
      foreach (string item in set) 
      { 
       GenerateTwoElementSet(setNumber); 
      } 

     } 
     private void GenerateTwoElementSet(int setNumber) 
     { 
      SortedSet<string> originalSet = _items[setNumber]; 
      List<SortedSet<string>> twoItemSets = new List<SortedSet<string(); 
      foreach (string item in originalSet) 
      { 
       Console.WriteLine(item); 
      } 
     } 

Answer 1

Ich gehe davon aus, dass der Teil, den Sie bei stecken ist der Console.WriteLine(item); Ort in der Nähe der Unterseite des Codes.

Ihr Ziel ist es, eine Liste eindeutiger Paare Kombinationen über eine Reihe von Werten zu erstellen. Der einfachste Weg besteht darin, zwei verschachtelte for-Schleifen zu verwenden, wobei der Indexwert der inneren Schleife vom Indexwert der äußeren Schleife abhängt.

Sie können diese Sets in Listen oder Sets speichern, aber der Typ, der wahrscheinlich am besten geeignet ist, wäre das Tuple. Ein Tupel enthält genau die Anzahl der von Ihnen angegebenen Werte (in diesem Fall 2) und behält ihre Reihenfolge in den Eigenschaften mit dem Namensschema Item1, Item2 , Item3 usw.

(Beachten Sie auch, dass Sie diese Methode innerhalb derselben deklarieren Klasse, die Ihre Main Methode, so aus Gründen der Vernunft hält, ist es am besten zu erklären, dies als statisch)

private static List<Tuple<int, int>> GenerateTwoElementSet(int setNumber) 
{ 
    List<Tuple<int, int>> set = new List<Tuple<int, int>>(); 

    for (int i = 1; i <= setNumber; i++) 
    { 
     for (int j = i + 1; j <= setNumber; j++) 
     { 
      set.Add(new Tuple<int, int>(i, j)); 
     } 
    } 

    return set; 
} 

Sie erhalten die Werte aus der Menge wie folgt:.

var set = GenerateTwoElementSet(4); 
foreach (var tuple in set) 
{ 
    Console.WriteLine("{" + tuple.Item1 + "," + tuple.Item2 +"}"); 
} 

// Outputs the following: 
// {1,2} 
// {1,3} 
// {1,4} 
// {2,3} 
// {2,4} 
// {3,4} 

EDIT: Wenn Sie Paare aus einer vorhandenen Liste statt einer Reihe von Zahlen machen möchten, ist die Logik immer noch die gleiche. Sie verwenden einfach die Zahlen aus der obigen Methode als Indizes für Ihre Liste.

private static List<Tuple<string, string>> GenerateTwoElementSetFromList(List<string> list) 
{ 
    List<Tuple<string, string>> set = new List<Tuple<string, string>>(); 

    for (int i = 0; i < list.Count; i++) 
    { 
     for (int j = i + 1; j < list.Count; j++) 
     { 
      set.Add(new Tuple<string, string>(list[i], list[j])); 
     } 
    } 

    return set; 
} 

Und Sie verwenden es wie so:

List<string> list = new List<string> 
{ 
    "apple", 
    "pear", 
    "orange", 
    "plum" 
}; 

var set = GenerateTwoElementSetFromList(list); 

foreach (var tuple in set) 
{ 
    Console.WriteLine("{" + tuple.Item1 + "," + tuple.Item2 +"}"); 
} 

// Outputs the following: 
// {apple,pear} 
// {apple,orange} 
// {apple,plum} 
// {pear,orange} 
// {pear,plum} 
// {orange,plum}