标签: code-complexity

I understand that a confirmation message on a UI is counted as a Data Element Type (DET). What if my confirmation message is an alert box on a UI plus an email confirmation.

Should i count it as 1 DET or 2 DETs

Thanks

我正在尝试集成lizard来跟踪 sonarqube 上 Android 应用程序的代码复杂性。用于从 lizard 获取复杂性报告的命令是：

lizard src/main -x"./test/*" -x"./androidTest" --xml >lizard/lizardReport.xml \n

在build.gradle应用程序的文件中，sonarqube 属性配置如下：

lizard src/main -x"./test/*" -x"./androidTest" --xml >lizard/lizardReport.xml \n

\n

在此设置结束时，我运行命令gradle sonarqube来构建项目并运行声纳设置，但在 sonarqube 仪表板上查看报告时，没有发现代码复杂性的趋势。

我在这里缺少什么吗？

我想知道如何减少以下代码的Cyclomatic Complexity,如果这是我应该担心的事情.

请参考方法ValuePojo.getSomething()(请不要担心变量命名,为了清楚起见,这个问题已重写)

public class ValuePojo
{
    private ValueTypeEnum type;

    private BigDecimal    value1;

    private BigDecimal    value2;

    private BigDecimal    value3;

    public ValuePojo()
    {
        super();
    }

    /**
     * This method reports as "HIGH Cyclomatic Complexity"
     * 
     * @return
     */
    public BigDecimal getSomething()
    {
        if (this.type == null)
        {
            return null;
        }

        switch (this.type)
        {
            case TYPE_A:
            case TYPE_B:
            case TYPE_C:
            case TYPE_D:
                return this.value1;

            case TYPE_E:
            case TYPE_F:
            case TYPE_G:
            case TYPE_H:
                return this.value2;

            case TYPE_I:
            case TYPE_J:
                return this.value3;
        }

        return …

我最近开始使用SourceMonitor来检查我的(和其他)代码.虽然我理解该工具判断的其他参数,但我不知道它是如何计算代码的复杂性的.如何,它认为读取复杂性数字的所有参数是什么？

我想降低以下算法的复杂性.基本上,它需要一个单词作为输入并计算其中的唯一字母数(单词的"熵").我目前的解决方案采用3个嵌入式for循环,其复杂度为o(n ^ 3).由于此代码是更大项目的一部分(我们为游戏构建了一个称为boggle的解算器),我希望降低算法的复杂性,以减少其执行时间.提前致谢!

int wordEntropy(string word)
{

int length = word.length();
int uniquewords = length;
string compare = word;
char save[17];
int cond=0;

for (int ii=0; ii < length; ii++)
{

    for (int jj=ii+1; jj < length; jj++)
    {
        for (int kk=0; kk<= ii; kk++)
        {
            if (save[kk] == word[ii]) {cond++;}
        }
        if (word[ii] == word[jj])
        {
            if (cond>0) {break;}
            uniquewords--;
        }
    }

    save[ii] = word[ii];
    cond = 0;

}
return uniquewords;
}

试图在python3中找到最优化的数据结构以解决一个更严重的问题，我不得不开发，这才刚刚意识到，使用模块二等分进行实时有序插入的复杂性不是O（nlog n），而是应该成倍增长。代替。不知道它的原因，所以感觉就像问你们，以防万一，因为我发现它真的很有趣。

想想我使用模块正确，所以这对我来说应该不是问题，无论如何，这里是用于插入节点对象的代码，用于确定随机f值节点的插入。

bisect.insort(self._frontier, (node._f, node))

在几秒钟之内得到很多物体，但是随着时间的流逝就没有那么多。Bakuriu建议我问这个问题，因为他在进行了一些测试并得出与我相同的结果后也发现它很有趣。他用来测试的代码如下：

python3 -m timeit -s 'import bisect as B; import random as R;seq=[]' 'for _ in range(100000):B.insort(seq, R.randint(0, 1000000))'

这些是他的结论：

10k插入都很好（到80ms为止，它基本上是线性扩展的（请记住，它是O（nlog n），所以比线性还差一点）），但是100k插入将永远花费而不是10倍以上。100k元素的列表实际上并不大，log（100k）为16，所以它并不大。

任何帮助都感激不尽！

有人告诉我,我的代码应遵循O(logn)+ O(n)的复杂性指南.当提示澄清时,我被问到"代码的复杂性:)"无论如何,除了提供的任何澄清之外,我们将不胜感激.

我正在尝试从OCLint分析生成一个html报告.我已经安装了xctool并使用以下命令生成json文件:

xctool -project demoProject.xcodeproj -scheme demoProject -sdk iphonesimulator -reporter json-compilation-database:compile_commands.json  build

现在我可以使用此命令运行分析:

oclint-json-compilation-database

但报告打印在标准输出上.

OCLint scrips有一个report-type参数,所以我可以用这个命令创建一个html报告:

oclint -report-type html -o report.html 

但我不能用oclin-json-compilation-database做到这一点.

我阅读了帮助页面(http://docs.oclint.org/en/dev/manual/oclint-json-compilation-database.html),我发现了一个oclint_args参数,但我不明白如何使用它.我试过了

oclint-json-compilation-database -v oclint_args report-type html o report.html

但没有任何反应

我有一个使用递归打印斐波纳契数列的程序.有更好的方法,但我被要求使用递归,所以我必须这样做.

这是程序:

#include <stdio.h>
#define TERMS 10

long fibo(int);

int main(void){
   for(int i = 1; i <= TERMS; i++) {
       printf("%ld", fibo(i));
   }
   return 0;
}

long fibo(int n){
    if (n < 3) {
        return 1;
    }
    else {
        return fibo(n - 1) + fibo(n - 2);
    }
}

我知道这对于Fibonacci系列来说真的是一个糟糕的方法,从上面可以清楚地看到,因为TERMS超过35,该程序需要花费大量时间才能完成.

我已经完成了这个答案,无法理解他们是如何解决的,但它看起来像

fibo(int n)的时间复杂度为O(2 ^ n)

我可能也完全错了,但我想要的只是:

这个完整程序的时间复杂度是什么,简要解释一下你如何计算它？

如果你有一个更好的方法来计算使用递归计算Fibonacci,也欢迎.

positions2              :: (Eq a) => a -> [a] -> [Int]
positions2              = f where
    f aa aas        = filter (g aa aas) [0 .. (length aas - 1)]
    g aa aas it     = aa == aas !! it

此代码用于查找给定列表中给定元素的位置.

为了找出它的复杂性,我想到了filter一个函数g和一个列表[0..length-1].

现在,我想不出什么的复杂性positions2会(n)或会有任何环路事情,由于filter功能.

请建议是否有任何其他方法来编写更紧凑的代码,以降低复杂性.

我最近一直在玩flog，它是一个非常好的工具，可以为 ruby​​ 应用程序生成代码复杂性报告。在项目代码库上运行的结果是， flog您会得到类似于以下内容的输出：

  1272.3: flog total
     7.3: flog/method average

    62.2: MyClass#foobar lib/myclass#foobar:123
    ... more similar lines ...

上面的示例提供了方法的分数，并引用了定义该方法的源代码中的确切行号。这可以是常规实例/类方法或任何其他“动态”方法，例如。耙子任务等等。

因此，目标是从源文件中提取一段代码（很可能是一个方法），该代码以 flog 输出中定义的行号开头。然后，该代码片段可以在某些 Web UI 中用于显示各种代码指标（基于其他工具，例如flay）和/或存储在数据库中。据我所知，这个任务涉及将 ruby​​ 代码解析为 AST，然后遍历树找到相应的起始行并找出结束行号。我已经用这个库做了一些实验 - https://github.com/whitequark/parser，大部分时间都有效，但获得正确的结果有点棘手。

还有其他解决方案可以从用 ruby​​ 编写的源文件中快速提取方法代码吗？

我已经学习了几个星期的Python,并且在复活节之后,将有一个受控制的评估将计入我的GCSE等级,为此我也将被标记为类似于我的代码的标准.

问题是:编写一个Python程序,询问用户一个单词,然后计算打印输入单词的元音值.

我想知道的:

无论如何缩短这段代码？

并且:

如何在不打印"word"变量的情况下执行程序？

上面我给了一个我在代码中使用的量规(在控制流程部分).

score = 0

word = str(input("Input a word: "))

c = 0
for letter in word:
        print(word[c])
        c = c + 1
        if letter == "a":
                score = score + 5
        if letter == "e":
                score = score + 4
        if letter == "i":
                score = score + 3
        if letter == "o":
                score = score + 2
        if letter == "u":
                score = score + 1

print("\nThe score for your word is: …

任何算法示例我们何时比O(n logn)更喜欢Big O(n ^ 2)时间复杂度？我在某处看到过这个问题,但没有找到答案.