s_id
stringlengths 10
10
| p_id
stringlengths 6
6
| u_id
stringlengths 10
10
| date
stringlengths 10
10
| language
stringclasses 1
value | original_language
stringclasses 11
values | filename_ext
stringclasses 1
value | status
stringclasses 1
value | cpu_time
int64 0
100
| memory
stringlengths 4
6
| code_size
int64 15
14.7k
| code
stringlengths 15
14.7k
| problem_id
stringlengths 6
6
| problem_description
stringlengths 358
9.83k
| input
stringlengths 2
4.87k
| output
stringclasses 807
values | __index_level_0__
int64 1.1k
1.22M
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
s106557815
|
p00024
|
u647694976
|
1555926355
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5588
| 170
|
while True:
try:
v=float(input())
t=v/9.8
y=4.9*t**2
N=0
while y>5*(N-1):
N +=1
print(N)
except:break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,602
|
s272956497
|
p00024
|
u193025715
|
1408269510
|
Python
|
Python3
|
py
|
Accepted
| 30
|
6800
| 249
|
while True:
try:
n = float(input())
ans = 1
v = 0
while v < n:
ans += 1
y = ans * 5 - 5
t = (y / 4.9) ** 0.5
v = 9.8 * t
print(ans)
except:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,603
|
s542796075
|
p00024
|
u506132575
|
1416134972
|
Python
|
Python
|
py
|
Accepted
| 20
|
4364
| 140
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import math
for s in sys.stdin:
print int(math.ceil(( float(s)**2 )*0.1/9.8)+1)
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,604
|
s810925505
|
p00024
|
u342537066
|
1420713381
|
Python
|
Python3
|
py
|
Accepted
| 30
|
6808
| 270
|
while True:
try:
x=float(input())
cnt=1
while True:
y=cnt*5-5
t=(y/4.9)**0.5
v=t*9.8
if x<=v:
print(cnt)
break
else: cnt+=1
except:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,605
|
s557868141
|
p00024
|
u567380442
|
1422793893
|
Python
|
Python3
|
py
|
Accepted
| 30
|
6828
| 151
|
import sys
f = sys.stdin
import math
for line in f:
v = float(line)
t = v / 9.8
y = 4.9 * t * t
n = math.ceil(y / 5) + 1
print(n)
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,606
|
s007052921
|
p00024
|
u879226672
|
1424449843
|
Python
|
Python
|
py
|
Accepted
| 10
|
4348
| 187
|
import math
while True:
try:
minv = float(raw_input())
except EOFError:
break
N = 1
while 9.8 * math.sqrt( (5*N -5) /4.9) < minv:
N +=1
print N
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,607
|
s872539521
|
p00024
|
u744114948
|
1425999892
|
Python
|
Python3
|
py
|
Accepted
| 40
|
6836
| 134
|
import math
while True:
try:
l=float(input())
except:
break
y=4.9*(l/9.8)**2/5
print(math.ceil(y)+1)
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,608
|
s925193326
|
p00024
|
u540744789
|
1426177893
|
Python
|
Python
|
py
|
Accepted
| 20
|
4368
| 116
|
import sys
import math
for v in sys.stdin:
y=4.9*(float(v)/9.8)**2
N=(y+5.0)/5.0
print int(math.ceil(N))
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,609
|
s656258383
|
p00024
|
u067299340
|
1432819059
|
Python
|
Python
|
py
|
Accepted
| 10
|
4364
| 105
|
import sys,math
for l in sys.stdin:print int(math.ceil(float(l)**2*0.01020408163265306122448979591837)+1)
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,610
|
s511443324
|
p00024
|
u067299340
|
1432819329
|
Python
|
Python
|
py
|
Accepted
| 20
|
4360
| 73
|
import sys,math
for l in sys.stdin:print int(math.ceil(float(l)**2/98)+1)
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,611
|
s644193259
|
p00024
|
u067299340
|
1432819400
|
Python
|
Python
|
py
|
Accepted
| 20
|
4356
| 73
|
import sys,math
for l in sys.stdin:print int(math.ceil(float(l)**2/98))+1
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,612
|
s470219912
|
p00024
|
u067299340
|
1432819443
|
Python
|
Python
|
py
|
Accepted
| 20
|
4356
| 73
|
import sys,math
for l in sys.stdin:print int(math.ceil(float(l)**2/98))+1
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,613
|
s328585006
|
p00024
|
u067299340
|
1432873651
|
Python
|
Python
|
py
|
Accepted
| 10
|
4360
| 73
|
import sys,math
for l in sys.stdin:print int(math.ceil(float(l)**2/98))+1
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,614
|
s115679566
|
p00024
|
u873482706
|
1434541034
|
Python
|
Python
|
py
|
Accepted
| 10
|
4376
| 287
|
import math
def get_float():
while True:
try:
yield float(raw_input())
except EOFError:
break
v_lis = list(get_float())
for v in v_lis:
t = v / 9.8
y = 4.9 * (t**2)
_N = (y + 5) / 5
N = int(math.ceil(_N))
print N
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,615
|
s834048210
|
p00024
|
u379956761
|
1435152255
|
Python
|
Python3
|
py
|
Accepted
| 30
|
6824
| 251
|
import math
import sys
def speed(floor):
N = 5 * floor - 5
time = math.sqrt(N/4.9)
return (9.8 * time)
for s in sys.stdin:
brkSpd = float(s)
floor = 1
while brkSpd > speed(floor):
floor = floor + 1
print(floor)
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,616
|
s630201281
|
p00024
|
u071010747
|
1445265944
|
Python
|
Python3
|
py
|
Accepted
| 20
|
7428
| 431
|
# -*- coding:utf-8 -*-
def main():
while True:
try:
v=float(input())
flag=True
i=1
while flag:
h=19.6*(5*i-5)
if h>=v**2:
flag=False
print(i)
elif h<v**2:
i+=1
except:
break
if __name__ == '__main__':
main()
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,617
|
s358856737
|
p00024
|
u140201022
|
1446995473
|
Python
|
Python
|
py
|
Accepted
| 10
|
6320
| 356
|
import math
while 1:
try:
while 1:
v=float(raw_input())
t=v/9.8
y=t*t*4.9
n=int(math.ceil((y+5.0)/5.0))
tmp=0
while 1:
if tmp*5-5>=y:
n=tmp
break
tmp+=1
print n
except:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,618
|
s342282723
|
p00024
|
u775586391
|
1448335698
|
Python
|
Python3
|
py
|
Accepted
| 30
|
7464
| 145
|
import sys
for line in sys.stdin.readlines():
v = float(line)
t = v / 9.8
h = 4.9*(t**2)
n = 0
while 5*(n-1) < h:
n += 1
print(n)
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,619
|
s432907532
|
p00024
|
u461370825
|
1449743448
|
Python
|
Python
|
py
|
Accepted
| 20
|
6420
| 182
|
from math import *
PI = 3.1415926535898
while True:
try:
v = input()
t = v / 9.8
y = t*t * 4.9
ans = 0
while 5*ans-5 < y:
ans += 1
print ans
except EOFError:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,620
|
s638331972
|
p00024
|
u560214129
|
1450449147
|
Python
|
Python3
|
py
|
Accepted
| 30
|
7472
| 163
|
import sys,math
for line in sys.stdin.readlines():
v = float(line)
t = v/9.8
y = 4.9*t*t
floor = (y + 5)/5
floor = math.ceil(floor)
print(floor)
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,621
|
s009729161
|
p00024
|
u075836834
|
1458510762
|
Python
|
Python3
|
py
|
Accepted
| 20
|
7488
| 211
|
def floor(y):
f=1
height=0
while True:
if y<height and y-height<5:
return f
else:
f+=1
height+=5
while True:
try:
v=float(input())
y=v**2/(2*9.8)
print(floor(y))
except EOFError:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,622
|
s722132305
|
p00024
|
u650459696
|
1458717548
|
Python
|
Python3
|
py
|
Accepted
| 40
|
7436
| 136
|
import math
while True:
try:
v = float(input())
except:
break
print(math.ceil(4.9 * (v / 9.8) ** 2 / 5) + 1)
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,623
|
s523656517
|
p00024
|
u148101999
|
1459237857
|
Python
|
Python
|
py
|
Accepted
| 10
|
6328
| 116
|
import sys
for i in sys.stdin:
x = map(float, i.split())
t = x[0] / 9.8
y = 4.9*(t**2)
print int((y + 5)/5) + 1
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,624
|
s229437003
|
p00024
|
u130979865
|
1459949281
|
Python
|
Python
|
py
|
Accepted
| 10
|
6472
| 157
|
# -*- coding: utf-8 -*-
import sys
import math
for line in sys.stdin:
v = float(line)
t = v/9.8
y = t*t*4.9
print int(math.floor((y+10)/5))
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,625
|
s536798816
|
p00024
|
u572790226
|
1460611208
|
Python
|
Python3
|
py
|
Accepted
| 30
|
7604
| 186
|
import sys
from math import ceil
a = 9.8
h = 5.0
Vmin = [float(v) for v in (sys.stdin.readlines())]
for vmin in Vmin:
y = a/2 * vmin**2 / a **2
N = int(ceil(y/h))+1
print(N)
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,626
|
s694621031
|
p00024
|
u766477342
|
1468192577
|
Python
|
Python3
|
py
|
Accepted
| 30
|
7520
| 159
|
try:
while 1:
y = 4.9 * (float(input()) / 9.8) ** 2
N = 1
while N * 5 - 5 < y:
N += 1
print(N)
except:
pass
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,627
|
s521639675
|
p00024
|
u896025703
|
1469597199
|
Python
|
Python3
|
py
|
Accepted
| 20
|
7440
| 118
|
while True:
try:
v = float(input())
N = 4.9 / 5 * v**2 / 9.8**2 + 1
print(int(N) + 1)
except EOFError:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,628
|
s484546571
|
p00024
|
u358919705
|
1471988089
|
Python
|
Python3
|
py
|
Accepted
| 30
|
7508
| 124
|
import math
while True:
try:
v = float(input())
except:
break
print(math.floor(v ** 2 / 98 + 2))
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,629
|
s058950876
|
p00024
|
u358919705
|
1471988236
|
Python
|
Python3
|
py
|
Accepted
| 20
|
7368
| 66
|
while 1:
try:print(int(float(input())**2/98+2))
except:break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,630
|
s388462142
|
p00024
|
u379499530
|
1473126297
|
Python
|
Python
|
py
|
Accepted
| 20
|
6412
| 136
|
while 1:
try:
v = float(input())
N = int((4.9 * ((v / 9.8) ** 2)) / 5) + 2
print N
except:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,631
|
s766455354
|
p00024
|
u964040941
|
1479237843
|
Python
|
Python3
|
py
|
Accepted
| 30
|
7412
| 195
|
import sys
import math
for line in sys.stdin:
x = float(line)
for i in range(500):
y = i * 5
if math.sqrt(y / 4.9) * 9.8 >= x:
print(i + 1)
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,632
|
s421983028
|
p00024
|
u922871577
|
1479428812
|
Python
|
Python
|
py
|
Accepted
| 30
|
7868
| 268
|
import sys, math
from fractions import Fraction as F
for line in sys.stdin:
t = F(line.rstrip()) / F(98, 10)
y = F(49, 10) * t * t
#print int(math.ceil(y/5 + 1))
for n in xrange(1, 1000):
if 5 * n - 5 >= y:
print n
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,633
|
s581577826
|
p00024
|
u777299405
|
1479893575
|
Python
|
Python3
|
py
|
Accepted
| 40
|
7504
| 129
|
import math
import sys
for s in sys.stdin:
d = float(s)
y = 4.9 * (d / 9.8)**2
n = math.ceil(y / 5) + 1
print(n)
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,634
|
s308958613
|
p00024
|
u301729341
|
1481041023
|
Python
|
Python3
|
py
|
Accepted
| 20
|
7504
| 192
|
import math
while True:
try:
v = float(input())
t = v / 9.8
y = 4.9 * (t**2)
N = (y + 5) / 5
print(math.ceil(N))
except EOFError:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,635
|
s814284775
|
p00024
|
u252368621
|
1481342476
|
Python
|
Python3
|
py
|
Accepted
| 30
|
7468
| 190
|
import sys
import math
while(True):
try:
v=float(input())
t=v/9.8
y=4.9*t**2
N=math.ceil((y+5)/5)
print(N)
except EOFError:
sys.exit()
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,636
|
s467334317
|
p00024
|
u811733736
|
1481609268
|
Python
|
Python3
|
py
|
Accepted
| 30
|
7496
| 847
|
import sys
from math import sqrt
def calc_height(f):
""" f???????????°????????§????????¢(m) """
return 5.0 * f - 5.0
if __name__ == '__main__':
# ??????????????\?????¨???????????????
for line in sys.stdin:
req_v = float(line) # ??¬???????????????????????????????????????
# ???????????????
floor = 1 # ??¬??????????????????????????????????????°
# found = False # ??????????????°??????????????£???????????????
while True:
y = calc_height(floor)
t = sqrt(y / 4.9)
v = 9.8 * t # floor????????????????????????????????§??????????¨????
if v >= req_v:
break
floor += 1 # ???????????????????????????????????£????????§???1????????¢?????????????????????
# ???????????¨???
print(floor)
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,637
|
s466212129
|
p00024
|
u661290476
|
1482231621
|
Python
|
Python3
|
py
|
Accepted
| 20
|
7492
| 218
|
from math import sqrt
g=9.8
while True:
try:
v=float(input())
except:
break
f=2
while True:
F=f*5-5
if sqrt(2*g*F)>=v:
print(f)
break
f+=1
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,638
|
s395866420
|
p00024
|
u898097781
|
1483303902
|
Python
|
Python
|
py
|
Accepted
| 10
|
6348
| 262
|
import math
while(1):
try:
thv = float(raw_input())
except:
break
for i in range(1, 1000):
y = 5 * (i-1)
t = math.sqrt(y/4.9)
v = 9.8 * t
if v >= thv:
print i
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,639
|
s392312412
|
p00024
|
u078042885
|
1483785414
|
Python
|
Python3
|
py
|
Accepted
| 20
|
7416
| 132
|
while 1:
try:
a=4.9*((float(input())/9.8)**2)
i=0
while 5*(i-1)<a:i+=1
print(i)
except:break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,640
|
s396615677
|
p00024
|
u711765449
|
1484463842
|
Python
|
Python3
|
py
|
Accepted
| 20
|
7520
| 313
|
def experiment(v):
n = 1
k = 4.9
while True:
y = 5*n-5
v_ex = 2*4.9*(y/k)**0.5
if v_ex >= v:
return n
break
else:
n += 1
while True:
try:
v = float(input())
print(experiment(v))
except EOFError:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,641
|
s913796980
|
p00024
|
u546285759
|
1485233597
|
Python
|
Python3
|
py
|
Accepted
| 20
|
7404
| 129
|
import math
while True:
try:
mv= float(input())
except:
break
print(math.ceil((4.9*(mv/9.8)**2+5)/5))
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,642
|
s529115258
|
p00024
|
u252414452
|
1486147964
|
Python
|
Python
|
py
|
Accepted
| 10
|
6424
| 158
|
import sys
while True:
v = sys.stdin.readline()
if not v: break
t = float(v) / 9.8
y = 4.9 * t * t
n = 2
while (5*n-5) < y:
n+=1
print(n)
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,643
|
s941265143
|
p00024
|
u797673668
|
1486716958
|
Python
|
Python3
|
py
|
Accepted
| 20
|
7344
| 123
|
import sys
from math import ceil
for s in sys.stdin:
t = float(s) / 9.8
y = 4.9 * t * t
print(ceil(y / 5) + 1)
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,644
|
s806539838
|
p00024
|
u901080241
|
1488971010
|
Python
|
Python3
|
py
|
Accepted
| 30
|
7424
| 123
|
import sys
from math import ceil
for line in sys.stdin:
needh = (float(line) **2 )/ 2 / 9.8
print(ceil(needh/5)+1)
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,645
|
s676008817
|
p00024
|
u462831976
|
1492724510
|
Python
|
Python3
|
py
|
Accepted
| 20
|
7464
| 279
|
# -*- coding: utf-8 -*-
import sys
import os
import math
def min_break_floor(v):
t = v / 9.8
y = 4.9 * t * t
N = (5 + y) / 5
return math.ceil(N)
for s in sys.stdin:
break_v = float(s)
break_floor = min_break_floor(break_v)
print(break_floor)
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,646
|
s698275404
|
p00024
|
u868716420
|
1494279235
|
Python
|
Python3
|
py
|
Accepted
| 20
|
7428
| 226
|
while True :
try :
min_y = float(input())
t = min_y / 9.8
y = 4.9 * (t ** 2)
if y % 5 > 0 : N = int(y // 5 + 2)
else : N = int(y // 5 + 1)
print(N)
except : break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,647
|
s237572494
|
p00024
|
u905313459
|
1496465618
|
Python
|
Python3
|
py
|
Accepted
| 20
|
7372
| 89
|
while True:
try:
print(int(float(input())**2/98+2))
except:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,648
|
s337193880
|
p00024
|
u957840591
|
1497916875
|
Python
|
Python3
|
py
|
Accepted
| 30
|
7456
| 103
|
while True:
try:
v=float(input())
print(int(v**2/98+1)+1)
except:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,649
|
s798613604
|
p00024
|
u546285759
|
1501139712
|
Python
|
Python3
|
py
|
Accepted
| 30
|
7468
| 169
|
import math
while True:
try:
v = float(input())
except:
break
t = v / 9.8
y = 4.9 * pow(t, 2)
N = (y + 5) / 5
print(math.ceil(N))
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,650
|
s620333256
|
p00024
|
u354053070
|
1501986893
|
Python
|
Python3
|
py
|
Accepted
| 30
|
7460
| 261
|
vdata = [0.0]
for n in range(1, 411):
vdata.append((2 * 9.8 * (5 * n - 5)) ** 0.5)
while True:
try:
v = float(input())
except EOFError:
break
for n, u in enumerate(vdata):
if v < u:
print(n)
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,651
|
s032717905
|
p00024
|
u584777171
|
1503469391
|
Python
|
Python3
|
py
|
Accepted
| 20
|
7380
| 301
|
import sys
def height(i):
return 5 * i - 5
def time(v):
return v/9.8
def y(t):
return t*t*4.9
for user in sys.stdin:
h = float(user)
y1 = y(time(h))
i = 1
while True:
if y1 < height(i):
print(i)
break
else:
i += 1
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,652
|
s701900935
|
p00024
|
u957021183
|
1504777065
|
Python
|
Python3
|
py
|
Accepted
| 20
|
7496
| 303
|
# Aizu Problem 0024: Physical Experiments
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
for line in sys.stdin:
v_crack = float(line)
y = v_crack**2 * 4.9 / 9.8**2
N = y / 5 + 1
print(math.ceil(N))
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,653
|
s142170482
|
p00024
|
u548155360
|
1512400934
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5588
| 587
|
# coding=utf-8
def solve_under_stair(high: float) -> int:
one_under = int((high + 5) // 5)
return one_under + 1
def solve_need_time(velocity: float) -> float:
return velocity / 9.8
def solve_need_height(fall_time: float) -> float:
return 4.9 * fall_time * fall_time
if __name__ == '__main__':
while True:
try:
v = float(input())
except EOFError:
break
time = solve_need_time(v)
minimum_height = solve_need_height(time)
floor_number = solve_under_stair(minimum_height)
print(floor_number)
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,654
|
s636915194
|
p00024
|
u236679854
|
1512514275
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5636
| 199
|
from math import ceil
while True:
try:
v = input()
v = float(v)
t = v / 9.8
y = 4.9 * t * t
n = ceil((y+5) / 5)
print(n)
except:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,655
|
s197170170
|
p00024
|
u299798926
|
1513232319
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5640
| 171
|
import math
while(1):
try:
n=float(input())
t=n/9.8
y=4.9*t**2
N=(y+5)/5
print(math.ceil(N))
except EOFError:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,656
|
s547258810
|
p00024
|
u205327055
|
1513398272
|
Python
|
Python
|
py
|
Accepted
| 10
|
4656
| 216
|
# coding:utf-8
while True:
try:
v = float(raw_input())
t = v / 9.8
y = 4.9 * t * t
n = 1
while 5 * (n - 1) < y:
n += 1
print n
except:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,657
|
s529370093
|
p00024
|
u203261375
|
1513494720
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5632
| 162
|
from math import ceil
while True:
try:
v = float(input())
except:
break
t = v / 9.8
y = 4.9 * t * t
print(ceil((y + 5) / 5))
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,658
|
s621746778
|
p00024
|
u028347703
|
1514783101
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5632
| 231
|
import sys
import math
for line in sys.stdin:
try:
mv = float(line)
n = 2
while True:
if math.sqrt((5 * n - 5) / 4.9) * 9.8 >= mv:
print(n)
break
else:
n += 1
except:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,659
|
s353818127
|
p00024
|
u024715419
|
1515643724
|
Python
|
Python3
|
py
|
Accepted
| 30
|
5636
| 167
|
import math
while True:
try:
v = float(input())
t = v/9.8
y = 4.9*t**2
print(math.ceil((y + 5.0)/5.0))
except:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,660
|
s259239600
|
p00024
|
u764789069
|
1516201115
|
Python
|
Python
|
py
|
Accepted
| 10
|
4724
| 189
|
import math
while True:
try:
v = float(raw_input())
t = v / 9.8
y = 4.9 * t ** 2
N = math.ceil((y+5) / 5)
print int(N)
except:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,661
|
s756243105
|
p00024
|
u150984829
|
1516987262
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5644
| 87
|
import math,sys
for e in sys.stdin:
g=9.8;print(math.ceil((g/2*(float(e)/g)**2+5)/5))
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,662
|
s231126630
|
p00024
|
u150984829
|
1516987818
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5624
| 64
|
import math,sys
for e in sys.stdin:print(int(float(e)**2/98+2))
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,663
|
s209603704
|
p00024
|
u150984829
|
1516987838
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5572
| 59
|
import sys
for e in sys.stdin:print(int(float(e)**2/98+2))
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,664
|
s944249273
|
p00024
|
u553148578
|
1523606723
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5640
| 105
|
import math
while 1:
try: print(math.ceil((math.ceil(4.9*(float(input())/9.8)**2)+5)/5))
except: break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,665
|
s745744331
|
p00024
|
u166871988
|
1523781076
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5632
| 179
|
import math
h=lambda n:math.sqrt((5*n-5)/4.9)*9.8
while True:
try:v=float(input())
except:break
n=1
while True:
if h(n)>v:break
n+=1
print(n)
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,666
|
s153598505
|
p00024
|
u724548524
|
1525851318
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5632
| 88
|
import math
import sys
for e in sys.stdin:
print(math.ceil(float(e) ** 2 / 98) + 1)
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,667
|
s969718777
|
p00024
|
u724548524
|
1525851344
|
Python
|
Python3
|
py
|
Accepted
| 30
|
5648
| 85
|
import math
import sys
[print(math.ceil(float(e) ** 2 / 98) + 1) for e in sys.stdin]
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,668
|
s457649717
|
p00024
|
u043254318
|
1526481346
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5640
| 261
|
import math
def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
N = list(get_input())
for l in range(len(N)):
V = float(N[l])
ans = math.ceil((V*V/19.6 + 5.0)/5.0)
print(ans)
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,669
|
s249547391
|
p00024
|
u136916346
|
1527390266
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5652
| 99
|
import math,sys
[print(i) for i in [math.ceil(((4.9*(float(a)/9.8)**2)+5)/5) for a in sys.stdin]]
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,670
|
s765515641
|
p00024
|
u847467233
|
1528973532
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5572
| 185
|
# AOJ 0024 Physical Experiments
# Python3 2018.6.14 bal4u
while True:
try:
v = float(input())
print((int)(v**2 / 19.6) // 5 + 2)
except EOFError:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,671
|
s740576641
|
p00024
|
u724947062
|
1347285238
|
Python
|
Python
|
py
|
Accepted
| 20
|
5396
| 318
|
import sys
from math import sqrt
def calc(min_v):
min_t = min_v / 9.8
N = 2
while True:
height = 5 * N - 5
if sqrt(height / 4.9) > min_t:
return N
else:
N += 1
for line in sys.stdin.readlines():
line = line.strip()
n = float(line)
print calc(n)
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,672
|
s719019494
|
p00024
|
u460331583
|
1347543856
|
Python
|
Python
|
py
|
Accepted
| 10
|
4264
| 191
|
while True:
try:
a = float(input())
a/=9.8
b = a**2*4.9
n = (b+5)/5
if n > int(n):
print int(n+1)
elif n == int(n):
print int(n)
except EOFError: break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,673
|
s413434272
|
p00024
|
u147801965
|
1347543868
|
Python
|
Python
|
py
|
Accepted
| 10
|
4260
| 191
|
while True:
try:
a = float(input())
a/=9.8
b = a**2*4.9
n = (b+5)/5
if n > int(n):
print int(n+1)
elif n == int(n):
print int(n)
except EOFError: break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,674
|
s698523037
|
p00024
|
u647766105
|
1354695906
|
Python
|
Python
|
py
|
Accepted
| 10
|
4368
| 140
|
import sys,math
for line in sys.stdin.readlines():
try:
print int(math.ceil(float(line)**2/98)+1)
except:
pass
#temp
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,675
|
s190323726
|
p00024
|
u504990413
|
1355569125
|
Python
|
Python
|
py
|
Accepted
| 10
|
4264
| 213
|
while True:
try:
y = 4.9*(float(raw_input())/9.8)**2
dif = y
n = 0
while dif>0:
n += 1
dif = y-5*(n-1)
print n
except EOFError:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,676
|
s232602664
|
p00024
|
u419407022
|
1356120181
|
Python
|
Python
|
py
|
Accepted
| 20
|
23000
| 126
|
while True:
try:
v = float(raw_input())
except EOFError:
break
print int((((1/9.8)*v)**2)*4.9)/5+2
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,677
|
s369090352
|
p00024
|
u560838141
|
1357491797
|
Python
|
Python
|
py
|
Accepted
| 10
|
4260
| 191
|
while True:
try:
a = float(input())
a/=9.8
b = a**2*4.9
n = (b+5)/5
if n > int(n):
print int(n+1)
elif n == int(n):
print int(n)
except EOFError: break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,678
|
s370956112
|
p00024
|
u560838141
|
1357491959
|
Python
|
Python
|
py
|
Accepted
| 10
|
4264
| 191
|
while True:
try:
a = float(input())
a/=9.8
b = a**2*4.9
n = (b+5)/5
if n > int(n):
print int(n+1)
elif n == int(n):
print int(n)
except EOFError: break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,679
|
s114948976
|
p00024
|
u560838141
|
1357492513
|
Python
|
Python
|
py
|
Accepted
| 10
|
4264
| 191
|
while True:
try:
a = float(input())
a/=9.8
b = a**2*4.9
n = (b+5)/5
if n > int(n):
print int(n+1)
elif n == int(n):
print int(n)
except EOFError: break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,680
|
s222409752
|
p00024
|
u560838141
|
1357517589
|
Python
|
Python
|
py
|
Accepted
| 20
|
4264
| 191
|
while True:
try:
a = float(input())
a/=9.8
b = a**2*4.9
n = (b+5)/5
if n > int(n):
print int(n+1)
elif n == int(n):
print int(n)
except EOFError: break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,681
|
s842946230
|
p00024
|
u560838141
|
1357530996
|
Python
|
Python
|
py
|
Accepted
| 10
|
4260
| 191
|
while True:
try:
a = float(input())
a/=9.8
b = a**2*4.9
n = (b+5)/5
if n > int(n):
print int(n+1)
elif n == int(n):
print int(n)
except EOFError: break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,682
|
s346990998
|
p00024
|
u782850731
|
1362242423
|
Python
|
Python
|
py
|
Accepted
| 10
|
4408
| 345
|
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
from itertools import count
for line in stdin:
if not line.strip():
break
H = 4.9 * (float(line) / 9.8) ** 2
for N in count(1):
if H <= 5 * N - 5:
print(N)
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,683
|
s122532973
|
p00024
|
u282635979
|
1363945004
|
Python
|
Python
|
py
|
Accepted
| 20
|
4244
| 100
|
while True:
try:
v = raw_input()
y = (float(v))**2 / 19.6
print int(y/5 + 2)
except: break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,684
|
s620865145
|
p00024
|
u542421762
|
1368262002
|
Python
|
Python
|
py
|
Accepted
| 10
|
4392
| 242
|
import sys
import math
def heigh(v):
t = v / 9.8
return 4.9 * t ** 2
#input_file = open(sys.argv[1], "r")
for line in sys.stdin:
v = float(line)
h = heigh(v)
# print h
n = int(math.ceil(h / 5.0) + 1.0)
print n
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,685
|
s019458110
|
p00024
|
u865312527
|
1369061661
|
Python
|
Python
|
py
|
Accepted
| 10
|
4376
| 185
|
import sys,math
for line in sys.stdin.readlines():
V=float(line.rstrip())
N=0
while 1:
N+=1
v=9.8*math.sqrt((5*N-5)/4.9)
if V-v<=0: break
print N
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,686
|
s135765659
|
p00024
|
u350508326
|
1372458764
|
Python
|
Python
|
py
|
Accepted
| 20
|
4256
| 385
|
while True:
try:
g = 9.8
l = 4.9
v = float(raw_input())
t = v/g
y = l*(t)**2
n = y/5 + 2
print int(n)
except EOFError: break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,687
|
s570068364
|
p00024
|
u912237403
|
1378018002
|
Python
|
Python
|
py
|
Accepted
| 20
|
4368
| 167
|
import math
while True:
try:
v = input()
t = v/9.8
y = v/2*t
n = math.ceil(y/5.0)+1
print int(n)
except:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,688
|
s404012231
|
p00024
|
u813384600
|
1380541757
|
Python
|
Python
|
py
|
Accepted
| 10
|
4360
| 157
|
import math
while True:
try:
n = float(raw_input())
print int(math.ceil((n * n / (9.8 * 2) + 5) / 5))
except EOFError:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,689
|
s210258205
|
p00024
|
u523886269
|
1381543608
|
Python
|
Python
|
py
|
Accepted
| 10
|
4360
| 158
|
import math
while True:
try:
n = float(raw_input())
print int(math.ceil((n * n / (9.8 * 2) + 5) / 5))
except EOFError:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,690
|
s270214350
|
p00024
|
u523886269
|
1381543982
|
Python
|
Python
|
py
|
Accepted
| 20
|
4372
| 262
|
import sys
import math
g = 9.8
while True:
try:
s = raw_input()
vd = float(s)
#N = int(math.ceil((vd * vd / (10 * g)) + 1))
N = int(math.ceil((vd * vd / (9.8 * 2) + 5) / 5))
print N
except EOFError:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,691
|
s608845382
|
p00024
|
u523886269
|
1381544608
|
Python
|
Python
|
py
|
Accepted
| 10
|
4372
| 322
|
import sys
import math
g = 9.8
while True:
try:
s = raw_input()
vd = float(s)
#N = int(math.ceil((vd * vd / (10 * g)) + 1))
#N = int(math.ceil((vd * vd / (9.8 * 2) + 5) / 5))
N = int(math.ceil((vd * vd / (9.8 * 2) + 5) / 5))
print N
except EOFError:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,692
|
s041123343
|
p00024
|
u523886269
|
1381545232
|
Python
|
Python
|
py
|
Accepted
| 10
|
4372
| 267
|
import sys
import math
g = 9.8
while True:
try:
s = raw_input()
vd = float(s)
#N = int(math.ceil((vd * vd / (10.0 * g)) + 1.0))
N = int(math.ceil((vd * vd / (9.8 * 2) + 5) / 5))
print(N)
except EOFError:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,693
|
s598822181
|
p00024
|
u260980560
|
1384348741
|
Python
|
Python
|
py
|
Accepted
| 20
|
4224
| 89
|
while 1:
try:
print int(input()**2//98)+2
except EOFError:
break;
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,694
|
s311820645
|
p00024
|
u633068244
|
1393386862
|
Python
|
Python
|
py
|
Accepted
| 10
|
4244
| 193
|
while True:
try:
s = float(raw_input())
t = s/9.8
y = 4.9*t**2
n = 1
while 5*(n-1) < y:
n += 1
print n
except:
break
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,695
|
s298189259
|
p00024
|
u912237403
|
1394290034
|
Python
|
Python
|
py
|
Accepted
| 10
|
4352
| 119
|
import math,sys
for e in sys.stdin:
v=float(e[:-1])
t=v/9.8
y=v/2*t
n=int(math.ceil(y/5))+1
print n
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,696
|
s052663777
|
p00024
|
u912237403
|
1394290223
|
Python
|
Python
|
py
|
Accepted
| 10
|
4356
| 111
|
import math,sys
for e in sys.stdin:
v=float(e[:-1])
y=v*v/2/9.8
n=int(math.ceil(y/5))+1
print n
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,697
|
s466114747
|
p00024
|
u246033265
|
1396618719
|
Python
|
Python
|
py
|
Accepted
| 10
|
4236
| 206
|
try:
while True:
y = ((float(raw_input()) / 9.8) ** 2) * 4.9
if y == int(y):
print int((int(y) - 1) // 5) + 2
else:
print int(y // 5) + 2
except:
pass
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,698
|
s603283678
|
p00024
|
u378480414
|
1397062148
|
Python
|
Python
|
py
|
Accepted
| 10
|
4344
| 89
|
import sys,math
for v in sys.stdin:
v=float(v[:-1])
print int(math.ceil(v*v/2/9.8/5))+1
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,699
|
s698694578
|
p00024
|
u378480414
|
1397062190
|
Python
|
Python
|
py
|
Accepted
| 10
|
4364
| 90
|
import sys,math
for v in sys.stdin:
v=float(v[:-1])
print int(math.ceil(v**2/2/9.8/5))+1
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,700
|
s285337905
|
p00024
|
u378480414
|
1397062258
|
Python
|
Python
|
py
|
Accepted
| 10
|
4360
| 80
|
import sys,math
for v in sys.stdin:
print int(math.ceil(float(v)**2/2/9.8/5))+1
|
p00024
|
<script type="text/x-mathjax-config">
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});
</script>
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
<H1>Physical Experiments</H1>
<p>
Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:<br/>
<br/>
$ v = 9.8 t $<br/>
$ y = 4.9 t^2 $<br/>
</p>
<!--
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_physical"></center>
-->
<p>
A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.
</p>
<p>
You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.
</p>
<H2>Input</H2>
<p>
The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity <i>v</i> (0 < <i>v</i> < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.
</p>
<H2>Output</H2>
<p>
For each dataset, print the lowest possible floor where the ball cracks.
</p>
<H2>Sample Input</H2>
<pre>
25.4
25.4
</pre>
<H2>Output for the Sample Input</H2>
<pre>
8
8
</pre>
|
25.4
25.4
|
8
8
| 7,701
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.