Go: package main

import (
	"fmt"
	"math"
)

func main() {
	var resultArr [40]int
	var inputCount, primeCount, input int
	for {
		fmt.Scanf("%d", &input)
		for i := 0; i <= input; i++ {
			if IsPrime(i) {
				primeCount++
			}
		}
		resultArr[inputCount] = primeCount
		if inputCount == 30 {
			break
		}
		primeCount = 0
		inputCount++
	}
	for _, v := range resultArr {
		fmt.Printf("%d\n", v)
	}
}

func IsPrime(num int) bool {
	switch {
	case num == 2:
		return true
	case num < 2 || num%2 == 0:
		return false
	}
	sqrt := math.Sqrt(float64(num))
	for i := 3; i <= int(sqrt); i += 2 {
		if num%i == 0 {
			return false
		}
	}
	return true
}

C++: #include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
typedef vector<int> vi;

int n;
vi eratosthenes_sieve(int n){
	vi res(n+1);
	if(n<2) return res;
	res[2]=1;
	for(int i=3;i<=n;i+=2){
		if(i*i<=n && !res[i]) for(int j=i+i+i;j<=n;j+=i+i) res[j]=1;
		res[i]=!res[i];
	}
	return res;
}
vi prime_list(const vi& isprime){
	vi res;if(isprime.size()<=2)return res;
	res.push_back(2);
	for(unsigned int i=3;i<isprime.size();i+=2)
		if(isprime[i])res.push_back(i);
	return res;
}
vi prime_list(int n){
	return prime_list(eratosthenes_sieve(n));
}

main(){
	vi pl = prime_list(1000000);
	while(cin >> n) cout << (upper_bound(pl.begin(), pl.end(), n) - pl.begin()) << endl;
	return 0;
}

C++: #coding: UTF-8

from bisect import bisect_right

max_number = 1000000
prime_flag_list = [True] * max_number

prime_flag_list[0] = False
prime_flag_list[1] = False

prime_flag_list[4::2] = [False] * len(prime_flag_list[4::2])

for i in range(3, int(max_number**0.5) + 1, 2):
    prime_flag_list[i*i::i] = [False] * len(prime_flag_list[i*i::i])

prime_list = [i for i in range(2, max_number) if prime_flag_list[i]]

while True:
    try:
        input = int(raw_input())
    except EOFError:
        break

    print bisect_right(prime_list, input)

C++: #include <cstdio>
#include <stdlib.h>
#include <algorithm>
#include <cmath>
#define min(a,b)    (((a) < (b)) ? (a) : (b))
#define max(a,b)    (((a) > (b)) ? (a) : (b))
#define abs(x)    ((x) < 0 ? -(x) : (x))
#define INF 0x3f3f3f3f
#define delta 0.85
#define eps 1e-3
#define PI 3.14159265358979323846
#define MAX_N 1000005
using namespace std;
int cnt[MAX_N];
bool is_prime[MAX_N];

void sieve(int n){
	int limit = sqrt(n);
	for(int i = 0; i <= n; i++) is_prime[i] = 1;
	is_prime[0] = is_prime[1] = 0;
	cnt[0] = cnt[1] = 0;
	for(int i = 2; i <= n; i++){
		if(is_prime[i]){
			cnt[i] = cnt[i - 1] + 1;
			if(i <= limit){
				for(int j = i * i; j <= n; j += i) is_prime[j] = 0;
			}
		}
		else cnt[i] = cnt[i - 1];
	}
}

int main(){
	int n;
	sieve(MAX_N);
	while(~scanf("%d", &n)){
		printf("%d\n", cnt[n]);
	}
	return 0;
}

C++: #include <stdio.h>
#include <stdlib.h>

int main()
{
    int i,j,flag,n,c=0;
    scanf("%d",&n);
    for(i=2;i<=n;i++)
    {
        flag=0;
        for(j=2;j<=i/2;j++)
        {
            if(i%j==0)
            {
                flag=1;
            }
        }
        if(flag==0)
        {
            c++;
        }
    }
    printf("%d",c);
    return 0;
}

C++: #include <iostream>
#include <cstdio>
using namespace std;
const int MAX_N = 1000000; // いくつまで調べるか
bool prime[MAX_N + 1]; // 添字が素数ならtrue、それ以外はfalse
/*void sieve()
{
  prime[0] = prime[1] = false; // 例外処理
  // 配列prime の初期化
  for(int i = 2; i <= MAX_N; ++i)
    prime[i] = true;
  // 素数でないものを調べる
  for(int i = 2; i <= MAX_N; ++i)
    if(prime[i])
      for(int j = i * 2; j <= MAX_N; j += i)
	prime[j] = false;
	}*/

/*int is_prime(int n)
{
  return prime[n];
  }*/

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

int main()
{
  //sieve();
  int a;
  while(cin >> a){
    //cin >> a;
    //if(a==EOF)return 0;
    int count=0;
    //int tmp;
    for(int i=1;i<=a;i++){
      if(is_prime(i))count++;
    }
    printf("%d\n",count);
  }
}

C++: #include <bits/stdc++.h>

const static double	de_PI	= 3.14159265358979323846;
const static int	de_MOD	= 1000000007;
const static int	de_MAX	= 999999999;
const static int	de_MIN = -999999999;

bool Judge_PrimeNumber(const int a) {

	if (a < 2) { return false; }
	if (a == 2) { return true; }
	if (a % 2 == 0) { return false; }

	for (int i = 3; i <= a / i; i += 2) {
		if (a%i == 0) {
			return false;
		}
	}
	return true;
}

int main(void) {

	//std::ifstream in("123.txt");	std::cin.rdbuf(in.rdbuf());

	int n = 0, ans = 0;
	std::vector<int> A;

	while (std::cin >> n) {
		A.push_back(n);
	}

	for (unsigned int i = 0; i < A.size(); i++) {

		if (n == 1) {
			std::cout << 0 << std::endl;
			continue;
		}
		ans = 1;
		for (int j = 3; j <= A[i]; j += 2) {
			if (Judge_PrimeNumber(j)) {
				ans++;
			}
		}
		std::cout << ans << std::endl;
	}

}

C++: #include <iostream>
#include <vector>
#include <algorithm>
	

unsigned isPrime(unsigned x) {
	static std::vector<unsigned> primes{2};
	if (x < 2) {
		return 0;
	}
	if (x == 2) {
		return 1;
	}
	if (primes.back() < x) {
		for (unsigned i = primes.back() + 1; i*i <= x; i++) {
			bool isPrime = std::none_of(primes.begin(), primes.end(), [i](auto d){ return i % d == 0; });
			if (isPrime) {
				primes.push_back(i);
			}
		}
	}
	bool isPrime{true};
	for (auto&& var : primes) {
		if (var >= x) break;
		if (x % var == 0) {
			isPrime = false;
			break;
		}
	}
	return (isPrime) ? 1 : 0;
}

unsigned numOfPrime(const unsigned& x) {
	unsigned sum{};
	static unsigned ntable[999999]{};
	static unsigned maxX{1};
	if (x < 2) {
		return 0;
	}
	if (x == 2) {
		return 1;
	}
	unsigned count_from = std::min(maxX, x);
	sum += ntable[count_from];
	for (unsigned i = count_from + 1; i <= x; i++) {
		sum += isPrime(i);
		ntable[i] = sum;
	}
	maxX = std::max(x,maxX);
	return sum;
}

int main(int argc, char const* argv[])
{
	unsigned d{};
	std::ios::sync_with_stdio(false);
	std::cin.tie(0);
	while (std::cin >> d) {
		std::cout << numOfPrime(d) << std::endl;
	}
	return 0;
}

C++: #include	<math.h>
#include	<stdio.h>

bool isPrimeNumber(int number){
	if(number	  == 2)	return true;
	if(number % 2 == 0)	return false;
	
	
	for(int i = 3; i <= (int)sqrt((double)number) ;i += 2){
		if(number % i == 0)	return false;
	}
	
	return true;
}

int main(int argc, char** argv){
	
	int search, counter;
	
	while((scanf("%d", &search)) != EOF){
		counter = 0;
		for(int i = 2; i <= search; i++){
			counter += isPrimeNumber(i) ? 1 : 0;		
		}
		printf("%d\n", counter);
	}
	
	return 0;
}

C++: #include <iostream>
#define N 1000000 

using namespace std;

bool sosu[N];

void sosuhyo()
{
	sosu[0]=true;
	sosu[1]=true;

	for(int i=2;i<N;i++){
		if(!sosu[i]){
			for(int j=2;j<=(N/i);j++){
				sosu[i*j]=true;
			}
		}
	}

}


int main(){
	
	sosuhyo();

	int a,count;

	while(cin>>a && a){
		count=0;
		for(int i=0;i<=a;i++){
			if(!sosu[i])count++;
		}
		cout << count << endl;
	}

	return 0;
}

C++: #define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>

using namespace std;


#define N_MAX 100000
int main(){
	
	int array[N_MAX],i,j,n, num = 0;
	
	while(cin>>n){
		num = 0;
		for (i=0;i<n;i++)
			array[i]=i+2;
		for (i=0;i<sqrt(n*1.0);i++){
			for (j = (i+2); (i+2) * j <= n; j++)
				array[(i+2) * j - 2] = -1;}

	for (i = 0; i < n-1; i++){
    if (array[i] != -1)
	num++;
	}
	cout<<num<<endl;
	}

	cin>>n;
	
	
	
	
  
	return (0);
}

C++: #include<iostream>
using namespace std;
int main(){
  int a,t[1000000],u[1000000];
  for(int i=0;i<1000000;i++){
    t[i]=1;
  }
  t[0]=t[1]=u[0]=u[1]=0;
  for(int i=2;i<=1000000;i++){
    if(t[i]==1){
      for(int j=i+i;j<1000000;j+=i)t[j]=0;
      u[i]=u[i-1]+1;
    }else{
      u[i]=u[i-1];
    }
  }
  while(cin>>a){
    cout<<u[a]<<endl;
  }
  return 0;
}