标签: execution-time

我正在尝试使用本网站上给出的bactracking 解决Knight Tour问题.

在网站上给出的实现 在ideone上大约需要0.49秒.

int solveKTUtil(int x, int y, int movei, int sol[N][N], int xMove[N],
                int yMove[N])
{
   int k, next_x, next_y;
   if (movei == N*N)
       return true;

   /* Try all next moves from the current coordinate x, y */
   for (k = 0; k < 8; k++)
   {
       next_x = x + xMove[k];
       next_y = y + yMove[k];
       if (isSafe(next_x, next_y, sol))
       {
         sol[next_x][next_y] = movei;
         if (solveKTUtil(next_x, next_y, movei+1, sol, xMove, yMove) …

我需要在Java中获取函数的执行时间.我知道有两种方法,我可以使用: currentTimeMillis();和nanoTime();,但据我了解,currentTimeMillis();更准确,如果我需要的挂钟时间(即,好像我从墙上时钟的执行多少时间把测量不处理.时间).

但currentTimeMillis();不能给我小分数.例如,如果执行时间小于1毫秒,则返回0.我需要时间,即使它小于1,比如说0.05毫秒.当方法返回0时,这是一个简单的示例.

long startTime=System.currentTimeMillis();
for(int x=0; x<10;x++)
{
    System.out.println("-");
}

long execTime=System.currentTimeMillis() - startTime;

即使它返回时间,它也会返回30或40.但是,我需要一个更准确的数字,比如30.00012.此外,方法返回类型是long但我改为它,double因为我想要一个浮点数,这有什么害处？你能告诉我以正确的方式测量我的java方法执行挂钟时间的小分数(例如不是8.0而是8.287335)

我正在尝试优化朋友给我的一大堆代码,但我的平均执行时间的基线是非常不稳定的,我迷失了为什么/如何修复它.

码:

#include <sys/time.h>
#include <time.h>
#include <stdio.h>
#include "wall.h" /* Where his code is */

int main()
{
    int average;
    struct timeval tv;
    int i;

    for(i = 0; i < 1000; i++) /* Running his code 1,000 times */
    {
        gettimeofday(&tv, NULL); /* Starting time */ 

        start(); /* Launching his code */ 

        int ret = tv.tv_usec; /* Finishing time */ 
        ret /= 1000; /* Converting to milliseconds */ 
        average += ret; /* Adding to the average */ 
    }
    printf("Average …

我有这个Java代码,使用两种不同类型的循环.

public class Test {
    public static void main(String[] args){
        long fl = 0, wl = 0; 
        int i = 0;
        int a = 0;
        long start = 0, stop = 0;

        start = System.currentTimeMillis();
        while(i<2000000000){
             if(i%2 == 0)
                a++;
            else
                a--;
            i++;
        }
        stop = System.currentTimeMillis();
        wl = stop-start/2;
        System.out.println("\nWhile loop = "+wl);

        i = 0;
        a = 0;
        start = 0;
        stop = 0;

        start = System.currentTimeMillis();
        for(;i<2000000000;){
            if(i%2 == 0)
                a++;
            else
                a--;
            i++;
        }
        stop = …

我有两个问题已经在脑子里转了一段时间,我希望有些知识渊博的人可以为我回答:)

1. 在代码执行期间(时间)使用静态方法对性能有好坏吗？
2. 记忆怎么样？他们使用的内存多于实例方法吗？

我已经测量了以下代码的执行时间:

volatile int r = 768;
r -= 511;

volatile int r = 768;
r = (r & ~512) + 1;

部件:

mov     eax, DWORD PTR [rbp-4]
sub     eax, 511
mov     DWORD PTR [rbp-4], eax

mov     eax, DWORD PTR [rbp-4]
and     ah, 253
add     eax, 1
mov     DWORD PTR [rbp-4], eax

结果:

Subtraction time: 141ns   
AND + addition: 53ns

我已经多次运行代码片段并且结果一致.
有人可以解释一下,为什么会出现这种情况,甚至还有一个AND +添加版本的组装线？

我sum()在循环中使用，执行时间超过4s，sum()这里是否等于嵌套循环？

def arrayMaxConsecutiveSum(inputArray, k):
    cop=k
    lis=[]
    i=0
    while i < len(inputArray):
        inpu=sum(inputArray[i:cop])
        lis.append(inpu)
        cop+=1
        i+=1
    return max(lis)

我正在为班级的比赛编写程序。它已经很好用了，现在我正在努力让它尽可能快。我的问题是 - 与制作用户定义的函数相比，只是粘贴函数返回的内容，无论我想在哪里使用它，都可以加速我的程序吗？我知道函数调用会导致内存跳转，那么这样做是否可以显着加速我的代码？在这种情况下，我不关心可读性

例如。而不是这样做

while(something){
y = function();
}
double function(){
return f(x);
}

我这样做

while(something){
y = f(x);
}

我已经做了一些事情，比如通过引用传递结构、避免强制转换、使用移位操作、使用诸如 ++i 之类的东西来加快执行时间，我希望获得一点优势。

switch语句是否case在同一执行时间内为任一可能的输入值确定适当的语句？当找到它正在寻找的值时，它是否将输入值与case块进行比较并跳转到适当的值？case

考虑下面的例子。语句是否switch在同一时间执行input = 1或input = 256对于后一个值执行速度较慢？

int output, input = 256;
    switch( input )
    {   
        case 1:
            output = 1;
            break;
        case 2:
            output = 2;
            break;
        case 4:
            output = 3;
            break;
        case 8:
            output = 4;
            break;
        case 16:
            output = 5;
            break;
        case 32:
            output = 6;
            break;
        case 64:
            output = 7;
            break;
        case 128:
            output = 8;
            break;
        case 256:
            output = 9; …