如何在数组中生成一组字符的非重复可能组合？

Question

如何为字符数组生成有序组合？

例如，给定一个数组['a','b','c','d']，编写一个程序，用于按长度按升序排序的所有可能组合，然后按字典顺序递增 - 换句话说：

ab ac ad bc bd cd abc abd acd bcd abcd

Answer 1

试试这个。虽然我已经在Console应用程序中编写了它，但是通过将static void Main（string [] args）更改为一个方法，它可以工作。

static void Main(string[] args)
{
     Dictionary<string, int> s = new Dictionary<string, int>();
     Dictionary<string, int> dict = new Dictionary<string, int>();
     bool bln = false;
     string[] str = new string[5] { "a", "b", "c", "d","e"};
     int len = str.Length;
     string lastWord = "";
     // a,b,c,d - count=1, aa,ab,ac,ad,ba,bb,bc,bd - count=2 etc
     int count = 1;
     foreach(string sa in str)
     {
         dict.Add(sa,1);
     }

     for(int m=0;m<len;m++)
     {
         // Gets last word as eeeee in this example             
         lastWord += str[4];
     }
     for (int i = 0; i < len; i++)
     {
         foreach (KeyValuePair<string, int> kvp in dict)
         {
              for (int j = 0; j < str.Length; j++)
              {
                   if (kvp.Value == count)
                   {                          
                       s.Add(kvp.Key + str[j],count + 1);
                       // If last combination has reached
                       if (s.Keys.Contains(lastWord))
                          bln = true;
                   }
              }
         }                
         foreach (KeyValuePair<string, int> kvp in s)
         {
             if (kvp.Value == count + 1)
             {
                 dict.Add(kvp.Key,kvp.Value);
             }
         }
         if (bln)
            break;
         count++;
         // a,b,c,d - 4 combinations. aa,ab,ac,ad,ba,bb,bc,bd...4*4=16, then 64 etc
         len = len * str.Length;
     }
     dict.Clear();
     foreach (KeyValuePair<string, int> kvp in s)
     {
          string s1 = SortWord(kvp.Key);
          if(!dict.Keys.Contains(s1))
               dict.Add(s1, kvp.Value);               
     }       
     foreach (KeyValuePair<string, int> kvp in s)
     {
         // abdc will get sorted to abcd
         string s1 = SortWord(kvp.Key);
         // If aabc then false becz 'a' is repeated two times
         bool b = IsWordsRepeat(s1);
         if (dict.Keys.Contains(s1) && !b)
         {                  
              dict.Remove(SortWord(kvp.Key));                    
         }
     }
     Console.ReadLine();  
}

获取布尔状态以检查字符是否重复超过1次

public static bool IsWordsRepeat(string text)
{
    int count = 0;
    foreach(char c in text)
    {
         count = 0;
         foreach (char c1 in text)
         {
              if (c == c1)
              {
                  count++;
              }
              if (count == 2)
                 return false;
         }
    }
    return true;  
}

排序后获取单词（即abdc到abcd）

static string SortWord(string str)
{
    char[] chars = str.ToArray();
    Array.Sort(chars);
    return new string(chars);
}

您将以排序的方式在dict中获得结果。

<强> RESULT

根据您提出的问题，您曾要求订购字符串

ab ac ad bc bd cd abc abd acd bcd abcd

不按字母顺序/词典顺序排列，形成如下结果

截至目前，您需要按其他订单订购。只需在Console.ReadLine（）之前添加以下代码即可生成所需结果

var list = dict.Keys.ToList();
list.Sort();
foreach (var key in list)
{
     Console.WriteLine("{0}", key);
}

显示以下结果

Answer 2

import java.util.*;
import java.math.*;

public class combPowerSet {

     //printing the charachters as per the number sent.
     void printNumber(int number, char [] items)
        {
            String digitString = Integer.toString(number);
            char [] digitStringArray = digitString.toCharArray();
            int length = digitStringArray.length;
            for ( int i=0; i<length; i++)
            {
                System.out.print(items[Character.getNumericValue(digitStringArray[i])-1]);
            }
            System.out.println();
        }

    //checking if the number follows the required pattern.
    boolean checkCondition(int number, int itemSize)
    {
        boolean validNumber = true;
        String digitString = Integer.toString(number);
        char [] digitStringArray = digitString.toCharArray();
        int length = digitStringArray.length;
        for ( int i=0; i<length; i++)
        {
            for( int j = i+1; j < length; j++)
            {
                int x = Character.getNumericValue(digitStringArray[i]);
                int y = Character.getNumericValue(digitStringArray[j]);             

                if (x > itemSize-1 || y > itemSize || x > y  || x==y)
                {
                    validNumber = false;
                    break;
                }               
            }
            if (validNumber == false) break;
         }
        return validNumber;     
    }


    void printCombinations(char [] items)
    {
        double maxDigit = 0; 
        int itemSize = items.length;
        for(int i=1; i<=itemSize; i++)
        {
            maxDigit = maxDigit + i*Math.pow(10,itemSize-i);
        }


        for(int x=12; x<=maxDigit; x++)
        {
            if(checkCondition(x, itemSize))
            {
                printNumber(x, items);
            }
        }
    }

    public static void main(String [] args)
    {
        char [] arr = { 'a','b', 'c','d', 'e'};
        combPowerSet obj = new combPowerSet();
        obj.printCombinations(arr);     

    }
 }