calcolo del tempo di esecuzione in c ++

Question

Ho scritto un programma in C ++, voglio sapere come calcolare il tempo impiegato per l'esecuzione in modo da non supererà il limite di tempo.

#include<iostream>

using namespace std;

int main ()
{
    int st[10000],d[10000],p[10000],n,k,km,r,t,ym[10000];
    k=0;
    km=0;
    r=0;
    scanf("%d",&t);
    for(int y=0;y<t;y++)
    {
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
            cin>>st[i] >>d[i] >>p[i];
    }
    for(int i=0;i<n;i++)
    {
            for(int j=i+1;j<n;j++)
            {
                    if((d[i]+st[i])<=st[j])
                    {
                              k=p[i]+p[j];
                    }
                    if(k>km)
                    km=k;
            }
        if(km>r)
        r=km;
    }
    ym[y]=r;
}
    for( int i=0;i<t;i++)
    {
         cout<<ym[i]<<endl;
    }


    //system("pause");
    return 0;
}     

questo è il mio programma e voglio che sia entro il tempo limite di 3 secondi !! come farlo ? sì scusa volevo dire tempo di esecuzione !!

Answer 1

Se avete installato cygwin, dalla sua shell bash, eseguire il file eseguibile, dire MyProgram, utilizzando l'utilità time, in questo modo:

/usr/bin/time ./MyProgram

Questa segnalerà quanto tempo l'esecuzione del programma ha preso - l'uscita sarebbe simile al seguente:

real    0m0.792s
user    0m0.046s
sys     0m0.218s

Si potrebbe anche modificare manualmente il vostro programma C per strumento utilizzando la funzione di libreria clock(), in questo modo:

#include <time.h>
int main(void) {
    clock_t tStart = clock();
    /* Do your stuff here */
    printf("Time taken: %.2fs\n", (double)(clock() - tStart)/CLOCKS_PER_SEC);
    return 0;
}

Answer 2

Con C ++ 11 per misurare il tempo di esecuzione di un pezzo di codice, possiamo utilizzare la funzione now ():

auto start = chrono::steady_clock::now();

//  Insert the code that will be timed

auto end = chrono::steady_clock::now();

// Store the time difference between start and end
auto diff = end - start;

Se si desidera stampare la differenza di tempo tra inizio e fine nel codice qui sopra, è possibile utilizzare:

cout << chrono::duration <double, milli> (diff).count() << " ms" << endl;

Se si preferisce utilizzare nanosecondi, si utilizzerà:

cout << chrono::duration <double, nano> (diff).count() << " ns" << endl;

Il valore della variabile diff può anche essere troncato per un valore intero, per esempio, se si desidera che il risultato espresso come:

diff_sec = chrono::duration_cast<chrono::nanoseconds>(diff);
cout << diff_sec.count() << endl;

Per maggiori info clicca qui

Answer 3

Panoramica

Ho scritto un semplice trucco semantico per questo utilizzo @AshutoshMehraresponse. È il codice sembra davvero leggibile in questo modo!

MACRO

#include <time.h>

#ifndef SYSOUT_F
#define SYSOUT_F(f, ...)      _RPT1( 0, f, __VA_ARGS__ ) // For Visual studio
#endif

#ifndef speedtest__             
#define speedtest__(data)   for (long blockTime = NULL; (blockTime == NULL ? (blockTime = clock()) != NULL : false); SYSOUT_F(data "%.9fs", (double) (clock() - blockTime) / CLOCKS_PER_SEC))
#endif

Utilizzo

speedtest__("Block Speed: ")
{
    // The code goes here
}

USCITA

Block Speed: 0.127000000s

Answer 4

Nota: la questione era in origine sul tempo di compilazione, ma in seguito si è scoperto che il PO realmente significava tempo di esecuzione. Ma forse questa risposta sarà ancora utile per qualcuno.

Per Visual Studio: andare a Tools / Options / Projects and Solutions / VC++ Project Settings e impostare l'opzione di Build Timing 'yes'. Dopo che il tempo di ogni costruzione sarà visualizzato nella finestra di output.

Answer 5

Questo appare come l'algoritmo di Dijstra. In ogni caso, il tempo impiegato per l'esecuzione dipenderà N. Se ci vogliono più di 3 secondi, non v'è alcun modo che posso vedere di accelerare lo compongono, come tutti i calcoli che si sta facendo bisogno di essere fatto.

A seconda di quale problema si sta cercando di risolvere, ci potrebbe essere un algoritmo più veloce.

Answer 6

Ho utilizzato la tecnica sopra detto, ancora ho trovato che il tempo indicato nella Codice: Blocchi IDE era più o meno simile al risultato Elementi ottenuti (può essere differirà da poco micro secondi) ..