Question

我有一个字符串列表列表，以便将字符串分组，其数量为'1'，如string =“00000”属于第一组，string =“00001”属于第二组。 ALl String的长度相等。现在我将第一组与第二组进行比较，将第二组与第三组进行比较，很快......就像在图像中一样。将第一组中的第一个元素与第二组中的所有元素进行比较。直到比较每个字符串。有没有办法加快我的程序的性能？所以我可以用15长度实现32000字符串。

修改的

对于过去的帖子感到抱歉。阅读之后，我意识到我会这样愚蠢地问这个问题。该计划的目标是简化。基于 Quine-McCluskey算法

考虑

我将它们分组为1

然后我将该组中的每个字符串与下一组

进行比较

group 1
000

group 2
001
010
100

group 3
011
101
110

group1 -> group2
------------------
    000 -> 001 = 00-
    000 -> 010 = 0-0
    000 -> 100 = -00
------------------
group2 ->group3
--------------------  
    001 -> 011 = 0-1
    001 -> 101 = -01
    001 -> 110 = no output

    010 -> 011 = 01-
    010 -> 101 = no output
    010 -> 110 = -10

    100 -> 011 = no output
    100 -> 101 = 10-
    100 -> 110 = 1-0

---------------------
etc.

然后再次将输出分组，并再次比较它们直到不能比较任何字符串。

我需要实现一个15变量，但程序完成需要永远。任何想法如何加快它。我正在测试它的线程，但只是一点改进。

字符串数：2048变量长度：11时间：10分钟

需要实现

字符串数：32767变量长度：15时间：无法实现

 List<List<string>> ImplicantsByOneFinal = new List<List<string>>();
 List<List<string>> TermsByOne = new List<List<string>>();

是否有一种方法或算法来改进此代码。它在11到15个变量上变慢。

bool CombineAndGroup(List<List<string>> ImplicantsByOne)
{ 
            TermsByOne = new List<List<string>>();
            int combined = 0; 
            for (int i = 0; i < ImplicantsByOne.Count - 1; i++)
            { 
                List<string> termsGrouped = new List<string>();
                for (int j = 0; j < ImplicantsByOne[i].Count; j++)
                { 
                    int combination = 0;
                    int num1 = Convert.ToInt32((ImplicantsByOne[i][j]).Replace('-','0'), 2); 
                        for (int k = 0; k < ImplicantsByOne[i + 1].Count; k++)
                        { 
                            int num2 = Convert.ToInt32((ImplicantsByOne[i + 1][k]).Replace('-', '0'), 2);
                            int num3 = num2 - num1;
                            double num4 = Math.Log((double)num3, (double)2); 
                            if (((num4 % 1) == 0) && (num3 > 0) && (Esum(ImplicantsByOne[i][j]) == Esum(ImplicantsByOne[i + 1][k])))
                            {  
                                string combinedMinterm = CompareString(ImplicantsByOne[i][j], ImplicantsByOne[i + 1][k]); 
                                if (!termsGrouped.Contains(combinedMinterm))
                                {
                                    termsGrouped.Add(combinedMinterm); 
                                }  

                            }
                        }   
                }
                if (termsGrouped.Count > 0)
                {
                    combined += termsGrouped.Count;
                } 
                TermsByOne.Add(termsGrouped);
            }

            return (combined > 0) ? true : false;
        } 

 private int Esum(String binCode)
        {
            binCode = binCode.Replace('1','0');
            binCode = binCode.Replace('-', '1');
            int esum = Convert.ToInt32(binCode, 2);
            return esum;
        }
//Purpose of CompareString is to compare two string and change the unique char to '-'
//like 000 and 001 = 00-
  private string CompareString(string str1, string str2)
        { 
            if (str1 == str2)
            { 
                CountCompareStringLoops++;
                return str1;
            }
            else 
            { 
                if (str1.Length == 1)
                { 
                    return "-";
                }
                int halflength = str1.Length / 2; 
                return CompareString(str1.Substring(0, halflength), str2.Substring(0, halflength)) + CompareString(str1.Substring(halflength), str2.Substring(halflength)); 
            }
        }

主程序

 MintermsByOne = Loaded with string 000 001 and so on

CombineAndGroup(MintermsByOne);
 ImplicantsByOneFinal = TermsByOne; 
 while (CombineAndGroup(TermsByOne))
 {
        ImplicantsByOneFinal = TermsByOne; 
 }

输出ImplicantsByOneFinal

Answer 1

你要实现的目标并不是很清楚，说实话......你的描述与你的代码不符。（例如，您的代码从未提及字符'1'。您永远不会使用调用CompareString的结果这一事实也是可疑的。）LINQ应该实现您的描述“将字符串与数字组合” 1'“简单高效：

var grouped = strings.GroupBy(x => x.Count(c => c == '1'));

这只会计算每个字符串中“1”个字符的数量。您永远不需要将任何字符串与另一个字符串进行比较。

如果这不是你真正想做的事情，你需要澄清你的实际目标。

Answer 2

我不知道怎么写C＃，但我想帮忙。所以我的代码用Java表示。

1.我认为==是O(n)操作，CompareString可能是O(nlgn) n = str1.Length。使用更简单，更快捷的O(n)方式，查看时间是否减少：

private String CompareString(String str1, String str2) {
    StringBuilder sb = new StringBuilder(str1.length());
    for (int i = 0; i < str1.length(); i++) {
        if (str1.charAt(i) == str2.charAt(i))
            sb.append(str1.charAt(i));
        else
            sb.append('-');
    }
    return sb.toString();
}

2。好吧，我发现有很多ToInt32。一次计算ImplicantsByOne中所有字符串的结果，稍后再使用。 Esum也是如此 3.检查num3是否为2的幂：

private boolean isPowerOfTwo(int x) {
    return (x > 0 && (x & (x - 1)) == 0);
}

嵌套For Loop加速性能

2 个答案: