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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
s446202378 | p00003 | u528181593 | 1594627204 | Python | Python3 | py | Accepted | 40 | 5596 | 200 | n=int(input())
for i in range (n):
l=list(map(int,input().split()))
L=sorted(l)
if (L[0])*(L[0])+(L[1])*(L[1])==(L[2])*(L[2]):
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,002 |
s310273327 | p00003 | u421274895 | 1594621164 | Python | Python3 | py | Accepted | 40 | 5600 | 194 | N=int(input())
for i in range(N):
a,b,c=map(int,input().split())
if (a**2==b**2+c**2) or (b**2==a**2+c**2) or (c**2==a**2+b**2):
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,003 |
s818973827 | p00003 | u278236319 | 1594614957 | Python | Python3 | py | Accepted | 40 | 5592 | 205 | N = int(input())
for i in range(N):
a, b, c = map(int, input().split())
if (a**2 + b**2 == c**2 or a**2 + c**2 == b**2 or c**2 + b**2 == a**2) :
print("YES")
else :
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,004 |
s388756800 | p00003 | u082412851 | 1594470882 | Python | Python3 | py | Accepted | 40 | 5600 | 193 | N = int(input())
for i in range(N):
a,b,c = map(int,input().split())
if a**2 == b**2+c**2 or b**2 == a**2+c**2 or c**2 == a**2+b**2:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,005 |
s858127955 | p00003 | u062640303 | 1594449419 | Python | Python3 | py | Accepted | 40 | 5596 | 188 | N=int(input())
for i in range(N):
a,b,c=map(int,input().split())
if (a**2+b**2)==c**2 or (a**2+c**2)==b**2 or (c**2+b**2)==a**2:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,006 |
s691735836 | p00003 | u799016206 | 1594022486 | Python | Python3 | py | Accepted | 40 | 5648 | 182 | N = input()
for i in range(int(N)):
l = list(map(int, input().split()))
l.sort()
if(l[2] == (l[0]**2+l[1]**2)**0.5):
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,007 |
s123873326 | p00003 | u189528630 | 1594011994 | Python | Python3 | py | Accepted | 50 | 5612 | 270 | n=int(input())
for i in range(n):
a=list(map(float,input().split()))
if a[0]**2+a[1]**2==a[2]**2:
print("YES")
elif a[1]**2+a[2]**2==a[0]**2:
print("YES")
elif a[2]**2+a[0]**2==a[1]**2:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,008 |
s964799707 | p00003 | u635020217 | 1593975956 | Python | Python3 | py | Accepted | 40 | 5596 | 199 | # coding: utf-8
# Your code here!
N = int(input())
for i in range(N):
a,b,c = sorted(map(int,input().split()))
if a*a + b*b == c*c:
print ("YES")
else:
print ("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,009 |
s684904738 | p00003 | u706683821 | 1593855761 | Python | Python3 | py | Accepted | 50 | 5592 | 211 | N=int(input())
for i in range(N):
a,b,c=map(int,input().split())
A=max(a,max(b,c))
B=min(a,min(b,c))
C=a+b+c-A-B
if B**2+C**2==A**2:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,010 |
s427617461 | p00003 | u100874602 | 1593848851 | Python | Python3 | py | Accepted | 40 | 5596 | 152 | N=int(input())
for i in range(N):
x,y,z=sorted(map(int,input().split()))
if x**2+y**2==z**2:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,011 |
s827030419 | p00003 | u555228137 | 1593480947 | Python | Python3 | py | Accepted | 40 | 5592 | 182 | N=int(input())
for i in range(N):
a,b,c=map(int,input().split())
if a**2+b**2==c**2 or a**2+c**2==b**2 or b**2+c**2==a**2:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,012 |
s101660096 | p00003 | u709176169 | 1593476847 | Python | Python3 | py | Accepted | 40 | 5592 | 238 | N=int(input())
for i in range(N):
x,y,z=map(int,input().split())
if x**2==y**2+z**2:
print('YES')
elif y**2==x**2+z**2:
print('YES')
elif z**2==x**2+y**2:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,013 |
s880361371 | p00003 | u118506623 | 1593430388 | Python | Python3 | py | Accepted | 40 | 5596 | 200 | n = int(input())
for i in range(n):
a, b, c = map(int,input().split())
if a**2 + b**2 == c**2 or a**2 + c**2 == b**2 or b**2 + c**2 == a**2:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,014 |
s777518303 | p00003 | u272062354 | 1593413352 | Python | Python3 | py | Accepted | 40 | 5600 | 177 | N=int(input())
for i in range(N):
a,b,c=map(int,input().split())
a,b,c=sorted([a,b,c])
if (a**2)+(b**2)==(c**2):
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,015 |
s382897443 | p00003 | u167524059 | 1593410250 | Python | Python3 | py | Accepted | 50 | 5596 | 204 | N = int(input())
for i in range(N) :
a, b, c = map(int, input().split())
if a**2 == b**2 + c**2 or b**2 == c**2 + a**2 or c**2 == a**2 + b**2 :
print("YES")
else :
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,016 |
s671193885 | p00003 | u413645175 | 1593308803 | Python | Python3 | py | Accepted | 40 | 5640 | 238 | n = int(input())
for i in range(n):
a, b, c = map(int, input().split())
d = 2
e = 1/2
if (a**d+b**d)**e == c or (a**d+c**d)**e == b or (c**d+b**d)**e == a:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,017 |
s725857912 | p00003 | u355413291 | 1592876071 | Python | Python3 | py | Accepted | 40 | 5596 | 197 | n=int(input())
for i in range(n):
a,b,c=map(int,input().split())
d=[a,b,c]
d=sorted(d)
if d[0]**2+d[1]**2 == d[2]**2 :
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,018 |
s370233871 | p00003 | u293306835 | 1592874621 | Python | Python3 | py | Accepted | 40 | 5596 | 273 | N=int(input())
for i in range(0,N):
a,b,c=map(int,input().split())
if a**2==b**2+c**2:
print("YES")
elif b**2==a**2+c**2:
print("YES")
else:
if c**2==a**2+b**2:
print("YES")
else:
print("NO")
i+=1
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,019 |
s555974798 | p00003 | u037566157 | 1592818046 | Python | Python3 | py | Accepted | 40 | 5596 | 174 | N=int(input())
for i in range(N):
a=list(map(int,input().split()))
a.sort()
if a[2]*a[2]==a[1]*a[1]+a[0]*a[0]:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,020 |
s848969058 | p00003 | u554271288 | 1592813460 | Python | Python3 | py | Accepted | 40 | 5596 | 199 | N=int(input())
for i in range (1,N+1):
a,b,c=map(int,input().split())
x=max(a,b,c)
y=min(a,b,c)
z=a+b+c-x-y
if x**2==y**2+z**2:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,021 |
s015958747 | p00003 | u755480664 | 1592723118 | Python | Python3 | py | Accepted | 40 | 5596 | 234 | for i in range(int(input())):
a,b,c=map(int,input().split())
if a**2+b**2==c**2:
print("YES")
elif b**2+c**2==a**2:
print("YES")
elif c**2+a**2==b**2:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,022 |
s305360213 | p00003 | u905454643 | 1592717033 | Python | Python3 | py | Accepted | 40 | 5660 | 242 | import math as m
N=int(input())
for i in range(N):
a,b,c=map(int,input().split())
A = min(a,min(b,c))
C = max(a,max(b,c))
B = a+b+c-A-C
r=m.sqrt(A**2+B**2)
if C == r:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,023 |
s548146679 | p00003 | u251716708 | 1592357424 | Python | Python3 | py | Accepted | 40 | 5596 | 237 | n = int(input())
for i in range(n):
a,b,c = map(int,input().split())
if a>b:
a,b=b,a
if b>c:
b,c=c,b
if a>b:
a,b=b,a
if(a**2 + b**2 == c**2):
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,024 |
s246464682 | p00003 | u361745995 | 1592270130 | Python | Python3 | py | Accepted | 40 | 5596 | 430 | i=1
n=int(input())
for i in range(1,n+1):
a,b,c=map(int,input().split())
if a==0 or b==0 or c==0:
break
else:
if a>b:
a,b=b,a
else:
a,b=a,b
if b>c:
b,c=c,b
else:
b,c=b,c
if a>b:
a,b=b,a
else:
a,b=a,b
if a**2+b**2==c**2:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,025 |
s723019544 | p00003 | u680047335 | 1592268651 | Python | Python3 | py | Accepted | 40 | 5600 | 264 | #Volume0-0003
n = int(input())
for a in range(n):
x,y,z = (input().split())
x = int(x)
y = int(y)
z = int(z)
for a in range (3):
if x > y:
x,y = y,x
if y > z:
y,z = z,y
if z**2 == x**2+y**2:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,026 |
s240272766 | p00003 | u329155726 | 1592266832 | Python | Python3 | py | Accepted | 40 | 5592 | 128 | for _ in range(int(input())):
a, b, c = sorted(list(map(int, input().split())))
print("YES" if a**2 + b**2 == c**2 else "NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,027 |
s293936739 | p00003 | u869208015 | 1592213833 | Python | Python3 | py | Accepted | 30 | 5596 | 230 | N=int(input())
for i in range(N):
a,b,c=map(int,input().split())
if a>b:
a,b=b,a
if b>c:
b,c=c,b
if a>b:
a,b=b,a
if c**2-a**2-b**2==0:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,028 |
s741100321 | p00003 | u457539618 | 1592204260 | Python | Python3 | py | Accepted | 50 | 5592 | 253 | N=int(input())
for i in range(N):
a,b,c=input().split()
a=int(a)
b=int(b)
c=int(c)
X=int(max(a,b,c))
Y=int(min(a,b,c))
Z=int(a+b+c-X-Y)
if X**2 == Y**2 + Z**2:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,029 |
s969617089 | p00003 | u586171604 | 1592202019 | Python | Python3 | py | Accepted | 40 | 5604 | 194 | N = int(input())
for i in range(N):
p = input()
li = sorted([int(i) for i in p.split(" ")])
if li[-1]**2 == li[-2]**2 + li[-3]**2:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,030 |
s450857207 | p00003 | u826807985 | 1592198725 | Python | Python3 | py | Accepted | 50 | 5596 | 248 | N=int(input())
for i in range(N):
x,y,z=map(int,input().split())
if x**2+y**2==z**2:
print("YES")
elif x**2+z**2==y**2:
print("YES")
elif y**2+z**2==x**2:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,031 |
s562346859 | p00003 | u900012957 | 1592198421 | Python | Python3 | py | Accepted | 40 | 5596 | 161 | for i in range(int(input())):
x,y,z = sorted(list(map(int, input().split())))
if x**2 + y**2 == z**2:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,032 |
s434152615 | p00003 | u187074069 | 1592185595 | Python | Python3 | py | Accepted | 40 | 5600 | 213 | num = int(input())
for i in range(num):
lst = list(map(int, input().split()))
lst.sort()
a, b, c = lst[0], lst[1], lst[2]
if c**2 == a**2 + b**2:
print('YES')
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,033 |
s614472501 | p00003 | u645087541 | 1592183457 | Python | Python3 | py | Accepted | 40 | 5592 | 193 | n = int(input())
for i in range (n):
a = list(map(int,input().split()))
a.sort()
if a[0] ** 2 + a[1] ** 2 == a[2] ** 2:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,034 |
s952247635 | p00003 | u412088763 | 1592123544 | Python | Python3 | py | Accepted | 40 | 5600 | 232 | input()
while True:
try:
num=list(map(int,input().split()))
num.sort()
if num[2]**2==num[0]**2+num[1]**2:
print("YES")
else:
print("NO")
except EOFError:
break
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,035 |
s876100335 | p00003 | u529477970 | 1592095771 | Python | Python3 | py | Accepted | 40 | 5660 | 219 | import math
N=int(input())
for i in range(N):
a,b,c=map(int, input().split())
if c==math.sqrt(a**2+b**2) or b==math.sqrt(a**2+c**2) or a==math.sqrt(c**2+b**2):
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,036 |
s209195449 | p00003 | u834258010 | 1591961283 | Python | Python3 | py | Accepted | 40 | 5660 | 218 | import math
N=int(input())
for i in range(N):
a,b,c=map(int,input().split())
if c==math.sqrt(a**2+b**2) or a==math.sqrt(c**2+b**2) or b==math.sqrt(a**2+c**2):
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,037 |
s224587949 | p00003 | u390052013 | 1591959355 | Python | Python3 | py | Accepted | 40 | 5612 | 222 | def solve():
n = int(input())
for _ in range(n):
a, b, c = sorted([int(i) for i in input().split()])
if a**2 + b**2 == c**2:
print("YES")
else:
print("NO")
solve()
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,038 |
s679615831 | p00003 | u925445050 | 1591710962 | Python | Python3 | py | Accepted | 40 | 5600 | 191 | N=int(input())
for i in range(N):
a,b,c=sorted(map(int,input().split()))
if a**2+b**2==c**2 or a**2+c**2==b**2 or b**2+c**2==a**2:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,039 |
s144462860 | p00003 | u630948380 | 1591666795 | Python | Python3 | py | Accepted | 40 | 5596 | 273 | N=int(input())
for i in range(0,N):
x,y,z=map(int,input().split())
if x**2==y**2+z**2:
print("YES")
elif y**2==x**2+z**2:
print("YES")
else:
if z**2==x**2+y**2:
print("YES")
else:
print("NO")
i+=1
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,040 |
s359450870 | p00003 | u438043982 | 1591666512 | Python | Python3 | py | Accepted | 40 | 5604 | 181 | n=int(input())
for i in range(n):
a,b,c=map(int,input().split())
x=[a,b,c]
x.sort()
if x[2]**2==x[1]**2+x[0]**2:
print("YES")
else :
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,041 |
s092233139 | p00003 | u350481745 | 1591666265 | Python | Python3 | py | Accepted | 40 | 5596 | 170 | N=int(input())
for i in range(N):
a=list(map(int,input().split()))
a.sort()
if a[0]**2+a[1]**2==a[2]**2:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,042 |
s752860648 | p00003 | u976648183 | 1591663346 | Python | Python3 | py | Accepted | 40 | 5604 | 253 | n = int(input() )
for i in range(n):
a, b, c = [int(x) for x in input().split()]
if (b > a):
a, b = b, a
if (c > a):
a, c = c, a #a = max
if (b*b + c*c - a*a == 0):
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,043 |
s958061777 | p00003 | u644959375 | 1591606574 | Python | Python3 | py | Accepted | 40 | 5596 | 204 | N=int(input())
for i in range(N):
a,b,c=map(int,input().split())
A=min(a,min(b,c))
C=max(a,max(b,c))
B=a+b+c-A-C
if A**2+B**2==C**2:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,044 |
s473981262 | p00003 | u627612495 | 1591601083 | Python | Python3 | py | Accepted | 40 | 5596 | 251 | N = int(input())
for i in range(N):
a,b,c = map(int,input().split())
if a*a == b*b + c*c:
print('YES')
elif b*b == a*a + c*c:
print('YES')
elif c*c == a*a + b*b:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,045 |
s850405620 | p00003 | u661628543 | 1591598152 | Python | Python3 | py | Accepted | 30 | 5596 | 297 | N=int(input())
for i in range(N):
a,b,c=map(int,input().split())
A=a*a
B=b*b
C=c*c
if a>b and a>c and A==B+C:
print('YES')
elif b>a and b>c and B==A+C:
print('YES')
elif c>a and c>b and C==A+B:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,046 |
s388936153 | p00003 | u034153923 | 1591591960 | Python | Python3 | py | Accepted | 40 | 5600 | 165 | for i in range(int(input())):
a,b,c=sorted(list(map(int,input().split())))
if (a**2)+(b**2) == (c**2) :
print("YES")
else :
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,047 |
s271963879 | p00003 | u573698742 | 1591581836 | Python | Python3 | py | Accepted | 40 | 5596 | 156 | N=int(input())
for i in range(N):
a,b,c=sorted(map(int, input().split()))
if a*a + b*b == c*c :
print("YES")
else :
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,048 |
s239618264 | p00003 | u685887060 | 1591256222 | Python | Python3 | py | Accepted | 40 | 5592 | 199 | N=int(input())
for i in range(N):
a,b,c=map(int,input().split())
if (a**2+b**2)==c**2 or (a**2+c**2)==b**2 or (c**2+b**2)==a**2:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,049 |
s784097414 | p00003 | u722264914 | 1591235223 | Python | Python3 | py | Accepted | 30 | 5592 | 163 | N = int(input())
for i in range(N) :
vertex=sorted(map(int,input().split(" ")))
if vertex[0]**2+vertex[1]**2==vertex[2]**2 :
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,050 |
s681721879 | p00003 | u245861861 | 1591094922 | Python | Python3 | py | Accepted | 40 | 5720 | 255 | s=int(input())
jon=[]
while True:
try:
jon.append(input())
except:
break
for i in jon:
pon=sorted(list(map(int,i.split())),reverse=True)
if pon[0]**2==pon[1]**2+pon[2]**2:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,051 |
s826912376 | p00003 | u053015104 | 1591077491 | Python | Python3 | py | Accepted | 40 | 5592 | 192 | N=int(input())
for i in range(N):
a,b,c = map(int,input().split())
A=a*a
B=b*b
C=c*c
if A+B==C or A+C==B or B+C==A:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,052 |
s070907588 | p00003 | u673183698 | 1591061618 | Python | Python3 | py | Accepted | 40 | 5592 | 166 | N=int(input())
for i in range(N):
n=list(map(int,input().split()))
n.sort()
if n[0]*n[0]+n[1]*n[1]==n[2]*n[2]:
print('YES')
else:print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,053 |
s530285107 | p00003 | u275486335 | 1591061499 | Python | Python3 | py | Accepted | 40 | 5596 | 234 | i=int(input())
for j in range(i):
a,b,c=map(int,input().split())
d=[a,b,c]
list=sorted(d)
x=int(list[0])
y=int(list[1])
z=int(list[2])
if x**2+y**2==z**2:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,054 |
s899357644 | p00003 | u221550784 | 1591058015 | Python | Python3 | py | Accepted | 40 | 5600 | 225 | N=int(input())
for i in range(N):
a,b,c=map(int,input().split())
if a>b:
a,b=b,a
if b>c:
b,c=c,b
if a>b:
a,b=b,a
if a*a+b*b==c*c:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,055 |
s589021250 | p00003 | u257570657 | 1591024215 | Python | Python3 | py | Accepted | 40 | 5596 | 182 | n=int(input())
for i in range(n):
a,b,c=map(int,input().split())
if a**2+b**2==c**2 or a**2+c**2==b**2 or b**2+c**2==a**2:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,056 |
s060142609 | p00003 | u444626963 | 1591001234 | Python | Python3 | py | Accepted | 30 | 5596 | 213 | for i in range ( int ( input ( ) ) ):
a,b,c = map(int, input().split())
if a == 0 and b == 0: break
if a*a+b*b==c*c or b*b+c*c==a*a or c*c+a*a==b*b :
print('YES')
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,057 |
s237099106 | p00003 | u442912414 | 1590996403 | Python | Python3 | py | Accepted | 40 | 5596 | 180 | n=int(input())
for i in range (n):
a=list(map(int,input().split()))
a.sort()
if a[0]**2+a[1]**2==a[2]**2:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,058 |
s009534979 | p00003 | u037263780 | 1590994314 | Python | Python3 | py | Accepted | 40 | 5592 | 187 | n=int(input())
for i in range(1,n+1):
x,y,z=map(int,input().split())
if x**2+y**2==z**2 or y**2+z**2==x**2 or z**2+x**2==y**2:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,059 |
s069996492 | p00003 | u056263240 | 1590989468 | Python | Python3 | py | Accepted | 40 | 5596 | 165 | for i in range(int(input())):
a,b,c=sorted(list(map(int,input().split())))
if (a**2)+(b**2) == (c**2) :
print("YES")
else :
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,060 |
s860392792 | p00003 | u711365732 | 1590988941 | Python | Python3 | py | Accepted | 30 | 5600 | 199 | N = int(input())
for i in range(N):
a,b,c = map(int, input().split())
A = a**2
B = b**2
C = c**2
if A+B==C or A+C==B or B+C==A:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,061 |
s804886884 | p00003 | u497248335 | 1590988778 | Python | Python3 | py | Accepted | 40 | 5592 | 134 | for _ in range(int(input())):
a, b, c = sorted(list(map(int, input().split())))
print("YES" if a**2 + b**2 == c**2 else "NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,062 |
s263042092 | p00003 | u838993229 | 1590986919 | Python | Python3 | py | Accepted | 40 | 5596 | 160 | N = int(input())
for i in range(N):
a,b,c = sorted(map(int,input().split()))
if a**2 + b**2 == c**2:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,063 |
s318003154 | p00003 | u596129030 | 1590985917 | Python | Python3 | py | Accepted | 40 | 5600 | 234 | n=int(input())
for i in range(n):
a,b,c=map(int,input().split())
if a*a==b*b+c*c:
print("YES")
elif b*b==a*a+c*c:
print("YES")
elif c*c==a*a+b*b:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,064 |
s196404901 | p00003 | u514242733 | 1590909876 | Python | Python3 | py | Accepted | 40 | 5592 | 186 | n=input()
n=int(n)
for i in range(n):
a,b,c=map(int,input().split())
if a**2+b**2==c**2 or a**2+c**2==b**2 or b**2+c**2==a**2:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,065 |
s504001931 | p00003 | u795882061 | 1590845722 | Python | Python3 | py | Accepted | 40 | 5600 | 178 | N = int(input())
for i in range(N):
a,b,c = map(int,input().split())
if a*a+b*b==c*c or a*a+c*c==b*b or b*b+c*c==a*a:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,066 |
s395940307 | p00003 | u919773430 | 1590758933 | Python | Python3 | py | Accepted | 50 | 5592 | 264 | x = int(input())
for i in range(x):
a , b , c = list(map(int,input().split()))
if a**2 + b**2 == c**2:
print("YES")
elif a**2 + c**2 == b**2:
print("YES")
elif b**2 + c**2 == a**2:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,067 |
s557255036 | p00003 | u333382219 | 1590633101 | Python | Python3 | py | Accepted | 40 | 5592 | 146 | N = int(input())
for i in range(N):
a, b, c = sorted(map(int, input().split()))
if a*a + b*b == c*c:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,068 |
s172418357 | p00003 | u662362547 | 1590590280 | Python | Python3 | py | Accepted | 40 | 5608 | 128 | for i in range(int(input())):
a,b,c=sorted([int(i) for i in input().split()])
print('YES' if a**2+b**2==c**2 else 'NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,069 |
s259516694 | p00003 | u574841425 | 1590579213 | Python | Python3 | py | Accepted | 30 | 5596 | 425 | i=0
N=int(input())
for i in range(N):
i+=1
a,b,c=map(int,input().split())
if a>=c and a>=b:
if a**2==b**2+c**2:
print('YES')
else:
print('NO')
elif b>=a and b>=c:
if b**2==a**2+c**2:
print('YES')
else:
print('NO')
elif c>=a and c>=b:
if c**2==a**2+b**2:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,070 |
s103440745 | p00003 | u868891301 | 1590556577 | Python | Python3 | py | Accepted | 40 | 5600 | 239 | n=int(input())
for i in range(n):
a,b,c=map(int,input().split())
if a*a+b*b == c*c :
print("YES")
elif b*b+c*c == a*a :
print("YES")
elif c*c+a*a == b*b :
print("YES")
else :
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,071 |
s787074997 | p00003 | u874049078 | 1590503378 | Python | Python3 | py | Accepted | 30 | 5592 | 248 | n = int(input())
for i in range(n):
a, b, c = map(int, input().split())
if a*a + b*b == c*c:
print('YES')
elif a*a + c*c == b*b:
print('YES')
elif b*b + c*c == a*a:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,072 |
s400417005 | p00003 | u206985725 | 1590503288 | Python | Python3 | py | Accepted | 40 | 5596 | 270 | n=int(input())
for i in range(n):
x,y,z=map(int,input().split())
a=x**2
b=y**2
c=z**2
if c==(a+b):
print('YES')
elif b==(a+c):
print('YES')
elif a==(b+c):
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,073 |
s937103631 | p00003 | u695386605 | 1590499160 | Python | Python3 | py | Accepted | 40 | 5592 | 180 | N = int(input())
for i in range (N):
a, b, c = map(int,input().split())
if a*a+b*b==c*c or b*b+c*c==a*a or c*c+a*a==b*b:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,074 |
s944614916 | p00003 | u397004753 | 1590456457 | Python | Python3 | py | Accepted | 40 | 5596 | 142 | N=int(input())
for i in range(1,N+1):
x,y,z=sorted(map(int,input().split()))
if x**2+y**2==z**2:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,075 |
s236389855 | p00003 | u259416836 | 1590456236 | Python | Python3 | py | Accepted | 40 | 5600 | 187 | n=int(input())
for i in range(n):
a,b,c=map(int,input().split())
x=[a,b,c]
x=sorted(x)
if x[2]**2 == x[0]**2 + x[1]**2:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,076 |
s771783733 | p00003 | u799752967 | 1590455867 | Python | Python3 | py | Accepted | 50 | 5592 | 182 | N=int(input())
for i in range(N):
x,y,z=map(int,input().split())
if x**2+y**2==z**2 or y**2+z**2==x**2 or z**2+x**2==y**2:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,077 |
s184887331 | p00003 | u179629761 | 1590415424 | Python | Python3 | py | Accepted | 30 | 5596 | 121 | n=int(input())
for i in range(n):
a,b,c=sorted(map(int,input().split()))
print("YES"if a**2+b**2==c**2 else"NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,078 |
s710225339 | p00003 | u064625546 | 1590403632 | Python | Python3 | py | Accepted | 50 | 5596 | 234 | n=int(input())
i=0
for i in range(n):
a,b,c=map(int,input().split())
if a>b:
a,b=b,a
if b>c:
b,c=c,b
if a>b:
a,b=b,a
if a**2+b**2==c**2:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,079 |
s042139185 | p00003 | u320921262 | 1590390692 | Python | Python3 | py | Accepted | 40 | 5604 | 234 | N=int(input())
for i in range(N):
a,b,c=map(int,input().split())
if a>b:
a,b=b,a
if b>c:
b,c=c,b
if a>b:
a,b=b,a
if (a**2)+(b**2)==(c**2):
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,080 |
s905153083 | p00003 | u506949161 | 1590389781 | Python | Python3 | py | Accepted | 40 | 5600 | 251 | n=int(input())
for i in range(n):
a,b,c=map(int,input().split())
if a**2+b**2==c**2:
print("YES")
elif b**2+c**2==a**2:
print("YES")
elif a**2+c**2==b**2:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,081 |
s223198773 | p00003 | u931484744 | 1590386436 | Python | Python3 | py | Accepted | 40 | 5604 | 282 | # coding: utf-8
# Your code here!
N = int(input())
for i in range(N):
a, b, c = map(int, input().split())
if a > b:
a, b = b, a
if b > c:
b, c = c, b
if a > b:
a, b = b, a
if c * c - a * a - b * b == 0:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,082 |
s584949901 | p00003 | u138194441 | 1590384295 | Python | Python3 | py | Accepted | 40 | 5592 | 146 | T = int(input())
for x in range(0,T) :
a = sorted(map(int,input().split()))
if a[0]**2+a[1]**2 == a[2]**2 :
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,083 |
s434635396 | p00003 | u511292942 | 1590382640 | Python | Python3 | py | Accepted | 40 | 5600 | 176 | n = int(input())
for i in range(n):
x = list(map(int,input().split()))
x.sort()
if x[0]**2 +x[1]**2 == x[2]**2:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,084 |
s919679699 | p00003 | u455994792 | 1590333201 | Python | Python3 | py | Accepted | 40 | 5592 | 256 | N=int(input())
i=1
t=0
while i<N+1:
a,b,c=map(int,input().split())
if a>b:
t=a;a=b;b=t
if b>c:
t=b;b=c;c=t
if a>b:
t=a;a=b;b=t
if a*a + b*b == c*c:
print("YES")
else:
print("NO")
i=i+1
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,085 |
s398429394 | p00003 | u994684803 | 1590243677 | Python | Python3 | py | Accepted | 40 | 5596 | 191 | n=int(input())
for i in range(n):
a,b,c=map(int,input().split())
if c**2 == a**2+b**2 or b**2 == a**2+c**2 or a**2 == c**2+b**2 :
print("YES")
else :
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,086 |
s910206937 | p00003 | u747536722 | 1590228829 | Python | Python3 | py | Accepted | 30 | 5712 | 367 | list_a=[]
list_b=[]
list_c=[]
N=int(input())
for i in range(N):
a,b,c=map(int,input().split())
list_a.append(a)
list_b.append(b)
list_c.append(c)
for i in range(N):
list_a[i],list_b[i],list_c[i]=sorted([list_a[i],list_b[i],list_c[i]])
x=list_a[i]
y=list_b[i]
z=list_c[i]
if x**2+y**2==z**2:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,087 |
s655518961 | p00003 | u918533241 | 1589852268 | Python | Python3 | py | Accepted | 40 | 5592 | 164 | x=int(input())
for i in range(x):
a,b,c=sorted(list(map(int,input().split())))
if (a**2)+(b**2)==(c**2):
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,088 |
s055798380 | p00003 | u695568874 | 1589851842 | Python | Python3 | py | Accepted | 40 | 5596 | 230 | N=int(input())
for i in range(N):
a,b,c=map(int,input().split())
if a*a==b*b+c*c:
print("YES")
elif b*b==a*a+c*c:
print("YES")
elif c*c==a*a+b*b:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,089 |
s204233782 | p00003 | u427834127 | 1589848420 | Python | Python3 | py | Accepted | 40 | 5592 | 239 | N=int(input())
for i in range (N):
a,b,c=map(int,input().split())
if a**2+b**2==c**2:
print("YES")
elif a**2+c**2==b**2:
print("YES")
elif b**2+c**2==a**2:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,090 |
s166476403 | p00003 | u228556128 | 1589802165 | Python | Python3 | py | Accepted | 40 | 5600 | 131 | a=int(input())
for _ in range(a):
x,y,z=sorted(list(map(int,input().split())))
print("YES" if x**2+y**2==z**2 else "NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,091 |
s342000151 | p00003 | u371026526 | 1589786209 | Python | Python3 | py | Accepted | 40 | 5600 | 315 | N = int(input())
i=0
while i < N:
x,y,z = map(int,input().split())
if x<=z and y<=z:
if z**2 == x**2+y**2: print("YES")
else: print("NO")
elif x<=y and z<=y:
if y**2 == x**2+z**2: print("YES")
else: print("NO")
else:
if x**2 == y**2+z**2: print("YES")
else: print("NO")
i += 1
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,092 |
s606057169 | p00003 | u419548414 | 1589785550 | Python | Python3 | py | Accepted | 50 | 5596 | 312 | a=int(input())
for i in range(a):
x,y,r=map(int,input().split())
l=[]
l.append(x)
l.append(y)
l.append(r)
for t in range(2):
if l[t]>l[t+1]:
l[t],l[t+1]=l[t+1],l[t]
if (l[0]**2)+(l[1]**2)==l[2]**2:
print("YES")
else:
print("NO")
del l
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,093 |
s978555906 | p00003 | u470391435 | 1589778442 | Python | Python3 | py | Accepted | 40 | 5596 | 298 | def san(a,b,c):
if (a**2)==(b**2)+(c**2):
print('YES')
elif (b**2)==(a**2)+(c**2):
print('YES')
elif (c**2)==(b**2)+(a**2):
print('YES')
else:
print('NO')
N = int(input())
for i in range(N):
x, y, z = map(int,input().split())
san(x,y,z)
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,094 |
s340076501 | p00003 | u705625724 | 1589778077 | Python | Python3 | py | Accepted | 40 | 5596 | 232 | # coding: utf-8
# Your code here!
N = int(input())
for i in range(N):
a,b,c = map(int,input().split())
a = a*a
b = b*b
c = c*c
if a==b+c or b==a+c or c==a+b:
print('YES')
else:
print('NO')
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,095 |
s108543383 | p00003 | u192469946 | 1589778039 | Python | Python3 | py | Accepted | 40 | 5596 | 349 | #volume0 0003
N = int(input())
for i in range(N):
x , y , z= map(int,input().split())
if x > y:
min = x
x = y
y = min
if y > z:
mid = y
y = z
z = mid
if x > y:
min = x
x = y
y = min
if z**2 == x**2 + y**2:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,096 |
s246889477 | p00003 | u894788865 | 1589766943 | Python | Python3 | py | Accepted | 40 | 5592 | 168 | n = int(input())
for i in range(n):
a,b,c=map(int,input().split())
a=a*a
b=b*b
c=c*c
if a+b==c or a+c==b or b+c==a:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,097 |
s416858954 | p00003 | u904289400 | 1589688362 | Python | Python3 | py | Accepted | 40 | 5596 | 287 | i=1
N=int(input())
while i<=N:
x,y,z=map(int,input().split())
if x**2+y**2==z**2:
print('YES')
i+=1
elif y**2+z**2==x**2:
print('YES')
i+=1
elif x**2+z**2==y**2:
print('YES')
i+=1
else:
print('NO')
i+=1
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,098 |
s812393444 | p00003 | u171326376 | 1589687925 | Python | Python3 | py | Accepted | 40 | 5600 | 262 | N = int(input())
i = 1
for i in range(1,N+1):
a,b,c = map(int,input().split())
if a>b:
a,b = b,a
if b>c:
b,c = c,b
if a>c:
a,c = c,a
if a**2+b**2 == c**2:
print('YES')
else:
print('NO')
i += 1
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,099 |
s546942658 | p00003 | u677563181 | 1589628894 | Python | Python3 | py | Accepted | 40 | 5596 | 194 | x=int(input())
for i in range(x):
a, b, c=list(map(int ,input().split()))
s=[a**2,b**2,c**2]
t=sorted(s)
if t[0]+t[1]==t[2]:
print("YES")
else:
print("NO")
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,100 |
s767796219 | p00003 | u577978368 | 1589626532 | Python | Python3 | py | Accepted | 40 | 5592 | 235 | n=int(input())
i=0
while i<n:
a,b,c=map(int,input().split())
if a*a+b*b==c*c:
print("YES")
elif a*a+c*c==b*b:
print("YES")
elif b*b+c*c==a*a:
print("YES")
else:
print("NO")
i=i+1
| p00003 |
<H1>Is it a Right Triangle?</H1>
<p>
Write a program which judges wheather given length of three side form a right triangle. Print "<span>YES</span>" if the given sides (integers) form a right triangle, "<span>NO</span>" if not so.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. In the first line, the number of data set, <var>N</var> is given. Then, <var>N</var> lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.
</p>
<h2>Constraints</h2>
<ul>
<li> 1 ≤ length of the side ≤ 1,000</li>
<li> <var>N</var> ≤ 1,000</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print "<span>YES</span>" or "<span>NO</span>".
</p>
<H2>Sample Input</H2>
<pre>
3
4 3 5
4 3 6
8 8 8
</pre>
<H2>Output for the Sample Input</H2>
<pre>
YES
NO
NO
</pre>
| 3
4 3 5
4 3 6
8 8 8
| YES
NO
NO
| 3,101 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.