Question

我有一个列表，我需要输出列表的每个子集

例如a b c d e

将输出到

 a
 b
 c  
 d 
 e 
 ab  
 ac  
 ad 
 ae

 abc
 abd 
 abe
 bcd
 bce
 ....
 abcde

我认为正确的术语是组合，不应该在同一行重复元素

我打算尝试使用一系列循环，但我甚至不确定是否要开始

有什么建议吗？

Answer 1

这将生成您想要的集合，但是以不同的顺序（我在结尾按字母排序，您也希望按长度排序）。

你最终会得到：

一 AB ABC A B C D ABCDE ABCE ... d 德 ë

所以，每个可能的子集（除了空字符串），同时保持原始列表的顺序。

我们的想法是将每个元素添加到不断增长的列表中。对于每个新元素，首先添加它，然后将其添加到所有现有元素。

所以，从'a'开始。

继续'b'。将其添加到列表中。我们现在有{'a'，'b'}。

将其添加到现有元素，因此我们有'ab'。现在我们有{'a'，'b'，'ab'}。

然后'c'，并将其添加到现有元素以获得'ac'，'bc'，'abc'：{'a'，'b'，'ab'，'c'，'ac'，' bc'，abc'}。直到我们完成为止。

        string set = "abcde";

        // Init list
        List<string> subsets = new List<string>();

        // Loop over individual elements
        for (int i = 1; i < set.Length; i++)
        {
            subsets.Add(set[i - 1].ToString());

            List<string> newSubsets = new List<string>();

            // Loop over existing subsets
            for (int j = 0; j < subsets.Count; j++)
            {
                string newSubset = subsets[j] + set[i];
                newSubsets.Add(newSubset);
            }

            subsets.AddRange(newSubsets);
        }

        // Add in the last element
        subsets.Add(set[set.Length - 1].ToString());
        subsets.Sort();

        Console.WriteLine(string.Join(Environment.NewLine, subsets));

Answer 2

如果您需要的只是原始列表中元素的组合，您可以将问题转换为以下内容：您有一个大小为N的位数组，并且您希望找到数组元素的所有可能选择。例如，如果您的原始列表是

a b c d e

那么你的数组可以是

0 1 0 0 0

导致输出

b

或数组可以是

1 0 1 1 0

返回

acd

这是一个简单的递归问题，可以在O(2^n)时间内解决

编辑为递归算法添加伪代码：

CreateResultSet(List<int> currentResult, int step)
{
    if (the step number is greater than the length of the original list)
    {
        add currentResult to list of all results
        return
    }
    else
    {
        add 0 at the end of currentResult
        call CreateResultSet(currentResult, step+1)

        add 1 at the end of currentResult
        call CreateResultSet(currentResult, step+1)
    }
}

for every item in the list of all results
display the result associated to it (i.e. from 1 0 1 1 0 display acd)

Answer 3

这是我制作的一些代码。它构造了一个字母表中所有可能字符串的列表，长度为1到maxLength :(换句话说，我们正在计算字母表的幂）

  static class StringBuilder<T>
  {
    public static List<List<T>> CreateStrings(List<T> alphabet, int maxLength)
    {
      // This will hold all the strings which we create
      List<List<T>> strings = new List<List<T>>();

      // This will hold the string which we created the previous time through
      // the loop (they will all have length i in the loop)
      List<List<T>> lastStrings = new List<List<T>>();
      foreach (T t in alphabet)
      {
        // Populate it with the string of length 1 read directly from alphabet
        lastStrings.Add(new List<T>(new T[] { t }));
      }

      // This holds the string we make by appending each element from the
      // alphabet to the strings in lastStrings
      List<List<T>> newStrings;

      // Here we make string2 for each length 2 to maxLength
      for (int i = 0; i < maxLength; ++i)
      {
        newStrings = new List<List<T>>();
        foreach (List<T> s in lastStrings)
        {
          newStrings.AddRange(AppendElements(s, alphabet));
        }
        strings.AddRange(lastStrings);
        lastStrings = newStrings;
      }

      return strings;
    }

    public static List<List<T>> AppendElements(List<T> list, List<T> alphabet)
    {
      // Here we just append an each element in the alphabet to the given list,
      // creating a list of new string which are one element longer.
      List<List<T>> newList = new List<List<T>>();
      List<T> temp = new List<T>(list);
      foreach (T t in alphabet)
      {
        // Append the element
        temp.Add(t);

        // Add our new string to the collection
        newList.Add(new List<T>(temp));

        // Remove the element so we can make another string using
        // the next element of the alphabet
        temp.RemoveAt(temp.Count-1);
      }
      return newList;
    }
  }

Answer 4

延伸的while循环中的某些内容：

<?

$testarray[0] = "a";
$testarray[1] = "b";
$testarray[2] = "c";
$testarray[3] = "d";
$testarray[4] = "e";


$x=0;
$y = 0;
while($x<=4) {

$subsetOne[$x] .= $testarray[$y];
$subsetOne[$x] .= $testarray[$x];

$subsetTwo[$x] .= $testarray[$y];
$subsetTwo[$x] .= $subsetOne[$x];

$subsetThree[$x] = str_replace("aa","ab",$subsetTwo[$x]);

$x++;
}



?>

Answer 5

这适用于任何收藏。我修改了@Sapp's回答了一点

    static List<List<T>> GetSubsets<T>(IEnumerable<T> Set)
    {
        var set = Set.ToList<T>();

        // Init list
        List<List<T>> subsets = new List<List<T>>();

        subsets.Add(new List<T>()); // add the empty set

        // Loop over individual elements
        for (int i = 1; i < set.Count; i++)
        {
            subsets.Add(new List<T>(){set[i - 1]});

            List<List<T>> newSubsets = new List<List<T>>();

            // Loop over existing subsets
            for (int j = 0; j < subsets.Count; j++)
            {
                var newSubset = new List<T>();
                foreach(var temp in subsets[j])
                    newSubset.Add(temp);

                newSubset.Add(set[i]);


                newSubsets.Add(newSubset);
            }

            subsets.AddRange(newSubsets);
        }

        // Add in the last element
        subsets.Add(new List<T>(){set[set.Count - 1]});
        //subsets.Sort();

        return subsets;
    }

**然后，如果我有一组字符串，我会将其用作：

enter image description here

查找列表的所有子集

5 个答案: