====== Calculate Elapsed Time ======

===== C =====

<code c>
#include <time.h>
</code>

<code c>
#define CLOCK_REALTIME 0

struct timespec start, end, elapsed;

clock_gettime(CLOCK_REALTIME, &start);

clock_gettime(CLOCK_REALTIME, &end);

elapsed.tv_sec = end.tv_sec - start.tv_sec;

printf("Elapsed time: %ld seconds\n", elapsed.tv_sec);
</code>

===== C++ =====

<code cpp>
#include <chrono>
</code>

<WRAP prewrap>
<code cpp>
auto start = chrono::high_resolution_clock::now();

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

chrono::duration<double> elapsed = end - start;

cout << "Elapsed time: " << round(elapsed.count()) << " seconds" << endl;
</code>
</WRAP>

===== C# =====

<code csharp>
using System.Diagnostics;
</code>

<WRAP prewrap>
<code csharp>
Stopwatch stopwatch = Stopwatch.StartNew();

stopwatch.Stop();

Console.WriteLine($"Elapsed time: {stopwatch.ElapsedMilliseconds / 1000} seconds");
</code>
</WRAP>

===== Go =====

<code go>
import "time"
</code>

<WRAP prewrap>
<code go>
start := time.Now()

elapsed := time.Since(start)

fmt.Printf("Elapsed time: %d seconds\n", int(math.Round(elapsed.Seconds())))
</code>
</WRAP>

===== Java =====

<WRAP prewrap>
<code java>
long startTime = System.currentTimeMillis();

long endTime = System.currentTimeMillis();
long elapsedTime = (endTime - startTime) / 1000;

System.out.println(String.format("Elapsed time: %d seconds", elapsedTime));
</code>
</WRAP>

===== JavaScript =====

<WRAP prewrap>
<code javascript>
var startTime = new Date().getTime();

var endTime = new Date().getTime();
var elapsedTimeInSeconds = (endTime - startTime) / 1000;

document.getElementById('elapsedTime').innerHTML = `${Math.round(elapsedTimeInSeconds)} seconds`;
</code>
</WRAP>

===== Python =====

<code python>
import time
</code>

<WRAP prewrap>
<code python>
start_time = time.time()

end_time = time.time()
elapsed_time = end_time - start_time

print(f"Elapsed time: {elapsed_time:.0f} seconds")
</code>
</WRAP>

===== Ruby =====

<WRAP prewrap>
<code ruby>
start_time = Time.now

end_time = Time.now
elapsed_time = end_time - start_time

puts "Elapsed time: #{elapsed_time.round} seconds"
</code>
</WRAP>

===== Rust =====

<code rust>
use std::time::{Duration, Instant};
</code>

<WRAP prewrap>
<code rust>
let start_time: Instant = Instant::now();

let elapsed: Duration = start_time.elapsed();
let elapsed_seconds: f64 = elapsed.as_secs_f64();

println!("Elapsed time: {:.0} seconds", elapsed_seconds);
</code>
</WRAP>

===== Swift =====

<WRAP prewrap>
<code swift>
let start_time: Date = Date()

let end_time: Date = Date()
let elapsed_time: TimeInterval = end_time.timeIntervalSince(start_time)

print("Elapsed time: \(Int(round(elapsed_time))) seconds")
</code>
</WRAP>

{{tag>c_and_cpp dotnet go java javascript python ruby rust swift}}