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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
s873339558
|
p00014
|
u821624310
|
1502610228
|
Python
|
Python3
|
py
|
Accepted
| 30
|
7664
| 153
|
import fileinput
for x in fileinput.input():
x = int(x)
t = 600 // x
s = 0
for i in range(1, t):
s += x * (i * x)**2
print(s)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,902
|
s041841140
|
p00014
|
u584777171
|
1503069523
|
Python
|
Python3
|
py
|
Accepted
| 20
|
7600
| 185
|
import sys
for user in sys.stdin:
d = int(user)
S = 0
max = int(600/d)
for i in range(1, max):
# f(id) = (id) ** 2
S += d * ((i * d) ** 2)
print(S)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,903
|
s562559797
|
p00014
|
u957021183
|
1504764653
|
Python
|
Python3
|
py
|
Accepted
| 30
|
7728
| 379
|
# Aizu Problem 0014: Integral
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
def f(x):
return x**2
def integral(d):
s = 0
dd = d
while dd <= 600 - d:
s += d * f(dd)
dd += d
return s
for line in sys.stdin:
d = int(line)
print(integral(d))
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,904
|
s584274198
|
p00014
|
u299798926
|
1505962200
|
Python
|
Python3
|
py
|
Accepted
| 30
|
7680
| 222
|
import math
while 1:
try:
d=int(input())
time=600//d
S=0
for i in range(time):
x=i*d
y=x**2
S+=y*d
print(S)
except EOFError:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,905
|
s195842412
|
p00014
|
u197615397
|
1506224460
|
Python
|
Python3
|
py
|
Accepted
| 50
|
7616
| 138
|
import sys
for l in sys.stdin:
d = int(l)
result = 0
for x in range(d, 600-d+1, d):
result += d*x**2
print(result)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,906
|
s314782695
|
p00014
|
u546285759
|
1506326106
|
Python
|
Python3
|
py
|
Accepted
| 50
|
7772
| 154
|
def f(x):
return pow(x, 2)
while True:
try:
d = int(input())
except:
break
print(sum(f(x) * d for x in range(d, 600, d)))
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,907
|
s921676684
|
p00014
|
u917432951
|
1511334792
|
Python
|
Python3
|
py
|
Accepted
| 50
|
7628
| 245
|
import sys
def calcIntegral(d:int)->float:
result = 0
for x in range(0,600,d):
result += d*x**2
return result
if __name__ == '__main__':
for tmpLine in sys.stdin:
d = int(tmpLine)
print(calcIntegral(d))
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,908
|
s866896829
|
p00014
|
u424041287
|
1512108253
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5604
| 155
|
t = 0
while t == 0:
try:
d = int(input())
except:
break
else:
print(sum(d * ((i * d) ** 2) for i in range(int(600/d))))
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,909
|
s785863032
|
p00014
|
u548155360
|
1512397676
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5592
| 303
|
# coding=utf-8
def square(number: float) -> float:
return number * number
if __name__ == '__main__':
while True:
s = 0
try:
d = int(input())
except EOFError:
break
for i in range(600//d):
s += square(i*d)*d
print(s)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,910
|
s970722381
|
p00014
|
u471400255
|
1514305770
|
Python
|
Python3
|
py
|
Accepted
| 30
|
5588
| 159
|
from sys import stdin
f = lambda x:x**2
for line in stdin:
S = 0
d = int(line)
for i in range(int(600/d)):
S += f(d*i)*d
print(S)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,911
|
s493190449
|
p00014
|
u028347703
|
1514565415
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5596
| 179
|
import sys
for line in sys.stdin:
try:
d = int(line)
result = 0
f = d
while f < 600:
result += f**2 * d
f += d
print(result)
except:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,912
|
s285505690
|
p00014
|
u024715419
|
1515132044
|
Python
|
Python3
|
py
|
Accepted
| 30
|
5584
| 163
|
while True:
try:
d = int(input())
s = 0
for i in range(0, 600, d):
s += d*i**2
print(s)
except:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,913
|
s228172387
|
p00014
|
u764789069
|
1515169494
|
Python
|
Python
|
py
|
Accepted
| 0
|
4644
| 230
|
def f(x):
return x ** 2
while True:
try:
d = int(raw_input())
sum = 0
for i in range(0, 600, d):
#print i,d, sum
sum += f(i) * d
print sum
except:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,914
|
s735280438
|
p00014
|
u846136461
|
1516238927
|
Python
|
Python
|
py
|
Accepted
| 10
|
4648
| 179
|
# coding: utf-8
def f(x):
return x**2
while True:
try:
d = int(raw_input())
sum = 0
for i in range(1,600/d):
sum += f(i*d) * d
print(sum)
except EOFError:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,915
|
s804825868
|
p00014
|
u546285759
|
1516336964
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5592
| 124
|
while True:
try:
d = int(input())
except:
break
print(sum(d * x**2 for x in range(d, 600, d)))
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,916
|
s613466391
|
p00014
|
u043254318
|
1516464350
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5592
| 344
|
def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
def f(x):
return x*x
N = list(get_input())
for l in range(len(N)):
d = int(N[l])
n = int(600 / d)
S = 0
for i in range(n-1):
#print(d+d*i, f(d+d*i))
S = S + d*f(d+d*i)
print(S)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,917
|
s541742450
|
p00014
|
u150984829
|
1516902554
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5608
| 83
|
import sys
for d in map(int,sys.stdin):print(sum([i*i*d for i in range(d,600,d)]))
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,918
|
s776119156
|
p00014
|
u401720175
|
1519555482
|
Python
|
Python
|
py
|
Accepted
| 10
|
4652
| 199
|
# coding: utf-8
import sys
for line in sys.stdin:
d = int(line)
x = 0
surface = 0
for _ in range(int(600 / d) - 1):
x += d
surface += d * (x ** 2)
print(surface)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,919
|
s044907483
|
p00014
|
u553148578
|
1523585134
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5604
| 99
|
while True:
try: d = int(input())
except: break
print(sum([(i*d)**2*d for i in range(600//d)]))
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,920
|
s335342432
|
p00014
|
u166871988
|
1523716223
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5588
| 149
|
f=lambda x:x**2
while True:
try:d=int(input())
except:break
t=[]
for i in range(600//d):
t.append(d*f(d*i))
print(sum(t))
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,921
|
s091712051
|
p00014
|
u352394527
|
1523861489
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5584
| 142
|
while True:
try:
d = int(input())
s = 0
for i in range(d,600,d):
s += d * i * i
print(s)
except EOFError:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,922
|
s595064278
|
p00014
|
u724548524
|
1525746367
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5604
| 98
|
import sys
[print(sum([i ** 2 for i in range(int(e), 600, int(e))]) * int(e)) for e in sys.stdin]
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,923
|
s529972226
|
p00014
|
u536280367
|
1526111888
|
Python
|
Python3
|
py
|
Accepted
| 30
|
5596
| 230
|
import sys
a, b = 0, 600
def f(x):
return x ** 2
if __name__ == '__main__':
for line in sys.stdin:
d = int(line)
sum = 0
for i in range(a, b, d):
sum += d * f(i)
print(sum)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,924
|
s579426878
|
p00014
|
u136916346
|
1527361066
|
Python
|
Python3
|
py
|
Accepted
| 30
|
5608
| 127
|
import sys
S=lambda s:sum([((i*s)**2)*s for i in range(int(600/s))])
[print(i) for i in [S(int(line)) for line in sys.stdin]]
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,925
|
s789367609
|
p00014
|
u847467233
|
1528578888
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5592
| 226
|
# AOJ 0014 Integral
# Python3 2018.6.10 bal4u
while True:
try:
d = int(input())
sum = 0
for x in range(d, 600, d):
sum += d * x**2
print(sum)
except EOFError:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,926
|
s694763452
|
p00014
|
u847467233
|
1528579732
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5604
| 145
|
# AOJ 0014 Integral
# Python3 2018.6.10 bal4u
import sys
for d in sys.stdin:
a = int(d)
print(sum(a * x**2 for x in range(a, 600, a)))
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,927
|
s451791497
|
p00014
|
u724947062
|
1346958878
|
Python
|
Python
|
py
|
Accepted
| 10
|
4212
| 226
|
import sys
def calc(N):
tmp = 0
cur = 0
while cur < 600:
tmp += cur ** 2 * N
cur += N
return tmp
for line in sys.stdin.readlines():
line = line.strip()
N = int(line)
print calc(N)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,928
|
s341684639
|
p00014
|
u719737030
|
1351127441
|
Python
|
Python
|
py
|
Accepted
| 20
|
4212
| 142
|
import sys
total=0
for i in sys.stdin.readlines():
total=0
d=int(i)
for c in range(0,600,d):
total+=d*c**2
print total
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,929
|
s199576125
|
p00014
|
u647766105
|
1351612338
|
Python
|
Python
|
py
|
Accepted
| 10
|
4216
| 97
|
import sys
for i in sys.stdin:
d=int(i)
print sum([x**2*d for x in xrange(0,600,d)])
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,930
|
s394150667
|
p00014
|
u779627195
|
1352551966
|
Python
|
Python
|
py
|
Accepted
| 10
|
5440
| 298
|
def f(x):
return x**2
while 1:
try:
d0 = raw_input()
if d0 == '':
break
area = []
d = int(d0)
for i in range(d, 600, d):
area.append(d*f(i))
Sumpoyo = sum(area)
print Sumpoyo
except EOFError:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,931
|
s888491530
|
p00014
|
u504990413
|
1353075175
|
Python
|
Python
|
py
|
Accepted
| 10
|
4212
| 173
|
while True:
try:
d = input()
sum = 0
for x in range(0,600,d):
sum = sum + d*x**2
print sum
except EOFError:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,932
|
s079269336
|
p00014
|
u735362704
|
1355239310
|
Python
|
Python
|
py
|
Accepted
| 10
|
4220
| 354
|
#!/usr/bin/env python
# coding: utf-8
f = lambda x: x ** 2
def calc_area(d):
area = 0
for i in xrange(1, 600 / d):
area += f(d * i) * d
return area
def main():
while 1:
try:
d = int(raw_input())
except EOFError:
return
print calc_area(d)
if __name__ == '__main__':
main()
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,933
|
s609823069
|
p00014
|
u280179677
|
1355410169
|
Python
|
Python
|
py
|
Accepted
| 10
|
5224
| 212
|
def datasets():
import sys
while True:
s = sys.stdin.readline()
if len(s) < 2:
break
yield int(s)
for n in datasets():
print sum([x*x*n for x in range(n, 600, n)])
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,934
|
s814468235
|
p00014
|
u419407022
|
1356040763
|
Python
|
Python
|
py
|
Accepted
| 10
|
4344
| 223
|
while True:
try:
d = int(raw_input())
except EOFError:
break
if d == 600:
print 0
else:
rects = map(lambda x:d*x*x,range(d, 600, d))
print reduce(lambda x,y:x+y,rects)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,935
|
s255437356
|
p00014
|
u126791750
|
1357123473
|
Python
|
Python
|
py
|
Accepted
| 10
|
4212
| 129
|
while True:
try:
d = int(raw_input())
s = 0
for i in range(d,600,d):
s += i**2 * d
print(s)
except EOFError:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,936
|
s525043505
|
p00014
|
u782850731
|
1362069834
|
Python
|
Python
|
py
|
Accepted
| 20
|
4212
| 266
|
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
for line in stdin:
if not line.strip():
continue
d = int(line)
print(sum(d * nd ** 2 for nd in xrange(0, 600, d)))
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,937
|
s673520595
|
p00014
|
u743065194
|
1363880570
|
Python
|
Python
|
py
|
Accepted
| 10
|
4228
| 96
|
import sys
for l in sys.stdin:
d=int(l)
print(d*sum(map(lambda x:x**2,range(0,600,d))))
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,938
|
s299351168
|
p00014
|
u282635979
|
1363939700
|
Python
|
Python
|
py
|
Accepted
| 20
|
4216
| 155
|
while True:
try:
d = raw_input()
size = 0
d = int(d)
fd = d
for x in range(1,600/d):
size += d*(fd**2)
fd += d
print size
except: break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,939
|
s902655781
|
p00014
|
u542421762
|
1368178917
|
Python
|
Python
|
py
|
Accepted
| 10
|
4340
| 308
|
import sys
def integral(x, d):
ds = range(d, x, d)
ds2 = map((lambda a: a**2 * d), ds)
ds3 = reduce((lambda b, c: b + c), ds2, 0)
return ds3
#input_file = open(sys.argv[1], "r")
#for line in input_file:
for line in sys.stdin:
d = int(line)
area = integral(600, d)
print area
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,940
|
s760718384
|
p00014
|
u350508326
|
1368348628
|
Python
|
Python
|
py
|
Accepted
| 10
|
4220
| 248
|
def fx(x):
return x*x
while True:
try:
d = int(raw_input())
b = 600 / d
su = 0
i = 0
while b > 0:
b -= 1
su += fx(b*d)*d
print su
except EOFError:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,941
|
s409310544
|
p00014
|
u912237403
|
1377416282
|
Python
|
Python
|
py
|
Accepted
| 20
|
4212
| 155
|
while True:
try:
n = input()
s=0
for i in range(n, 600, n):
s += i**2 * n
print s
except:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,942
|
s132793454
|
p00014
|
u813384600
|
1379496448
|
Python
|
Python
|
py
|
Accepted
| 20
|
4212
| 176
|
while True:
try:
d = int(raw_input())
r = 0
for i in range(d, 600, d):
r += i * i * d
print r
except EOFError:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,943
|
s292522060
|
p00014
|
u523886269
|
1381060093
|
Python
|
Python
|
py
|
Accepted
| 20
|
4220
| 252
|
#! /usr/bin/python
import sys
def main():
for input in sys.stdin:
dx = int(input)
area = integral(dx)
print(area)
def integral(dx):
x = 0
area = 0
while x < 600:
area += f(x) * dx
x += dx
return area;
def f(x):
return x * x
main()
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,944
|
s960245357
|
p00014
|
u511257811
|
1382281517
|
Python
|
Python
|
py
|
Accepted
| 10
|
4184
| 155
|
import sys
for line in sys.stdin:
result = 0
d = int(line)
x = d
while x < 600:
result += x**2 * d
x += d
print result
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,945
|
s830740683
|
p00014
|
u351182591
|
1383586036
|
Python
|
Python
|
py
|
Accepted
| 10
|
4184
| 149
|
while 1:
s = f = 0
try:
d = input()
except:
break
while f < 600:
s += (f ** 2) * d
f += d
print s
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,946
|
s123400013
|
p00014
|
u230836528
|
1392286645
|
Python
|
Python
|
py
|
Accepted
| 20
|
4204
| 410
|
# -*- coding: utf-8 -*-
import sys
def f(x):
return x*x
lineNumber = 0
#for line in [ "20", "10" ]:
for line in sys.stdin.readlines():
lineNumber += 1
# except line
if lineNumber == 1:
cars = []
# get data
List = map(int, line.strip().split())
# program
d = List[0]
x = 0
ans = 0
while x < 600:
ans += f(x) * d
x += d
print ans
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,947
|
s882430281
|
p00014
|
u633068244
|
1393361147
|
Python
|
Python
|
py
|
Accepted
| 10
|
4192
| 212
|
while True:
try:
wid = int(raw_input())
r = 600 // wid
integral = 0
for i in range(1,r):
integral += wid*(wid*i)**2
print integral
except:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,948
|
s716902011
|
p00014
|
u124909914
|
1393482596
|
Python
|
Python
|
py
|
Accepted
| 10
|
4188
| 173
|
while True:
try:
sum = 0
d = input()
for i in range(d, 600, d):
sum += d * i * i
print sum
except EOFError:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,949
|
s705205078
|
p00014
|
u912237403
|
1393763506
|
Python
|
Python
|
py
|
Accepted
| 20
|
4216
| 90
|
import sys
for n in map(int,sys.stdin):
s=sum([i*i for i in range(n,600,n)])*n
print s
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,950
|
s535469350
|
p00014
|
u912237403
|
1393763656
|
Python
|
Python
|
py
|
Accepted
| 10
|
4188
| 91
|
import sys
for n in map(int,sys.stdin):
s=0
for i in range(n,600,n): s+=i*i
print s*n
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,951
|
s721769503
|
p00014
|
u858885710
|
1393929128
|
Python
|
Python
|
py
|
Accepted
| 10
|
4212
| 85
|
import sys
for d in map(int, sys.stdin):
print sum([d*x*x for x in range(d,600,d)])
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,952
|
s248753871
|
p00014
|
u193025715
|
1395977316
|
Python
|
Python
|
py
|
Accepted
| 10
|
4192
| 121
|
while True:
try:
d = input()
area = 0
for i in range(0,600,d):
area += d * (i**2)
print area
except:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,953
|
s798145305
|
p00014
|
u491763171
|
1396395568
|
Python
|
Python
|
py
|
Accepted
| 20
|
4200
| 187
|
L = []
while 1:
try:
d = input()
x = 600
ret = 0
for i in range(0, 600, d):
ret += d * (i ** 2)
print ret
except:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,954
|
s745969824
|
p00014
|
u491763171
|
1396395642
|
Python
|
Python
|
py
|
Accepted
| 10
|
4200
| 121
|
while 1:
try:
d = input()
print sum(d * (i ** 2) for i in range(0, 600, d))
except:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,955
|
s477841480
|
p00014
|
u491763171
|
1396395735
|
Python
|
Python
|
py
|
Accepted
| 10
|
4200
| 94
|
import sys
for d in map(int, sys.stdin):
print sum(d * (i ** 2) for i in range(0, 600, d))
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,956
|
s390854615
|
p00014
|
u246033265
|
1396613633
|
Python
|
Python
|
py
|
Accepted
| 10
|
4188
| 164
|
try:
while True:
d = int(raw_input())
sm = 0
for i in range(d, 600, d):
sm += (i ** 2) * d
print sm
except:
pass
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,957
|
s670176072
|
p00014
|
u708217907
|
1398208800
|
Python
|
Python
|
py
|
Accepted
| 10
|
4204
| 212
|
import sys
def drange(start, stop, step):
r = start
while r <= stop:
yield r
r += step
for s in sys.stdin:
d = int(s)
sum = 0
for x in drange(d, 600, d):
sum += (x-d)**2*d
print '%d'%sum
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,958
|
s739202428
|
p00014
|
u708217907
|
1398209013
|
Python
|
Python
|
py
|
Accepted
| 10
|
4188
| 111
|
import sys
for d in map(int,sys.stdin):
sum = 0
for x in range(d, 600, d): sum += x**2
print '%d'%(sum*d)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,959
|
s237406768
|
p00014
|
u747479790
|
1398265040
|
Python
|
Python
|
py
|
Accepted
| 10
|
4196
| 121
|
while True:
try:
d = input()
area = 0
for i in range(0,600,d):
area += d * (i**2)
print area
except:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,960
|
s567615381
|
p00014
|
u436634575
|
1401133683
|
Python
|
Python3
|
py
|
Accepted
| 30
|
6716
| 140
|
while True:
try:
d = int(input())
except:
break
area = d * sum(x * x for x in range(0, 600, d))
print(area)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,961
|
s595133325
|
p00014
|
u442912414
|
1597759029
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5592
| 166
|
while True:
try:
ans=0
a=int(input())
for i in range(1,600//a):
ans+=(i*a)**2*a
print(ans)
except:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,962
|
s430596459
|
p00014
|
u320921262
|
1597756863
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5584
| 172
|
while True:
try:
d = int(input())
S = 0
for i in range(d,600,d):
S += d * i * i
print(S)
except EOFError:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,963
|
s033864545
|
p00014
|
u350481745
|
1597741714
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5588
| 157
|
while True:
try:
d=int(input())
S=0
for i in range(600//d):
S+=(i*d)**2*d
print(S)
except:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,964
|
s606861264
|
p00014
|
u371026526
|
1597738592
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5592
| 133
|
while True:
try:
d = int(input())
ans = 0
for i in range(d,600,d):
ans += i*i*d
print(ans)
except: break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,965
|
s122233890
|
p00014
|
u799752967
|
1597725055
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5588
| 197
|
# coding: utf-8
# Your code here!
while True:
try:
d=int(input())
s=0
for i in range(d,600,d):
s+=d*i*i
print(s)
except EOFError:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,966
|
s568351251
|
p00014
|
u976648183
|
1597669841
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5588
| 201
|
def f(x):
return x*x
while True:
try:
d=int(input())
x=600//d
s=0
for i in range(x):
s+=d*f(i*d)
print(s)
except EOFError:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,967
|
s086317590
|
p00014
|
u931484744
|
1597667592
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5600
| 217
|
# coding: utf-8
# Your code here!
while True:
try:
d = int(input())
ans = 0
for i in range(1, 600 // d):
ans = ans + ((i * d) ** 2) * d
print(ans)
except EOFError:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,968
|
s882030122
|
p00014
|
u257570657
|
1597651956
|
Python
|
Python3
|
py
|
Accepted
| 30
|
5596
| 176
|
while True:
a=0
try:
d=int(input())
except EOFError:
break
count=1
for i in range(0,600,d):
a+=i**2*d
count+=1
print(a)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,969
|
s474004365
|
p00014
|
u593595530
|
1597637478
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5592
| 226
|
def process() :
d = int(input())
S = 0
n = 600 / d
for i in range(1,int(n)) :
S += (i * d * i * d) * d
print(S)
while True :
try :
process()
except EOFError :
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,970
|
s514255700
|
p00014
|
u991830357
|
1597531464
|
Python
|
Python3
|
py
|
Accepted
| 30
|
5588
| 208
|
while True:
try:
d=int(input())
i=1
k=0
while i*d<(600-d+1):
l=(i*d)**2
k+=l*d
i+=1
print(k)
except EOFError:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,971
|
s450961647
|
p00014
|
u512192552
|
1597502948
|
Python
|
Python3
|
py
|
Accepted
| 30
|
5592
| 225
|
# coding: utf-8
# Your code here!
def seki(x):
a=[]
for i in range(600//x):
a.append((i*x)**2*x)
print(sum(a))
while 1:
try:
n=int(input())
except EOFError:
break
seki(n)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,972
|
s395968007
|
p00014
|
u397004753
|
1597502052
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5588
| 136
|
while True:
try:
d = int(input())
except EOFError:
break
s = 0
for i in range(600//d):
s += d*(i*d)**2
print(s)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,973
|
s872568243
|
p00014
|
u140569607
|
1597411130
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5584
| 186
|
while True:
try:
d = int(input())
S = 0
l = 600 // d
for i in range(l):
S += d * d * i * d * i
print(S)
except:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,974
|
s749140413
|
p00014
|
u919773430
|
1597404731
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5588
| 123
|
while True:
try:
d = int(input())
except:
break
print(sum(d * x**2 for x in range(d, 600, d)))
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,975
|
s850834695
|
p00014
|
u189528630
|
1597070075
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5588
| 133
|
for line in open(0).readlines():
d = int(line)
ans = 0
for x in range(0, 600, d):
ans += x*x
print(ans * d)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,976
|
s223792391
|
p00014
|
u596129030
|
1596869502
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5592
| 241
|
list=[]
try:
while True:
list.append(int(input()))
except EOFError:
pass
for i in range(len(list)):
s=0
for k in range(0,int(600/list[i])):
s=s+(list[i]*k)**2
print(s*list[i])
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,977
|
s198572771
|
p00014
|
u053015104
|
1596819560
|
Python
|
Python3
|
py
|
Accepted
| 30
|
5588
| 258
|
#縦の長さx^2、横の長さ0~600
#for文で600までi-dで回す、たす
while(1):
try:
d = int(input())
except:
break
sum = 0
for i in range(600//d):
y = (i*d)**2
s = y*d
sum += s
print(sum)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,978
|
s851776960
|
p00014
|
u695386605
|
1596789323
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5592
| 246
|
while True:
try:
d = int(input())
x = 600 // d
s = 0
i = 1
for i in range(x):
D = (i * d)**2
s= D * d + s
i = i + 1
print(s)
except:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,979
|
s727820509
|
p00014
|
u413704014
|
1596688956
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5596
| 195
|
# 82
while True:
try:
q = round(600 / int(input()))
except:
break
S = 0
for i in range(1, q):
S += (i * 600 / q) ** 2 * 600 / q
print(round(S))
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,980
|
s633114492
|
p00014
|
u309196579
|
1596640700
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5592
| 123
|
while True:
try:
d = int(input())
except:
break
print(sum(d * x**2 for x in range(d, 600, d)))
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,981
|
s342552404
|
p00014
|
u874049078
|
1596565767
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5592
| 192
|
#82 数値積分
while True:
try:
d = int(input())
except:
break
ans = 0
x = d
while x<600:
ans += (x ** 2) * d
x += d
print(ans)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,982
|
s316331324
|
p00014
|
u251716708
|
1596545542
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5592
| 255
|
while 1:
try:
d=int(input())
a=0
b=d
for i in range(1,(600//d)):
h=b*b
s=d*h
b+=d
a+=s
print(a)
except EOFError:
#print(a)
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,983
|
s949088392
|
p00014
|
u221550784
|
1596501045
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5592
| 201
|
def f(x):
return x*x
while True:
try:
d=int(input())
x=600//d
s=0
for i in range(x):
s+=d*f(i*d)
print(s)
except EOFError:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,984
|
s925251305
|
p00014
|
u677563181
|
1596460804
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5596
| 127
|
import sys
for line in sys.stdin:
n, d = 0, int(line)
for i in range(d, 600, d):
n += d * i ** 2
print(n)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,985
|
s508677818
|
p00014
|
u986283797
|
1596443432
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5656
| 220
|
# -*- coding: utf-8 -*-
import math
errerN=1
while errerN:
try:
volume=0
a=int(input())
for x in range(0,600,a):
volume+=x*x*a
print(volume)
except :
errerN=0
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,986
|
s535344003
|
p00014
|
u635020217
|
1596433390
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5592
| 160
|
# coding: utf-8
# Your code here!
import sys
for i in sys.stdin:
n = 0
m = int(i)
for j in range(m, 600, m):
n += m * j ** 2
print(n)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,987
|
s969188164
|
p00014
|
u826807985
|
1596432446
|
Python
|
Python3
|
py
|
Accepted
| 30
|
5592
| 213
|
try:
while True:
d = int(input())
s = 0
for i in range(600//d):
tate = (i*d)**2
yoko = d
s += tate * yoko
print(s)
except EOFError:
pass
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,988
|
s579865326
|
p00014
|
u272062354
|
1596088753
|
Python
|
Python3
|
py
|
Accepted
| 30
|
5592
| 186
|
try:
while True:
d=int(input())
a=[]
for i in range(0,600,d):
s=d*(i**2)
a.append(s)
print(sum(a))
except EOFError:
pass
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,989
|
s861874393
|
p00014
|
u586171604
|
1595827633
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5592
| 127
|
import sys
for line in sys.stdin:
n, d = 0, int(line)
for i in range(d, 600, d):
n += d * i ** 2
print(n)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,990
|
s914045725
|
p00014
|
u470391435
|
1595826109
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5588
| 178
|
def seki(x):
a=[]
for i in range(600//x):
a.append((i*x)**2*x)
print(sum(a))
while 1:
try:
n = int(input())
except:
break
seki(n)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,991
|
s674062381
|
p00014
|
u633358233
|
1595818503
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5592
| 169
|
while True :
try :
d = int(input())
except EOFError :
break
S = 0
for i in range(600//d) :
S += (i * d)**2 * d
print(S)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,992
|
s030137327
|
p00014
|
u711365732
|
1595817832
|
Python
|
Python3
|
py
|
Accepted
| 30
|
5588
| 208
|
try:
while True:
d = int(input())
S = 0
if d=='':
break
for i in range(1, (600-d)//d+1):
s = (d * i)**2 *d
S += s
print(S)
except EOFError:
pass
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,993
|
s174951315
|
p00014
|
u555228137
|
1595715679
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5592
| 165
|
while True:
try:
d=int(input())
s=0
for i in range(600//d):
s+=(i*d)**2*d
print(s)
except EOFError:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,994
|
s179375212
|
p00014
|
u926092389
|
1595554484
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5588
| 159
|
while True:
try:
s=0
d=int(input())
for i in range(1,600//d):
s+=(i*d)**2*d
print(s)
except:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,995
|
s858350803
|
p00014
|
u630948380
|
1595512396
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5592
| 220
|
try:
while True:
A=0
d=int(input())
a=600//d
for i in range(a):
A+=((i*d)**2)*d
print(A)
except EOFError:
pass
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,996
|
s238120167
|
p00014
|
u705625724
|
1595390792
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5592
| 206
|
# coding: utf-8
# 82
while True:
m=0
try:
d=int(input())
D=d
except:
break
k=int(600/d)
for i in range(1,k):
D=i*d
m += d*D**2
print(m)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,997
|
s967347334
|
p00014
|
u173393391
|
1595230875
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5588
| 173
|
while True:
try:
d=int(input())
sum=0
for i in range(0,600,d):
sum+=i**2*d
print(sum)
except:
break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,998
|
s909091195
|
p00014
|
u753534330
|
1594741328
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5592
| 284
|
for j in range(20):
try:
d = int(input())
size = 0
for i in range(600//d - 1):
#print(i, i*d, (i*d)**2, d, size)
i += 1
size += ((i*d)**2) *d
print(int(size))
except: break
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 5,999
|
s684549577
|
p00014
|
u192469946
|
1594631319
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5592
| 146
|
while True:
try:
d = int(input())
except:
break
x = 0
for i in range(d,600,d):
x += d*(i**2)
print(x)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 6,000
|
s760007677
|
p00014
|
u895962529
|
1594524478
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5588
| 108
|
import sys
for d in map(int, sys.stdin):
a=0
for i in range(0,600,d):
a+=i*i
print(a*d)
|
p00014
|
<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>Integral</H1>
<p>
Write a program which computes the area of a shape represented by the following three lines:<br/>
<br/>
$y = x^2$<br/>
$y = 0$<br/>
$x = 600$<br/>
<br/>
<!--<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF1"></center>-->
</p>
<p>
It is clear that the area is $72000000$, if you use an integral you learn in high school. On the other hand, we can obtain an approximative area of the shape by adding up areas of many rectangles in the shape as shown in the following figure:
</p>
<center><img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integral"><br/>
$f(x) = x^2$<br/>
<br/>
</center>
<!--
<center>
<img src="https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_integralF2">
</center>
-->
<p>
The approximative area $s$ where the width of the rectangles is $d$ is:<br/>
<br/>
area of rectangle where its width is $d$ and height is $f(d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(2d)$ $+$ <br/>
area of rectangle where its width is $d$ and height is $f(3d)$ $+$ <br/>
...<br/>
area of rectangle where its width is $d$ and height is $f(600 - d)$ <br/>
</p>
<p>
The more we decrease $d$, the higer-precision value which is close to $72000000$ we could obtain. Your program should read the integer $d$ which is a divisor of $600$, and print the area $s$.
</p>
<H2>Input</H2>
<p>
The input consists of several datasets. Each dataset consists of an integer $d$ in a line. The number of datasets is less than or equal to 20.
</p>
<H2>Output</H2>
<p>
For each dataset, print the area $s$ in a line.
</p>
<H2>Sample Input</H2>
<pre>
20
10
</pre>
<H2>Output for the Sample Input</H2>
<pre>
68440000
70210000
</pre>
|
20
10
|
68440000
70210000
| 6,001
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.