标签: analysis

我注意到我的代码不像以前那样多.今天我将更多的时间用于分析和设计,然后我将这种设计传达给程序员.然后他们做编码.这影响了我的编码效率,因为我必须参考参考文献并依赖智能感知.事情变得越来越复杂

现在,这是具有讽刺意味的.如果我雇用一名程序员并让他/她坐在电脑前,我可能会要求做一些编码,我会检查能力.我会根据他们对内存与咨询参考的使用来评估它们.也许我更喜欢那个没有过多咨询但是谁知道他们在做什么的程序员.

您有什么看法和经验？

我有点理解一个接口是一个契约,可以应用于本来没有任何共同点的类(例如:Java中的Comparable).但是,在什么情况下你会在设计阶段有反射添加界面？

我正在比较这三种算法,我觉得RSA需要更多时间,但我无法得出哪种算法最好.

以下是使用microsoft给出的代码对3种方法进行的性能分析器结果

所有输入字符串都是Here is some data to encrypt!.

任何人都可以建议我,我断言RSA由于导入参数方法而具有性能损失,我想使用ManagedRijandel方法.

我正在将它用于需要正常加密[不是非常强和慢]的地方,但它应该是高性能的.

请从您的角度+建议中给我分析详细信息.

注意:1.比较对称和非对称并不是更好..但我需要一些强有力的分析.

2. 此外,我的内存分析显示RSA的内存使用量较少.

3. 框架:.Net Framework V4与C#和VS2010请提出建议.

我目前在系统分析课程中,我想更好地理解规范化的使用.对于3NF,如果我正在处理包含学生ID,姓名,电话号码和专业的表格.我必须只使用学生证和学生证,因为学生姓名和电话号码都可以通过身份证找到.我明白了吗？

我有一个文件,我想从中提取日期,它是一个HTML源文件,所以它充满了我不需要的代码和短语.我需要提取包含在特定HTML标记中的日期的每个实例:

abbr title ="((这是我需要的文字))"data-utime ="

实现这一目标的最简单方法是什么？

请考虑以下Java方法:

   public static void f(int n) {
    if (n<=1) { 
       System.out.print(n) ; 
       return; 
   }else {
       f(n/2) ;
       System.out.print(n);
       f(n/2);
    }
 } // end of method

问题3.设S(n)表示f(n)的空间复杂度.以下哪项陈述是正确的？

• 答:S(n)=(2n)
• B:S(n)=(n)
• C:S(n)=(log n)< - 正确答案,有谁知道为什么？
• D:以上都不是

我有一个算法,我正在尝试实现.我被要求确定一个描述最坏情况下运行时间的函数.作为输入,它需要一些长度的数组(让我们称之为n).然后它做的是如下:

if (n==0){ return 0;}
else if(n==1){return A[0];}
else{
     return f(n-1)+f(n-2)
}

对不起,如果我对实现细节有点稀疏,但从某种意义上说,它与fibbanoci序列非常类似.我认为这个算法的最坏情况运行时间是t(n)= 2 ^ n,因为如果n很大,它将分解为2个单独的计算,而这又将分成2个,依此类推.我只是不确定如何正式证明这一点

我已经进行了超几何分析(使用python脚本)来研究基因子集中GO术语的富集.我输出的一个例子如下:

GO00001 1500    300 200 150 5.39198144708e-77
GO00002 1500    500 400 350 1.18917839281e-160
GO00003 1500    400 350 320 9.48402847878e-209
GO00004 1500    100 100 75  3.82935778527e-82
GO00005 1500    100 80  80  2.67977253966e-114

哪里

Column1 = GO ID
Column2 = Total sum of all terms in the original dataset
Column3 = Total sum of [Column 1] IDs in the original dataset
Column4 = Sum of all terms in the subset
Column5 = Sum of [Column 1] IDs in subset
Column6 = pvalue …

我必须使用大小为10000到50000且步长为10000的数组,为所有三种算法提供相同的输入,并且对于每个输入重复执行100次,以纳秒为单位测量执行(使用System.nanoTime()),并以毫秒为单位报告平均时间.这就是我在下面所做的,但有些平均值是负数,我不知道为什么？

import java.util.Arrays;

public class Sort{

   public static void main(String[]args){

      double[] arr5 = new double[50000];

      for(int i=0;i<arr5.length;i++)
         arr5[i] = Math.random();

      selectionSort(arr5,10000);
      bubbleSort(arr5,10000);
      quickSort(arr5,10000);

      selectionSort(arr5,20000);
      bubbleSort(arr5,20000);
      quickSort(arr5,20000);

      selectionSort(arr5,30000);
      bubbleSort(arr5,30000);
      quickSort(arr5,30000);

      selectionSort(arr5,40000);
      bubbleSort(arr5,40000);
      quickSort(arr5,40000);

      selectionSort(arr5,50000);
      bubbleSort(arr5,50000);
      quickSort(arr5,50000);
   }

   public static void selectionSort(double [] A,int n){
      int sum = 0;
      System.out.println("Algorithm 1");
      for(int s=0;s<100;s++){
         long arr[] = new long[100];

         long startTime = System.nanoTime();

         for(int i=0;i<n-1;i++){
            int min = i;
            for(int j=i+1;j<n;j++){
               if(A[j] < A[min])
                  min=j;}
            double tmp = A[i];
            A[i] = A[min];
            A[min]=tmp;} …

int dup_chk(int a[], int length) 
{
  int i = length;
  while (i > 0)
  {
    i--;
    int j = i -1;
    while (j >= 0)
    {
      if (a[i] == a[j])
      {
        return 1;
      }
      j--;
    }
  }
  return 0;
}

所以我想我知道以下内容:

• 第1行只是1.
• 首先while循环是N + 1.
• 一世 - ; 自第一个while循环内部起N次.
• j = i -1; 也是N.
• 第二个while循环是(N + 1)N = N ^ 2 + N,因为它是while循环中的while循环
• 如果声明:???
• j--; 是N(N)= N ^ 2
• 返回0; 是1

我真的很想计算算法的时间复杂度,所以我甚至不确定我认为我所知道的是完全正确的.但是弄乱我的是if语句,我不知道如何计算(以及如果之后还有其他内容呢？)

编辑:总计等于3/2N ^ 2 + 5/2N + 3我明白,这个函数是O(N ^ …