Go: package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)

	for scanner.Scan() {
		num, _ := strconv.Atoi(scanner.Text())
		flag := false
		count := 0

		for i := 2; i <= num; i++ { //1を除く入力値以下の数字
			for j := 2; j < i-1; j++ {
				if i%j == 0 && j != 1 {
					flag = true
					//fmt.Println(i, "/", j)
					break
				}
			}
			if !flag {
				count++
			} else {
				flag = false
			}
		}
		fmt.Println(count)
	}
}

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

std::vector<std::size_t> prime_table = {2};

void make_prime_table(const std::size_t n)
{
    const std::size_t found_last_prime = prime_table.back();
    if(found_last_prime < n)
    {
        std::set<std::size_t> undefined_table;

        for(std::size_t i = found_last_prime + 1; i <= n; ++i)
        {
            undefined_table.insert(i);
        }

        const std::size_t sn = std::sqrt(n);
        for(std::size_t p = 0; ; ++p)
        {
            for(auto u = undefined_table.begin(); u != undefined_table.end();)
            {
                if(0 == *u % prime_table[p])
                {
                    u = undefined_table.erase(u);
                }
                else
                {
                    ++u;
                }
            }
            if(!undefined_table.empty() && found_last_prime <= prime_table[p])
            {
                prime_table.push_back(*undefined_table.begin());
                undefined_table.erase(undefined_table.begin());
                if(sn < prime_table.back())
                {
                    break;
                }
            }
        }
        prime_table.insert(prime_table.end(), undefined_table.begin(), undefined_table.end());
    }
}

std::vector<size_t> prime_acc = {0};

std::size_t prime_size(const std::size_t limit)
{
    if(prime_acc.size() <= limit)
    {
        make_prime_table(limit);
        auto it = prime_table.begin();
        while(prime_acc.size() <= limit)
        {
            it = std::lower_bound(it, prime_table.end(), prime_acc.size());
            if(it != prime_table.end())
            {
                prime_acc.insert(prime_acc.end(), *it - prime_acc.size(), prime_acc.back());
                prime_acc.push_back(prime_acc.back() + 1);
            }
            else
            {
                prime_acc.insert(prime_acc.end(), limit - prime_acc.size() + 1, prime_acc.back());
            }
        }
    }
    return prime_acc[limit];
}

int main()
{
    std::size_t n;

    while(std::cin >> n, !std::cin.eof())
    {
        std::cout << prime_size(n) << std::endl;
    }
}

C++: #include <iostream>
#include <math.h>
using namespace std;

int main(){
  
  int n;

  while(cin >> n){
    bool Prime[1000000] = {};
    int i,j,count;
    count = n;
    for(i = 2; i <= sqrt(n) ; i++){
      if(Prime[i] == false){        
	for(j = 2; i*j <= n ; j++){
	  if(!Prime[i*j]){
	    Prime[i*j] = true;
	    count--;
	  }
	}
      }
    }
    cout << count-1 << endl;
  }
  return 0;
}

C++: #include<stdio.h>
int prime[1000000];
int main(){
    prime[0]=-1;
    prime[1]=-1;
    for(int i=2;i<1000000;i++){
        if(prime[i]==0){
            prime[i]=1;
            for(int j=i*2;j<1000000;j+=i)prime[j]=-1;
        }
    }
    int now;
    while(~scanf("%d",&now)){
        int ans=0;
        for(int i=1;i<now+1;i++)if(prime[i]==1)ans++;
        printf("%d\n",ans);
    }
}

C++: #include<iostream>
using namespace std;

int main()
{
	int a = 0, n;

	for (int j = 1; j <= 30; j++) {
		cin >> n;
		for (int i = 2; i <= n; i++) {
			if (i == 2) {
				a++;
			}
			else if (i == 3) {
				a++;
			}
			else if (i % 2 != 0 && i % 3 != 0) {
				a++;
			}
		}
		cout << a << endl;
		a = 0;
	}
	return 0;
}

C++: #include<stdio.h>
int main(){
	int a,b,c,n;
	c=0;
	scanf("%d",&n);
		for(a=2;a<=n;a++){
			for(b=2;b<=n;b++){
				if(a%b==0&&a!=b){
					break;
				}else if(a%b==0&&a==b){
					c++;
				}else{
				}
			}
		}
		printf("%d\n",c);
	return 0;
}

C++: #include <iostream>
#include <set>
using namespace std;
int main() {
  long n;
  set<long> primes;
  primes.insert(2);
  while (cin >> n) {
    for (int i = 3; i <= n; i++) {
      bool prime = true;
      for (long j : primes)
        if (i % j == 0) {
          prime = false;
          break;
        }
      if (prime) primes.insert(i);
    }
    int x = 0;
    for (long j : primes)
      if (j <= n) x++;
    cout << x << endl;
  }
}

C++: 
#include <iostream>
#include <cmath>

int n;
int known_primes[500000];
int pointer = 0;

void dump_known_primes()
{
	for (int i = 0; i < pointer; i++) {
		std::cout << known_primes[i] << ' ';
	}
	std::cout << std::endl;
}

bool get_input()
{
//	std::cout << "get_input\n";
	return (std::cin >> n);
}

// a < known_primes[pointer+1] ÌÍÍÅ
// a ªf©Ç¤©»è·é
bool is_prime(int a)
{
//	std::cout << "is_prime\n";
	for (int i = 0; known_primes[i] <= std::sqrt(a); i++) {
		if (a % known_primes[i] == 0) {
			return false;
		}
	}
	return true;
}

// mçêÄ¢È¢ÌfðT·
void search_next_prime()
{
//	std::cout << "searcn_next_prime\n";
	int a;
	for (a = known_primes[pointer] + 2; !is_prime(a); a += 2);
	pointer++;
	known_primes[pointer] = a;
}

// XXX
int solve(int a)
{
//	std::cout << "solve\n";
	if (a <= known_primes[pointer]) {
//		std::cout << "a: " << a << ' ' << "pointer: " << pointer << std::endl;
		int i = pointer;
		while (a < known_primes[i]) {
//			std::cout << "i: " << i << std::endl;
			i--;
		}
		return i+1;
	} else {
		search_next_prime();
		return solve(a);
	}
}

int main()
{
//	std::cout << "main\n";
	known_primes[0] = 2;
	known_primes[1] = 3;
	known_primes[2] = 5;
	pointer = 2;
	while (get_input()) {
		std::cout << solve(n) << std::endl;
//		dump_known_primes();
	}
	return 0;
}

C++: #include<iostream>

int main(){

	bool data[100001];

	for (int i = 0; i < 100001; i++)
		if (i % 2 == 0)
			data[i] = false;
		else
			data[i] = true;

	int in;

	int res=0;

	for(int i=2;i<=100000;i++){
		if (i % 2 != 0) {
			for (int j = 2; j < i; j++) {
				if (i%j == 0) {
					data[i] = false;
					goto fl;
				}
			}
		}
	fl:;
	}

	while (true) {

		std::cin >> in;

		for (int i = 2; i <= in; i++) {
			if (data[i] == true)
				res++;
		}

		std::cout << res << std::endl;

	}

		return 0;
}

C++: #include <iostream>
#include <vector>
using namespace std;

int getPrimeCount(int n) {
    vector<bool> isPrime(n+1, true);
    int count = 0;
    for (int i = 2; i <= n; i++) {
        if (isPrime[i]) {
            count++;
            for (int j = i*2; j <= n; j+=i) {
                isPrime[j] = false;
            }
        }
    }
    return count;
}

int main() {
    int n;
    while (cin >> n) {
        cout << getPrimeCount(n) << endl;
    }
}

C++: #include <iostream>
#include <cmath>

const bool isPrime(const int p)
{
    if(p == 2)
    {
        return true;
    }

    if(p < 2 || p % 2 == 0)
    {
        return false;
    }

    for(int i = 3; i <= sqrt(p); i += 2)
    {
        if(p % i == 0)
        {
            return false;
        }
    }

    return true;
}

int main(void)
{
    bool p[1000000];

    for(int i = 0; i < 1000000; ++i)
    {
        p[i] = isPrime(i);
    }

    int n;

    while(std::cin >> n)
    {
        int result = 0;

        for(int i = 0; i <= n; ++i)
        {
            result += p[i];
        }

        std::cout << result << std::endl;
    }

    return 0;
}

C++: #include <iostream>
#include <math.h>
using namespace std;
int main() {
	unsigned long long int i;
	int n, p, cnt,fg;
	while (cin >> n) {
		cnt = 0;
		fg = 0;
		for (i = 3; i <= n; i+=2) {
			for (int j = 3; j <= (int)sqrt(i); j += 2) {
				if (i%j == 0) {
					fg = 1;
					break;
				}
			}
			if (fg)
				fg = 0;
			else
				cnt++;
		}
		//printf("cnt=%d\n", cnt);
		if (n >= 2)
			cnt++;
		cout << cnt << endl;
	}

	return 0;
}