Go: package main

import (
        "fmt"
        "math"
)

func main() {
        var v, t, h float64
        for {
                _, err := fmt.Scanf("%f", &v)
                if err != nil {
                        break
                }
                t = v / 9.8
                h = 4.9 * t * t
                n := math.Floor(h/5+1.0) + 1.0
                fmt.Printf("%d\n", int(n))
        }
}

C++: #include <algorithm>
#include <vector>
#include <math.h>
#include <stdio.h>
#include <cctype>
#include <iostream>
#include <set>
#include <string>
#include <queue>
#include <map>
using namespace std;
int size(string x){
	string::size_type size=x.size();
	return size;
}
#define fu(l,k) for(int i=l;i<k;i++)
#define fd(l,k) for(int i=l;i>k;i--)
#define fi first
#define se second
typedef  vector<string> vs;
typedef  vector<int> vi;
double pi(){
	return M_PI;
}
typedef set<int> set_i;
typedef set<string> set_s;
int main(){
	double n,x,t,h;
	while(cin>>x){
		t=x/9.8;
		h=4.9*x*x/(9.8*9.8);
		n=h/5;
		if((int)h%5==0) cout<<(int)n+1<<endl;
		else cout<<(int)n+2<<endl;
	}
}

C++: #include <stdio.h>
using namespace std;
int main ()
{
    double v,t,y,n,i;
    while(scanf("%lf",&v)!=EOF){
        y=4.9*(v/9.8)*(v/9.8);
        for(i=1;;i++){
            if(y-5>0) y=y-5;
            else if(y-5<=0)break;
        }
        printf("%d\n",(int)i+1);
    }
    return 0;
}

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

int main() {
	double v;
	while(~scanf("%lf",&v))
	{
		double t=v/9.8;
		t*=t*4.9;
		int c=1;
		double h=0.0;
		while(h<t)
		{
			h+=5.0;
			c++;
		}
		cout<<c<<endl;
	}
	return 0;
}

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

double v;

void solve() {
    double y = v * v / 19.6;
    int N = ceil(y / 5.0 + 1);
    cout << N << endl;
}

int main() {
    while (cin >> v) {
        solve();
    }
    return 0;
}

C++: #include <iostream>

using namespace std;

int main()
{
	double v, y, t;
	int floor;

	while (cin >> v)
	{
		if(cin.eof())    break;

		t = v / 9.8;
		y = 4.9 * t * t;
	
		floor = int((y+5) / 5 + 0.9999999999);

		cout << floor << endl;
	}

	return 0;
}

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

int main(){
	float v;
	while(cin >> v){
		float t = v / 9.8;
		float y = 4.9 * t * t;
		int i = 1;
		while(1){
			if(y <= 5*i-5) break;
			i++;
		}
		cout << i << endl;
	}
	return 0;
}

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

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    double v;
    while(cin>>v) {
        double y=v*v/19.6;
        cout<<(int)(y+4.9)/5+1<<'\n';
    }
    return 0;
}

C++: #include<iostream>
using namespace std;
int main(){
	double v0,t;
	while(cin>>v0){
		int n=0;
		t=0;
		t=v0/9.8;
		cout<<t<<endl;
		while(5*n-5<=4.9*t*t){
			n++;
		}
		cout<<n<<endl;
	}
}

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

using namespace std;

int main (void) {
    while (1) {
        double v0, v;
        cin >> v0;
        if (cin.eof()) break;
        for (int n = 0; ; n++) {
            v = 9.8 * sqrt((5 * n - 5) / 4.9);
            if (v >= v0) {
                cout << n << endl;
                break;
            }
        }
    }
    return 0;
}

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

//using namespace--------------------------------------------------------------------------------------------------------------
using namespace std;

//define-----------------------------------------------------------------------------------------------------------------------
#define rep(i, n) for(int i = 0; i < n; i++)
#define FOR(i, s, n) for(int i = s; i < n; i++)
#define per(i, n) for(int i = n; i >= 0; i--)
#define ROF(i, s, n) for(int i = s; i >= n; i--)
#define FORIT(i, A) for (auto i : A)
#define PRINT(x) cout << (x) << endl
#define ALL(a)  (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define FOREACH(i, n) for (__typeof((n).begin()) i = (n).begin(); i != (n).end(); ++i)
#define SZ(a) int((a).size())
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
#define INF 1 << 25
#define CLR(a) memset((a), 0 ,sizeof(a))
#define dump(x)  cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
#define sq(n) (n) * (n)

//typedef----------------------------------------------------------------------------------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
typedef unsigned int uint;
typedef unsigned long long ull;

//const------------------------------------------------------------------------------------------------------------------------
const double EPS = 1e-10;
const double PI = acos( -1.0 );

//global-----------------------------------------------------------------------------------------------------------------------
double a;
double test;

//function---------------------------------------------------------------------------------------------------------------------
int main() {
	while ( scanf( "%lf", &a ) != EOF ) {
		for ( int i = 2;; i++ ) {
			test = ( i * 5 - 5 );
			test /= 4.9;
			test = sqrt( test );
			if ( test * 9.8 >= a ) {
				printf( "%d\n", i );
				break;
			}
		}
	}
	return 0;
}

C++: #???script?????????????????????????????£???

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

int main()
{
	double velocity = 0;
	while (std::cin >> velocity) {
		double time = velocity / 9.8;
		double y = 4.9 * time * time;
		int floor = static_cast<int>(y / 5.0) + 2;
		std::cout << floor << std::endl;
	}

	return 0;
}

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

double speed(int i){
	double height = i * 5 - 5;
	return 2 * 9.8 * height;
}
int main(){
	double vl;
	while(cin >> vl){
		int i = 0;
		while(speed(i) < vl * vl) i++;
		cout << i << endl;
	}
	return 0;
}

C++: // 2014/06/09 Tazoe

#include <iostream>
#include <cmath>
using namespace std;

int main()
{
	while(true){
		double v;
		cin >> v;

		if(cin.eof())
			break;

		int N = ceil(v*v/98.0+1.0);

		cout << N << endl;
	}

	return 0;
}

C++: #include <iostream>
using namespace std;
 
int main() {
  double v;
  while(cin >> v) {
    double N = (v*v)/98+1;
    if(N != (int)N) N++;
    cout << (int)N << endl;
  }
  return 0;
}

C++: #define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;

//#define int long long
#define DBG 1
#define dump(o) if(DBG){cerr<<#o<<" "<<o<<endl;}
#define dumpc(o) if(DBG){cerr<<#o; for(auto &e:(o))cerr<<" "<<e;cerr<<endl;}
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define rrep(i,a,b) for(int i=(b)-1;i>=(a);i--)
#define each(it,c) for(auto it=(c).begin();it!=(c).end();it++)
#define all(c) c.begin(),c.end()
const int INF = sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)(1e9 + 7);

signed main() {
	double v;
	while (cin >> v) {
		double t = v / 9.8;
		double y = 4.9*t*t;
		cout << (int)ceil(y / 5)+1 << endl;
	}
	return 0;
}

C++: #include<iostream>

int main(){

	double min_v;
	while (std::cin >> min_v){

		double t = min_v / 9.8;
		double sum = 4.9*t*t;

		int y = (sum + 5) / 5;

		std::cout << (5 * y - 5 > sum ? y : y + 1) << std::endl;
	}

	return 0;
}

C++: 
#define _USE_MATH_DEFINES
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <string>
#include <cstring>
#include <vector>
#include <map>
#include <utility>
#include <complex>
#include <stack>
#include <climits>

using namespace std;

double sq(double x){return x*x;}

int a[5001];

int main(){
	double d;
	while(cin>>d){
		d = sq(d / 9.8) * 4.9 + 5;
		int n = (int)(d / 5);
		if((double)n * 5 != d)
			n++;
		cout << n << endl;
	}

	return 0;
}