Go: package main

import (
	"fmt"
	"math"
)

func main() {
	var resultArr [31]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<math.h>
#include<string>
#include<vector>
#include<algorithm>
#include<queue>
#include<map>
using namespace std;
#define INF 1<<20

struct edge{
	int to;
	int cost;
	edge() {};
	edge(int a, int b) {
		to = a;
		cost = b;
	}
};

struct Node {
	int pos;
	int cost;
	Node() {};
	Node(int a, int b) {
		pos = a;
		cost = b;
	}
	bool operator <(const Node& rhs) const {
		return cost > rhs.cost;
	}
};

void dijkistra(int st, int TO,int V,vector<vector<edge> > graph) {
	priority_queue<Node> q;
	vector<int> d(V);
	for (int i = 0;i < V;i++) {
		d[i] = INF;
	}
	d[st] = 0;
	q.push(Node(st, 0));
	while (!q.empty()) {
		Node s = q.top(); q.pop();
		int pos = s.pos;
		for (int i = 0;i < graph[pos].size();i++) {
			int to = graph[pos][i].to;
			int cost = graph[pos][i].cost;
			if (d[pos] + cost < d[to]) {
				d[to] = d[pos] + cost;
				q.push(Node(to, d[to]));
			}

		}
	}
	cout << d[TO] << endl;
}
int partition(int A[],int p, int r) {
	int x = A[r];
	int i = p - 1;
	for (int j = p;j < r;j++) {
		if (x >= A[j]) {
			i = i + 1;
			swap(A[i], A[j]);
		}
	}
		swap(A[i + 1], A[r]);
		return i + 1;
}
void quicksort(int A[], int p, int r) {
	if (p < r) {
		int q = partition(A, p, r);
		quicksort(A, p, q-1);
		quicksort(A, q + 1, r);
	}
}

int getNumberOfCoin(int C[],int n,int m) {
	int T[50000];
	for (int j = 0;j <= n;j++) {
		T[j] = INF;
	}
	T[0] = 0;
	for (int i = 0;i < m;i++) {
		for (int j = 0;j <= n;j++) {
			if (j - C[i] >=0  ) {
				T[j] = min(T[j], T[j - C[i]] + 1);
			}
		}
	}
	return T[n];
}
int knapsack(int w, int n,int* v,int* ww) {
	int W[101][10001];
		for (int j = 0;j <= w;j++) {
			W[0][j] = 0;
		}
	for (int i = 0;i < n;i++) {
		for (int k = 0;k < n;k++){
			for (int j = 0;j <= w;j++) {
				if (j - ww[k] < 0) {
					W[i + 1][j] = W[i][j];
				}
				if (j - ww[i] >= 0) {
					W[i + 1][j] = max(W[i][j], W[i][j - ww[k]] + v[k]);

				}
			}
		}
	}
	return W[n][w];
}
int fib(int n) {
	vector<int> v(n+1);
	v[0] = 1;
	v[1] = 1;
	for (int i = 2;i < n+1;i++) {
		v[i] = v[i - 2] + v[i - 1];
	}
	return v[n];
}
int isPrime(int x) {
	if (x <= 1) return false;
	if (x>2 && x % 2 == 0) return false;
	for (int i = 2;i <= sqrt(x);i++) {
		if (x%i == 0) {
			return false;
		}
	}
	if (x == 2) return true;
	return true;
}
int main(){
	int n;
	vector<int> a;
	while (cin >> n) {
		a.push_back(n);
	}
	for (int j = 0;j < a.size();j++){
		int count = 0;
		for (int i = 2;i <= a[j];i++) {
			
			if (isPrime(i)) {
				count++;
			}
			
		}
		cout << count << endl;
	}
	

}

C++: #include <iostream>
#include <math.h>
using namespace std;
bool isPrime(int n) {
    bool flag = false;
    if(n % 2 == 0) {
        if(n==2){
            flag=true;
        }
    }
    else {
        for(int i=3;i<=n;i+=2) {
            if(n==i) {flag=true;break;
            }else if(n % i==0){
                flag=false;break;
            }else flag=true;
        }
    }
    return flag;
}
int main(void){
    int n=0;
    int count = 0;
    while(cin>>n) {
        count = 0;
        for(int i=2;i<=n;i++) {
            if(isPrime(i))count++;
        }
        std::cout << count << std::endl;
    }
}

C++: #include<stdio.h>

int main(void)
{
	int d=0,i,j,s[100000],x;

	for(i=2;i<=100000;i++)
		s[i]=1;

	while(scanf("%d",&d)!=EOF)
	{
		x=0;
	for(i=2;i<=d;i++){
	    if(s[i]==1){
		  for(j=i*2;j<=d;j+=i)
			   s[j]=0;
		}
	}
		if(d<=1){
			printf("%d\n",0);
		}
		else
		{
		for(i=2;i<=d;i++){
			x+=s[i];
		}
		printf("%d\n",x);
		}
	}
  return 0;
}

C++: #include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <utility>
#include <ctime>
#define INF 999999999
#define mod 1000000007

#define rep(i,n) for(int i=0;i<int(n);i++)
#define rrep(i,n) for(int i=(n);i>=0;i--)
#define REP(i,a,b) for(int i=(a);i<int(b);i++)
#define all(x) (x).begin(),x.end()
#define pb push_back
#define MOD(x) (x%(mod))
using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef pair<int,int> pi;

bool debug=false;
/*---------------------------------------------------*/

bool prime[1000000];
int ans[1000000];

void is_prime(){
  rep(i,1000000)prime[i]=true;
  prime[0]=prime[1]=false;
  REP(i,2,1000000){
    if(prime[i]==true){
      for(int j=i+i;j<1000000;j+=i)prime[j]=false;
    }
  }
  if(debug)rep(i,1000)if(prime[i])cout<<i<<endl;
}

void calc(){
  ans[0]=0;
  REP(i,1,1000000){
    ans[i]=ans[i-1]+prime[i];
  }
}

int main(){
  int n;
  is_prime();
  calc();
  while(cin>>n){
    cout<<ans[n]<<endl;
  }
  return 0;
}

C++: #include<stdio.h>
bool b[1000000];

int main(void)
{
    int a,n,i;
    int count=0;
    int f=1;

    for(i=3;i<1000000;i+=2){
        f=1;
        for(a=2;a*a<=i;a++){
            if(i%a == 0){
                f=0;
                break;

            }
        }
        if(f==1){
            b[i]=1;
        }
    }
    b[2]=1;

    while(scanf("%d",&n)!=EOF){
        for(i = 0; i < n; i++){
            if(b[i]==1)count++;
        }

    printf("%d\n",count);
    count=0;
    }
    return 0;
}

C++: #include<stdio.h>
#include<algorithm>
#include<string.h>
#include<vector>
#include<queue>
//aoj0009
using namespace std;
int n,gs;
vector<int> cun;
char ip[1000003];
void prime()
{
	cun.clear();
	gs=0;
	memset(ip,1,sizeof(ip));
	ip[0]=0;
	ip[1]=0;
	for(int i=2;i<=n;i++)
	{
		if(ip[i]==1)
		{
			gs++;
			cun.push_back(i);
			for(int j=2*i;j<=n;j+=i)
			{
				ip[j]=0;
			}
		}
	}
}
int main()
{
	while(scanf("%d",&n)!=EOF)
	{
		prime();
		printf("%d\n",gs);
	}
	return 0;
}

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

using namespace std;

int main() {
  bitset<1000000> primes;
  int i, j, n;
  while (cin >> n) {
    primes.reset();
    for (i = 2; i <= n; i++)
      if (primes[i] == false)
	for (j = i + i; j <= n; j += i)
	  primes[j] = true;
    cout << n - primes.count() - 1 << endl;
  }
  return 0;
}

C++: #include <iostream>
#include <cmath>
 
bool CheckPrimeNumber(int number) {
    int max = (int)std::sqrt(number);
    for (int i=3; i<=max; i+=2)
        if (number % i == 0)
            return false;
    return true;
}
 
int main() {
    int n, cnt;
    while (std::cin >> n) {
        if (n < 2) {
	cnt = 0;
        } else if (n == 2) {
	cnt = 1;
        } else {
        	cnt = 1;
        	for (int i=3; i<=n; i+=2)
		if (CheckPrimeNumber(i))
			cnt++;
        }
        std::cout << cnt << std::endl;
    }
    return 0;
}

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


int main() {
  int max =0;
  vector<int> ns;
  vector<int> nums;
  while(!cin.eof()){
    int n=0;
    cin >> n;
    // 求める数の最大値を出す
    max = max > n ? max : n;
    // nsには入力が一覧で入る
    ns.push_back(n);
  }
  for(int i =0 ;i <= max;i++) {
    // 0-maxまで1をいれる。
    nums.push_back(1);
  }

  // 素数の可能性が無いものについては0を入れていく (n >=2)
  for(int i =2 ;i <= max;i++) {
    if(nums[i]==0) {
      continue;
    }
    // 素数の 2～倍はすべて素数ではないのでnを入れる
    for(int ii=i*2 ; ii<=max ; ii+=i) {
      nums[ii] = 0;
    }
  }

  for(int i=0;i<ns.size()-1;i++) {
    int count = 0;
    // 素数の数を数え上げ
    for(int ii=2 ; ii <= ns[i] ; ii++) {
      if(nums[ii]==1) count++;
    }
    cout<<count<<endl;
  }
}