import math
from datetime import datetime

def is_prime(num):
    if num < 2:
        return False
    for i in range(2, int(math.sqrt(num)) + 1):
        if num % i == 0:
            return False
    return True

start = datetime.now()
primes = []
for num in range(int(1e7)):
    if is_prime(num):
        primes.append(num)
print('Python: ', datetime.now() - start)

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <math.h>
#include <time.h>

bool is_prime(int num) {
    if (num < 2) {
        return false;
    }
    for (int i = 2; i <= sqrt(num); i++) {
        if (num % i == 0) {
            return false;
        }
    }
    return true;
}

int main() {
    clock_t start = clock();
    int *primes = malloc(10000000 * sizeof(int));
    int count = 0;
    for (int num = 2; num < 10000000; num++) { // Start at num=2, not num=0
        if (is_prime(num)) {
            primes[count++] = num;
        }
    }
    printf("C: %f seconds\n", ((double)clock() - start) / CLOCKS_PER_SEC);
    free(primes); // Free the dynamically allocated memory
    return 0;
}

package main

import (
    "fmt"
    "math"
    "time"
)

func isPrime(num int) bool {
    if num < 2 {
        return false
    }
    for i := 2; i <= int(math.Sqrt(float64(num))); i++ {
        if num%i == 0 {
            return false
        }
    }
    return true
}

func main() {
    start := time.Now()
    primes := []int{}
    for num := 0; num < int(1e7); num++ {
        if isPrime(num) {
            primes = append(primes, num)
        }
    }
    fmt.Println("Go: ", time.Since(start))
}

import java.time.Duration;
import java.time.Instant;
import java.lang.Math;
import java.util.ArrayList;
import java.util.List;

public class primes {
    public static boolean isPrime(int num) {
        if (num < 2) {
            return false;
        }
        for (int i = 2; i <= Math.sqrt(num); i++) {
            if (num % i == 0) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        Instant start = Instant.now();
        List<Integer> primes = new ArrayList<Integer>();
        for (int num = 0; num < 10000000; num++) {
            if (isPrime(num)) {
                primes.add(num);
            }
        }
        System.out.println("Java: " + Duration.between(start, Instant.now()).toMillis() + " ms");
    }
} 

function isPrime(num) {
    if (num < 2) {
      return false;
    }
    for (let i = 2; i <= Math.sqrt(num); i++) {
      if (num % i === 0) {
        return false;
      }
    }
    return true;
  }

  const start = new Date();
  const primes = [];
  for (let num = 0; num < 1e7; num++) {
    if (isPrime(num)) {
      primes.push(num);
    }
  }
  console.log(`JavaScript: ${(new Date() - start)/1000} seconds`);

def is_prime(num)
    return false if num < 2
    (2..Math.sqrt(num).to_i).each do |i|
      return false if num % i == 0
    end
    true
  end

  start = Time.now
  primes = []
  (0...1e7.to_i).each do |num|
    primes << num if is_prime(num)
  end
  puts "Ruby: #{Time.now - start} seconds"

use std::time::{Instant, Duration};
use std::f64::consts::SQRT_2;

fn is_prime(num: u32) -> bool {
    if num < 2 {
        return false;
    }
    for i in 2..=((num as f64).sqrt() as u32) {
        if num % i == 0 {
            return false;
        }
    }
    true
}

fn main() {
    let start = Instant::now();
    let mut primes = Vec::new();
    for num in 0..10_000_000 {
        if is_prime(num) {
            primes.push(num);
        }
    }
    let end = Instant::now();
    let time_elapsed = end - start;
    println!("Rust: {:?}", time_elapsed);
}