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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
s574470420 | p00014 | u350963229 | 1594307324 | Python | Python3 | py | Accepted | 20 | 5592 | 176 | while(1):
try:
d = int(input())
except:
break
s = 0
w = d
while d < 600:
h = d * d
s += h * w
d += w
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 com... | 20
10
| 68440000
70210000
| 6,002 |
s944589004 | p00014 | u583329397 | 1594012287 | Python | Python3 | py | Accepted | 20 | 5584 | 162 | 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 com... | 20
10
| 68440000
70210000
| 6,003 |
s911850717 | p00014 | u647921435 | 1593476111 | Python | Python3 | py | Accepted | 30 | 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 com... | 20
10
| 68440000
70210000
| 6,004 |
s206789460 | p00014 | u187074069 | 1593270901 | Python | Python3 | py | Accepted | 20 | 5592 | 201 | while True:
try:
n = int(input())
d = n
S = 0
while d < 600:
S = S + d**2 * n
d = d + n
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 com... | 20
10
| 68440000
70210000
| 6,005 |
s443812008 | p00014 | u128671689 | 1592810838 | Python | Python3 | py | Accepted | 20 | 5588 | 191 | while True:
try:
d=int(input())
z=0
for i in range(1,600//d):
x=d
y=(i*d)**2
z+=x*y
print(z)
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 com... | 20
10
| 68440000
70210000
| 6,006 |
s871483325 | p00014 | u228556128 | 1592313267 | Python | Python3 | py | Accepted | 20 | 5588 | 155 | while True:
try:
d=int(input())
except:
break
x=(600//d)
s=0
for i in range(1,x):
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 com... | 20
10
| 68440000
70210000
| 6,007 |
s978084973 | p00014 | u395654950 | 1592197054 | Python | Python3 | py | Accepted | 20 | 5596 | 218 | # 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 com... | 20
10
| 68440000
70210000
| 6,008 |
s099832009 | p00014 | u994684803 | 1591594704 | Python | Python3 | py | Accepted | 20 | 5592 | 178 | while True:
try:
d = int(input())
except:
break
ans = 0
for i in range(d,600,d):
ans += d*i**2
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 com... | 20
10
| 68440000
70210000
| 6,009 |
s910119513 | p00014 | u240091169 | 1590974025 | Python | Python3 | py | Accepted | 30 | 5588 | 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 com... | 20
10
| 68440000
70210000
| 6,010 |
s050133501 | p00014 | u747915832 | 1590220677 | Python | Python3 | py | Accepted | 30 | 5588 | 214 | while True:
try:
d = int(input())
except:
break
n = int(600/d)
S = 0
for i in range(1,n,1):
s = d*((i*d)**2)
S += s
print(S)
continue
| 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 com... | 20
10
| 68440000
70210000
| 6,011 |
s361440392 | p00014 | u814278309 | 1589888281 | Python | Python3 | py | Accepted | 20 | 5592 | 166 | while True:
try:
d = int(input())
except:
break
c = 0
x = d
while x < 600:
c += (x ** 2) * d
x += d
print(c)
| 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 com... | 20
10
| 68440000
70210000
| 6,012 |
s524015481 | p00014 | u037441960 | 1589013279 | Python | Python3 | py | Accepted | 20 | 5592 | 257 | while True :
try :
d = int(input())
l = 600 // d
D = []
for i in range(l - 1) :
D.append(((len(D) + 1) ** 2) * d ** 3)
print(sum(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 com... | 20
10
| 68440000
70210000
| 6,013 |
s642005738 | p00014 | u014861569 | 1588962780 | Python | Python3 | py | Accepted | 30 | 5588 | 195 | for i in range(1,21):
try:
s=0
n=int(input())
for j in range(n,600-n+1,n):
d=n*(j**2)
s+=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 com... | 20
10
| 68440000
70210000
| 6,014 |
s670281458 | p00014 | u260980560 | 1588730143 | Python | Python3 | py | Accepted | 20 | 5584 | 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 com... | 20
10
| 68440000
70210000
| 6,015 |
s245449987 | p00014 | u713674793 | 1586771913 | Python | Python3 | py | Accepted | 20 | 5592 | 349 | ans_l = []
while True:
try:
d = int(input())
x_coordinate = -d
def height(x_coordinate):
return x_coordinate**2
ans = 0
for i in range(600//d):
x_coordinate += d
ans += d * height(x_coordinate)
ans_l.append(ans)
except:
... | 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 com... | 20
10
| 68440000
70210000
| 6,016 |
s562106724 | p00014 | u374434600 | 1586627690 | Python | Python3 | py | Accepted | 20 | 5656 | 328 | import sys
import math
def area(d,sum1,i):
while i<=((600//d)-1):
sum1=sum1+d*i*i*d*d
i=i+1
return sum1
try:
while True:
d=int(input())
sum0=0 # 初期設定
i=1 # 初期設定
area_new=area(d,sum0,i)
print(round(area_new))
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 com... | 20
10
| 68440000
70210000
| 6,017 |
s801535620 | p00014 | u490578380 | 1584697409 | Python | Python3 | py | Accepted | 20 | 5588 | 199 | X = 600
while True:
try:
d = int(input())
result = 0
for i in range(d, X, d):
result += (i * i) * d
print(result)
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 com... | 20
10
| 68440000
70210000
| 6,018 |
s352225807 | p00014 | u808372529 | 1583830814 | Python | Python3 | py | Accepted | 20 | 5596 | 165 | while True:
try:
d = int(input())
s = 0
for i in range(d,600,d):
s = 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 com... | 20
10
| 68440000
70210000
| 6,019 |
s595346428 | p00014 | u630911389 | 1577928351 | Python | Python3 | py | Accepted | 20 | 5588 | 137 | while 1:
try:
d = int(input())
except:break
s = 0
for i in range(d,600,d):
s += d * (i * 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 com... | 20
10
| 68440000
70210000
| 6,020 |
s921281646 | p00014 | u350155409 | 1572346122 | Python | Python3 | py | Accepted | 20 | 5596 | 170 | import sys
MAX_X = 600
for dstr in sys.stdin:
d = int(dstr)
x = 600//d
area = 0
for i in range(x-1):
area += d*((d*(i+1))**2)
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 com... | 20
10
| 68440000
70210000
| 6,021 |
s738593934 | p00014 | u803862921 | 1570870768 | Python | Python3 | py | Accepted | 20 | 5596 | 186 | while True:
try:
n = int(input())
except EOFError:
break
step = 600//n
area = 0
for i in range(step):
area += (i*n)**2 * n
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 com... | 20
10
| 68440000
70210000
| 6,022 |
s647990348 | p00014 | u595265835 | 1570455977 | Python | Python3 | py | Accepted | 30 | 5592 | 204 | while True:
try:
d = int(input())
sum = 0
n = d
while n < 600:
sum += d * (n ** 2)
n += 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 com... | 20
10
| 68440000
70210000
| 6,023 |
s210804590 | p00014 | u629170852 | 1568806343 | Python | Python3 | py | Accepted | 20 | 5596 | 137 | import sys
N=[]
for l in sys.stdin:
N.append(int(l))
for i in N:
j=0
ans=0
while j<600:
ans+=i*(j**2)
j+=i
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 com... | 20
10
| 68440000
70210000
| 6,024 |
s523861562 | p00014 | u824708460 | 1566193195 | Python | Python3 | py | Accepted | 20 | 5588 | 173 | while 1:
try:
d = int(input())
area = 0
for i in range(d, 600, d):
area += i ** 2 * d
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 com... | 20
10
| 68440000
70210000
| 6,025 |
s081396520 | p00014 | u939401108 | 1564925537 | Python | Python3 | py | Accepted | 20 | 5588 | 146 | while 1:
try:
d = int(input())
except:
break
s = 0
w = d
while d < 600:
h = d * d
s += h * w
d += w
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 com... | 20
10
| 68440000
70210000
| 6,026 |
s375175161 | p00014 | u433250944 | 1564909529 | Python | Python3 | py | Accepted | 30 | 5588 | 153 | while True:
try:
d = int(input())
except:
break
S = 0
for i in range(d, 600, d):
S += d*(i**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 com... | 20
10
| 68440000
70210000
| 6,027 |
s993531393 | p00014 | u212392281 | 1564854400 | Python | Python3 | py | Accepted | 20 | 5596 | 157 | try:
while(True):
d = int(input())
s = 0
for i in range(d, 600, d):
s = s + d*i**2
print(s)
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 com... | 20
10
| 68440000
70210000
| 6,028 |
s571779820 | p00014 | u108130680 | 1564847426 | Python | Python3 | py | Accepted | 20 | 5604 | 101 | while 1:
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 com... | 20
10
| 68440000
70210000
| 6,029 |
s512787473 | p00014 | u427219397 | 1564726668 | Python | Python3 | py | Accepted | 20 | 5600 | 105 | 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 com... | 20
10
| 68440000
70210000
| 6,030 |
s390218670 | p00014 | u529337794 | 1564708109 | Python | Python3 | py | Accepted | 20 | 5600 | 101 | while 1:
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 com... | 20
10
| 68440000
70210000
| 6,031 |
s157107070 | p00014 | u090921599 | 1563717492 | Python | Python3 | py | Accepted | 20 | 5592 | 134 | import sys
for i in map(int,sys.stdin):
sum = 0
for j in range(600//i-1):
sum += i*((j+1)*i)*((j+1)*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 com... | 20
10
| 68440000
70210000
| 6,032 |
s874725911 | p00014 | u051789695 | 1562340875 | Python | Python3 | py | Accepted | 30 | 5592 | 158 | while True:
try:
d=int(input())
except:
break
ans=0
for i in range(d,601-d,d):
y=i**2
ans+=d*y
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 com... | 20
10
| 68440000
70210000
| 6,033 |
s724799127 | p00014 | u586792237 | 1561960789 | Python | Python3 | py | Accepted | 30 | 5604 | 108 | 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 com... | 20
10
| 68440000
70210000
| 6,034 |
s953483095 | p00014 | u847360154 | 1561959654 | Python | Python3 | py | Accepted | 20 | 5592 | 130 | import sys
for i in map(int,sys.stdin):
sum=0
for j in range(600//i-1):
sum+=i*((j+1)*i)*((j+1)*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 com... | 20
10
| 68440000
70210000
| 6,035 |
s894954751 | p00014 | u821561321 | 1561959109 | Python | Python3 | py | Accepted | 20 | 5584 | 135 | while True:
try:
d = int(input())
ans = 0
for x in range(0,600,d):
ans += d*x*x
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 com... | 20
10
| 68440000
70210000
| 6,036 |
s212602437 | p00014 | u480501638 | 1561958931 | Python | Python3 | py | Accepted | 20 | 5592 | 130 | import sys
for i in map(int,sys.stdin):
sum=0
for j in range(600//i-1):
sum+=i*((j+1)*i)*((j+1)*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 com... | 20
10
| 68440000
70210000
| 6,037 |
s148628871 | p00014 | u678843586 | 1561958863 | Python | Python3 | py | Accepted | 20 | 5592 | 130 | import sys
for i in map(int,sys.stdin):
sum=0
for j in range(600//i-1):
sum+=i*((j+1)*i)*((j+1)*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 com... | 20
10
| 68440000
70210000
| 6,038 |
s850101785 | p00014 | u264450287 | 1561956471 | Python | Python3 | py | Accepted | 20 | 5588 | 156 | while True:
try:
d=int(input())
count=0
for i in range(1,int(600/d)):
count+=((i*d)**2)*d
print(count)
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 com... | 20
10
| 68440000
70210000
| 6,039 |
s118640510 | p00014 | u580449007 | 1561800790 | Python | Python3 | py | Accepted | 20 | 5592 | 232 | 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 com... | 20
10
| 68440000
70210000
| 6,040 |
s732094985 | p00014 | u179046735 | 1560585159 | Python | Python3 | py | Accepted | 30 | 5592 | 167 | while True:
try:
d=int(input())
ans=0
for i in range(1,600//d):
ans+=d*((i*d)**2)
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 com... | 20
10
| 68440000
70210000
| 6,041 |
s869781704 | p00014 | u800408401 | 1560146163 | Python | Python3 | py | Accepted | 20 | 5600 | 123 | while True:
try:d=int(input())
except:break
list=[(i*d)**2*d for i in range(600//d)]
print(sum(list))
| 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 com... | 20
10
| 68440000
70210000
| 6,042 |
s340697436 | p00014 | u625806423 | 1557058218 | Python | Python3 | py | Accepted | 30 | 5588 | 133 | while True:
try:
d = int(input())
except EOFError:
break
S = 0
for i in range(d,600,d):
S += d * i**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 com... | 20
10
| 68440000
70210000
| 6,043 |
s311937349 | p00014 | u406093358 | 1555467938 | Python | Python | py | Accepted | 10 | 4636 | 130 | import sys
for line in sys.stdin:
d = int(line)
sum = 0
for i in range(0, (600-d)/d):
y = (i+1)*d
sum += y*y*d
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 com... | 20
10
| 68440000
70210000
| 6,044 |
s411105827 | p00014 | u647694976 | 1554943759 | Python | Python3 | py | Accepted | 20 | 5600 | 100 | 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 com... | 20
10
| 68440000
70210000
| 6,045 |
s141098586 | p00014 | u990228206 | 1553157248 | Python | Python3 | py | Accepted | 20 | 5592 | 153 | while 1:
try:
ans=0
d=int(input())
for i in range(1,600//d):
ans+=(i*d)**2*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 com... | 20
10
| 68440000
70210000
| 6,046 |
s263651072 | p00014 | u689047545 | 1547909624 | Python | Python3 | py | Accepted | 20 | 5588 | 263 | if __name__ == '__main__':
while True:
ans = 0
try:
n = int(input())
for i in range(1, 600//n):
ans += ((n*i)**2) * n
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 com... | 20
10
| 68440000
70210000
| 6,047 |
s635598502 | p00014 | u563075864 | 1542457003 | Python | Python3 | py | Accepted | 20 | 5612 | 166 | while(1):
try:
n = int(input())
a = list(range(0,600,n))
s = sum([i**2 for i in a])*n
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 com... | 20
10
| 68440000
70210000
| 6,048 |
s188457995 | p00014 | u067299340 | 1542164123 | Python | Python3 | py | Accepted | 20 | 5596 | 188 | while True:
try:
d = int(input())
sum = 0
for i in range(1, 600//d):
sum += d * (d * i) ** 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 com... | 20
10
| 68440000
70210000
| 6,049 |
s526350820 | p00014 | u717526540 | 1541642308 | Python | Python3 | py | Accepted | 20 | 5592 | 176 | while(1):
try:
d = int(input())
except:
break
s = 0
w = d
while d < 600:
h = d * d
s += h * w
d += w
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 com... | 20
10
| 68440000
70210000
| 6,050 |
s963928189 | p00014 | u219940997 | 1537449640 | Python | Python3 | py | Accepted | 20 | 5592 | 119 | while True:
try:
d = int(input())
print(sum(d * x**2 for x in range(d, 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 com... | 20
10
| 68440000
70210000
| 6,051 |
s518481390 | p00014 | u319725914 | 1534218467 | Python | Python3 | py | Accepted | 20 | 5588 | 162 | while(True):
try:
d = int(input())
r = 0
for p in range(0,600,d):
r += d*p**2
print(r)
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 com... | 20
10
| 68440000
70210000
| 6,052 |
s678746964 | p00014 | u995990363 | 1533638518 | Python | Python3 | py | Accepted | 20 | 5604 | 250 | import sys
def f(x):
return x**2
def integral(d):
s = 0
for _d in range(1, int(600/d)):
s += f(d * _d) * d
return s
def run():
for d in sys.stdin:
print(integral(int(d)))
if __name__ == '__main__':
run()
| 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 com... | 20
10
| 68440000
70210000
| 6,053 |
s763899296 | p00014 | u933096856 | 1533283397 | Python | Python3 | py | Accepted | 20 | 5592 | 202 | import sys
def Integral(x):
return x**2
def test(d):
s=0
n=int(600/d)
for i in range(1,n):
s+=Integral(d*i)*d
return s
for d in sys.stdin:
d=int(d)
print(test(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 com... | 20
10
| 68440000
70210000
| 6,054 |
s538688158 | p00014 | u252700163 | 1532761946 | Python | Python3 | py | Accepted | 30 | 5588 | 167 | while True:
try:
sums = 0
d = int(input())
n = 600//d
for s in range(n):
D = d*((s*d)**2)
sums += D
print(sums)
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 com... | 20
10
| 68440000
70210000
| 6,055 |
s785802218 | p00014 | u539753516 | 1532325499 | Python | Python3 | py | Accepted | 20 | 5588 | 151 | while 1:
try:
d=int(input())
ans=0
for i in range(600//d):
ans+=d*d*d*i*i
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 com... | 20
10
| 68440000
70210000
| 6,056 |
s221128196 | p00014 | u853158149 | 1521973184 | Python | Python3 | py | Accepted | 30 | 5592 | 157 | while 1:
try:
d = int(input())
s = 0
for i in range(d,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 com... | 20
10
| 68440000
70210000
| 6,057 |
s097002469 | p00014 | u079141094 | 1467381372 | Python | Python3 | py | Accepted | 30 | 7632 | 199 | # Integral
def sumby(d, S=0):
for i in range(d, 600, d):
S += pow(i,2) * d
return S
d = int(input())
while 1:
print(sumby(d))
try: d = int(input())
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 com... | 20
10
| 68440000
70210000
| 6,058 |
s484296134 | p00014 | u822200871 | 1448107447 | Python | Python3 | py | Accepted | 20 | 7536 | 238 | output = []
while True:
try:
d = int(input())
except :
break
sum = 0
for x in range(1,600//d):
sum = sum + d * (d*x) * (d*x)
output.append(sum)
for x in range(len(output)):
print(output[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 com... | 20
10
| 68440000
70210000
| 6,059 |
s654823101 | p00015 | u525366883 | 1535447665 | Python | Python | py | Accepted | 10 | 4668 | 186 | n = int(raw_input())
for i in range(n):
a = long(raw_input())
b = long(raw_input())
tmp = str(a+b)
if len(tmp) > 80:
print "overflow"
else:
print tmp
| p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,060 |
s532075002 | p00015 | u197670577 | 1546509955 | Python | Python3 | py | Accepted | 20 | 5604 | 1,212 | # 国家予算
def main():
N = int(input())
for _ in range(N):
n1 = input().strip()
n2 = input().strip()
#print(f"n1: {n1}\nn2: {n2}")
if len(n1) > 80 or len(n2) > 80:
print("overflow")
continue
print(add(n1, n2))
return
def add(n1, n2):
"""n1,... | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,061 |
s625575862 | p00015 | u990228206 | 1551343605 | Python | Python3 | py | Accepted | 20 | 5588 | 129 | n=int(input())
for i in range(n):
a=int(input())
b=int(input())
if a+b>=10**80:print("overflow")
else:print(a+b)
| p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,062 |
s736807739 | p00015 | u886122084 | 1551516157 | Python | Python3 | py | Accepted | 20 | 5600 | 310 | # python template for atcoder1
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
n = int(input())
ans = []
for _ in range(n):
a = int(input())
b = int(input())
s = a+b
if s > 10**80-1:
ans.append("overflow")
else:
ans.append(str(s))
print("\n".join(ans))
| p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,063 |
s857555718 | p00015 | u858885710 | 1406557499 | Python | Python | py | Accepted | 10 | 4228 | 108 | r=raw_input
for a in range(int(r())):
s=sum([int(r()),int(r())])
print s>=10**80 and "overflow" or s | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,064 |
s764368584 | p00015 | u385497113 | 1409332813 | Python | Python | py | Accepted | 20 | 4232 | 687 | #! -*- coding: utf-8-unix -*-
import sys
# if __name__=='__main__':
# lines = [int(x.strip()) for x in sys.stdin.readlines()]
# print lines
# n = lines[0]
# for i in xrange(n):
# # a, b = int(lines[i+1]), int(lines[i+2])
# a, b = lines[2*i+1], lines[2*i+2]
# if len(str(a+b)) > 80:
# print 'ov... | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,065 |
s521626063 | p00015 | u385497113 | 1409333276 | Python | Python | py | Accepted | 10 | 4240 | 259 | import sys
if __name__=='__main__':
lines = [int(x.strip()) for x in sys.stdin.readlines() if x != '' and x != '\n']
n = lines[0]
for i in xrange(n):
a, b = lines[2*i+1], lines[2*i+2]
if len(str(a+b)) > 80:
print 'overflow'
else:
print a+b | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,066 |
s705897466 | p00015 | u880042992 | 1409506838 | Python | Python3 | py | Accepted | 30 | 6720 | 116 | N = 10 ** 80
for i in range(int(input())):
n = int(input()) + int(input())
print(n if n < N else 'overflow') | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,067 |
s274296928 | p00015 | u696166817 | 1410094802 | Python | Python3 | py | Accepted | 30 | 6720 | 307 | if __name__ == "__main__":
nset = int(input())
for i in range(0, nset):
sa = input()
sb = input()
a = int(sa)
b = int(sb)
c = a + b
if len(sa) > 80 or len(sb) > 80 or len(str(c)) > 80:
print("overflow")
else:
print(c) | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,068 |
s850245225 | p00015 | u579833671 | 1410767450 | Python | Python | py | Accepted | 10 | 4236 | 285 | while(True):
try:
n = input()
for i in range(n):
a = input()
b = input()
c = str(a + b)
if(len(c) > 80):
print("overflow")
else:
print(c)
except Exception:
break | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,069 |
s980917527 | p00015 | u585391547 | 1413205987 | Python | Python3 | py | Accepted | 30 | 6716 | 135 | n=int(input())
for i in range(n):
a=int(input())
b=int(input())
c=a+b
c=str(c)
if len(c)>80:
print("overflow")
else:
print(c) | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,070 |
s378368571 | p00015 | u506132575 | 1416119441 | Python | Python | py | Accepted | 10 | 4236 | 209 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
num = input()
for i in range(num):
s = long(input())
t = long(input())
u = s+t
if len(str(u)) > 80 :
print "overflow"
else:
print u | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,071 |
s054035422 | p00015 | u607831289 | 1416145894 | Python | Python | py | Accepted | 10 | 4236 | 291 | n = int(raw_input())
for i in range(n):
a = raw_input()
b = raw_input()
if len(a) > 80 or len(b) > 80:
print 'overflow'
else:
a, b = int(a), int(b)
c = a + b
if len(str(c)) > 80:
print 'overflow'
else:
print c | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,072 |
s345300155 | p00015 | u162387221 | 1417515033 | Python | Python3 | py | Accepted | 30 | 6720 | 108 | N = 10**80
for i in range(int(input())):
n = int(input()) + int(input())
print(n if n < N else "overflow") | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,073 |
s559307906 | p00015 | u408260374 | 1418498360 | Python | Python3 | py | Accepted | 30 | 6724 | 124 | n = int(input())
for _ in range(n):
a = sum([int(input()) for _ in range(2)])
print(a if a < 10**80 else 'overflow') | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,074 |
s003076343 | p00015 | u408260374 | 1418498527 | Python | Python3 | py | Accepted | 30 | 6720 | 104 | for _ in range(int(input())):
a=int(input())+int(input())
print(a if a < 10**80 else 'overflow') | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,075 |
s098059357 | p00015 | u912237403 | 1418516920 | Python | Python | py | Accepted | 10 | 4228 | 131 | n = int(raw_input())
for _ in [0]*n:
a = int(raw_input())
b = int(raw_input())
c = a+b
print [c,"overflow"][len(str(c))>80] | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,076 |
s812535351 | p00015 | u912237403 | 1418516996 | Python | Python | py | Accepted | 10 | 4228 | 104 | n = input()
for _ in [0]*n:
a = input()
b = input()
c = a+b
print [c,"overflow"][len(str(c))>80] | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,077 |
s958768915 | p00015 | u334031393 | 1418716240 | Python | Python3 | py | Accepted | 30 | 6720 | 171 | import sys
n = int(input())
for i in range(n):
a = int(input())
b = int(input())
if a + b >= 10**80:
print ("overflow")
else:
print(a + b) | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,078 |
s297534833 | p00015 | u334491063 | 1419161145 | Python | Python | py | Accepted | 10 | 4364 | 132 | import math
n=input()
for i in range(n):
a=input()
b=input()
ans=a+b
if len(str(ans))>80:
print "overflow"
else:
print ans | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,079 |
s903068588 | p00015 | u912237403 | 1419171120 | Python | Python | py | Accepted | 10 | 4232 | 131 | n = int(raw_input())
for _ in [0]*n:
a = int(raw_input())
b = int(raw_input())
c = a+b
print [c,"overflow"][len(str(c))>80] | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,080 |
s807284630 | p00015 | u912237403 | 1419171304 | Python | Python | py | Accepted | 20 | 4232 | 126 | def f(): return int(raw_input())
n = f()
for _ in [0]*n:
a = f()
b = f()
c = a+b
print [c, "overflow"][len(str(c))>80] | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,081 |
s959837233 | p00015 | u342537066 | 1420704487 | Python | Python3 | py | Accepted | 30 | 6720 | 158 | n=int(input())
for i in range(n):
a=int(input())
b=int(input())
c=a+b
if len(str(c))>80:
print("overflow")
else:
print(c) | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,082 |
s559262615 | p00015 | u567380442 | 1422616122 | Python | Python3 | py | Accepted | 30 | 6724 | 215 | import sys
f = sys.stdin
n = int(f.readline())
for _ in range(n):
a = f.readline().strip()
b = f.readline().strip()
c = int(a) + int(b)
c = '{}'.format(c)
print(c if len(c) <= 80 else 'overflow') | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,083 |
s858975745 | p00015 | u929523932 | 1424305290 | Python | Python3 | py | Accepted | 30 | 6720 | 216 | from sys import stdin
n = int(stdin.readline())
for i in range(n):
c = str(int(stdin.readline().strip()) + int(stdin.readline().strip()))
if (len(c) > 80):
print("overflow")
else:
print(c) | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,084 |
s943602685 | p00015 | u744114948 | 1425519537 | Python | Python3 | py | Accepted | 30 | 6724 | 267 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Copyright : @Huki_Hara
# Created : 2015-03-05
n=int(input())
for _ in range(n):
a=int(input())
b=int(input())
sum=a+b
if len(str(sum)) > 80:
print("overflow")
else:
print(sum) | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,085 |
s384091244 | p00015 | u540744789 | 1425712694 | Python | Python | py | Accepted | 10 | 4272 | 745 | for x in range(input()):
x=raw_input()
x=x[::-1]
y=raw_input()
y=y[::-1]
z=[0]*81
if len(x)>80 or len(y) >80:
print 'overflow'
else:
for i in xrange(len(x)):
z[i]=int(x[i])
for j in xrange(len(y)):
z[j]=z[j]+int(y[j])
for k in xrange(ma... | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,086 |
s504132853 | p00015 | u266872031 | 1427642122 | Python | Python | py | Accepted | 20 | 4256 | 461 | N=int(raw_input())
for i in range(N):
a=raw_input()
b=raw_input()
if len(a)<len(b):
(a,b)=(b,a)
b=''.join(['0' for x in range(len(a)-len(b))])+b
c=[]
o=0
for p in range(len(a)):
d=(int(a[-p-1])+int(b[-p-1])+o)%10
o=(int(a[-p-1])+int(b[-p-1])+o)/10
c.append(d)
... | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,087 |
s908841228 | p00015 | u542962065 | 1428012910 | Python | Python | py | Accepted | 10 | 4220 | 110 | a=input()
for i in range(a):
x=input()
y=input()
if len(str(x+y))>80:
print "overflow"
else:
print x+y | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,088 |
s568388441 | p00015 | u145563629 | 1428819807 | Python | Python | py | Accepted | 10 | 4236 | 154 | n = int(raw_input())
while n:
n -= 1
a = long(raw_input())
b = long(raw_input())
c = a + b
if 80 < len(str(c)):
print "overflow"
else:
print c | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,089 |
s513914175 | p00015 | u886766186 | 1430398239 | Python | Python | py | Accepted | 10 | 4232 | 167 | n = input()
for i in range(n):
a = input()
b = input()
c = int(a) + int(b)
if len(str(c)) > 80:
print 'overflow'
else:
print a + b | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,090 |
s059412097 | p00015 | u067299340 | 1432901965 | Python | Python | py | Accepted | 10 | 4224 | 95 | for x in[sum([input(),input()])for i in range(input())]:print"overflow"if len(str(x))>80 else x | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,091 |
s856329787 | p00015 | u940190657 | 1433667088 | Python | Python3 | py | Accepted | 30 | 6720 | 245 | def main():
n = int(input())
for i in range(n):
result = str(int(input()) + int(input()))
if len(result) > 80:
print("overflow")
else:
print(result)
if __name__ == '__main__':
main() | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,092 |
s027972645 | p00015 | u379956761 | 1434845418 | Python | Python3 | py | Accepted | 30 | 6784 | 301 | #!/usr/bin/env python
#-*- coding:utf-8 -*-
import sys
import math
n = int(input())
result = 0
for i in range(n):
result = 0
x = int(input())
y = int(input())
result = x + y
length = len(str(result))
if length > 80:
print("overflow")
else:
print(result) | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,093 |
s454976703 | p00015 | u211905117 | 1435813961 | Python | Python3 | py | Accepted | 30 | 6720 | 145 | for _ in range(int(input())) :
n = int(input()) + int(input())
if (n >= 10 ** 80) :
print("overflow")
else :
print(n) | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,094 |
s538397199 | p00015 | u472944603 | 1437634695 | Python | Python | py | Accepted | 10 | 4232 | 174 | n = int(input())
over = 10 ** 80
for i in range(n):
a = int(input())
b = int(input())
if (a + b < over):
print (a + b)
else:
print "overflow" | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,095 |
s367333409 | p00015 | u883062308 | 1438520788 | Python | Python3 | py | Accepted | 30 | 6724 | 132 | max = 10 ** 80
for i in range(int(input())):
total = int(input()) + int(input())
print(total if total < max else "overflow") | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,096 |
s209687972 | p00015 | u193025715 | 1439635884 | Python | Python3 | py | Accepted | 40 | 6720 | 466 | #!/usr/bin/python
# AOJ
# 0015
for i in range(int(input())):
n1 = list(input())
n2 = list(input())
if len(n2) > len(n1):
n1, n2 = n2, n1
ans = []
for i in range(len(n1)):
a = int(ans.pop(0)) if len(ans) == i + 1 else 0
c1 = int(n1.pop(-1))
c2 = int(n2.pop(-1)) if le... | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,097 |
s853827473 | p00015 | u749493116 | 1440227892 | Python | Python | py | Accepted | 10 | 6600 | 248 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import math
n = int(raw_input());
over = 10 ** 80;
for i in range(0, n):
a = int(raw_input());
b = int(raw_input());
if a + b >= over:
print "overflow"
else:
print a + b; | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,098 |
s464226030 | p00015 | u071010747 | 1445234267 | Python | Python3 | py | Accepted | 20 | 7708 | 248 | # -*- coding:utf-8 -*-
def main():
for i in range(int(input())):
a=int(input())+int(input())
if a>=10**80:
print("overflow")
else:
print(a)
if __name__ == '__main__':
main() | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,099 |
s735553026 | p00015 | u823513038 | 1448098970 | Python | Python3 | py | Accepted | 30 | 7620 | 165 | n = int(input())
for i in range(n):
a = int(input())
b = int(input())
if (a + b) < (10 ** 80):
print(a + b)
else:
print("overflow") | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,100 |
s999967047 | p00015 | u461370825 | 1449737483 | Python | Python | py | Accepted | 10 | 6236 | 185 | while True:
try:
n = input()
for i in range(n):
a = input()
b = input()
s = a+b
if len(str(s)) > 80:
print "overflow"
else:
print s
except EOFError:
break | p00015 |
<H1>National Budget</H1>
<p>
A country has a budget of more than 81 trillion yen. We want to process such data, but conventional integer type which uses signed 32 bit can represent up to 2,147,483,647.
</p>
<p>
Your task is to write a program which reads two integers (more than or equal to zero), and prints a sum of... | 6
1000
800
9999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0
100000000000000000000000000000000000000000000000000000000000000000000000000000000
1
1000000000000000... | 1800
10000000000000000000000000000000000000000
overflow
99999999999999999999999999999999999999999999999999999999999999999999999999999999
overflow
overflow
| 6,101 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.