message stringlengths 2 44.5k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 276 109k | cluster float64 23 23 | __index_level_0__ int64 552 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Like any unknown mathematician, Yuri has favourite numbers: A, B, C, and D, where A ≤ B ≤ C ≤ D. Yuri also likes triangles and once he thought: how many non-degenerate triangles with integer sides x, y, and z exist, such that A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds?
Yuri is preparing problems for a new contest now, so he is very busy. That's why he asked you to calculate the number of triangles with described property.
The triangle is called non-degenerate if and only if its vertices are not collinear.
Input
The first line contains four integers: A, B, C and D (1 ≤ A ≤ B ≤ C ≤ D ≤ 5 ⋅ 10^5) — Yuri's favourite numbers.
Output
Print the number of non-degenerate triangles with integer sides x, y, and z such that the inequality A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds.
Examples
Input
1 2 3 4
Output
4
Input
1 2 2 5
Output
3
Input
500000 500000 500000 500000
Output
1
Note
In the first example Yuri can make up triangles with sides (1, 3, 3), (2, 2, 3), (2, 3, 3) and (2, 3, 4).
In the second example Yuri can make up triangles with sides (1, 2, 2), (2, 2, 2) and (2, 2, 3).
In the third example Yuri can make up only one equilateral triangle with sides equal to 5 ⋅ 10^5. | instruction | 0 | 20,421 | 23 | 40,842 |
Tags: binary search, implementation, math, two pointers
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
from collections import Counter
import math as mt
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def gcd(a, b):
if a == 0:
return b
return gcd(b % a, a)
def lcm(a, b):
return (a * b) / gcd(a, b)
mod = int(1e9) + 7
def power(k, n):
if n == 0:
return 1
if n % 2:
return (power(k, n - 1) * k) % mod
t = power(k, n // 2)
return (t * t) % mod
def totalPrimeFactors(n):
count = 0
if (n % 2) == 0:
count += 1
while (n % 2) == 0:
n //= 2
i = 3
while i * i <= n:
if (n % i) == 0:
count += 1
while (n % i) == 0:
n //= i
i += 2
if n > 2:
count += 1
return count
# #MAXN = int(1e7 + 1)
# # spf = [0 for i in range(MAXN)]
#
#
# def sieve():
# spf[1] = 1
# for i in range(2, MAXN):
# spf[i] = i
# for i in range(4, MAXN, 2):
# spf[i] = 2
#
# for i in range(3, mt.ceil(mt.sqrt(MAXN))):
# if (spf[i] == i):
# for j in range(i * i, MAXN, i):
# if (spf[j] == j):
# spf[j] = i
#
#
# def getFactorization(x):
# ret = 0
# while (x != 1):
# k = spf[x]
# ret += 1
# # ret.add(spf[x])
# while x % k == 0:
# x //= k
#
# return ret
# Driver code
# precalculating Smallest Prime Factor
# sieve()
# absolutely crazy!.... ashishgup orz
def main():
a, b, c, d = map(int, input().split())
pre = [0 for i in range(c + b + 10)]
for i in range(a, b + 1):
pre[b + i] += 1
pre[c + i + 1] -= 1
curr = 0
ans = 0
for i in range(len(pre)):
curr += pre[i]
if i > c:
ans += curr * ( min(i-1, d)-c + 1)
print(ans)
return
if __name__ == "__main__":
main()
``` | output | 1 | 20,421 | 23 | 40,843 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Like any unknown mathematician, Yuri has favourite numbers: A, B, C, and D, where A ≤ B ≤ C ≤ D. Yuri also likes triangles and once he thought: how many non-degenerate triangles with integer sides x, y, and z exist, such that A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds?
Yuri is preparing problems for a new contest now, so he is very busy. That's why he asked you to calculate the number of triangles with described property.
The triangle is called non-degenerate if and only if its vertices are not collinear.
Input
The first line contains four integers: A, B, C and D (1 ≤ A ≤ B ≤ C ≤ D ≤ 5 ⋅ 10^5) — Yuri's favourite numbers.
Output
Print the number of non-degenerate triangles with integer sides x, y, and z such that the inequality A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds.
Examples
Input
1 2 3 4
Output
4
Input
1 2 2 5
Output
3
Input
500000 500000 500000 500000
Output
1
Note
In the first example Yuri can make up triangles with sides (1, 3, 3), (2, 2, 3), (2, 3, 3) and (2, 3, 4).
In the second example Yuri can make up triangles with sides (1, 2, 2), (2, 2, 2) and (2, 2, 3).
In the third example Yuri can make up only one equilateral triangle with sides equal to 5 ⋅ 10^5. | instruction | 0 | 20,422 | 23 | 40,844 |
Tags: binary search, implementation, math, two pointers
Correct Solution:
```
a, b, c, d = map(int, input().split())
prefsum = [0]*(b+c+2)
# O(linear)
for i in range(a, b+1):
# all (x, y) sums between (i+b, i+c) are possible
prefsum[i + b] += 1
prefsum[i+c+1] += -1
# Get the prefix sum
for i in range(1, len(prefsum)):
prefsum[i] += prefsum[i-1]
# print(prefsum)
# Get the cummulative sum. # of (x, y) where x+y <= i
for i in range(1, len(prefsum)):
prefsum[i] += prefsum[i-1]
# print(prefsum)
# O(linear)
ans = 0
for z in range(c, d+1):
# no. of z's for which z<(x+y)
if z < (b+c+2):
ans += (prefsum[-1]-prefsum[z])
else: break
print(ans)
``` | output | 1 | 20,422 | 23 | 40,845 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Like any unknown mathematician, Yuri has favourite numbers: A, B, C, and D, where A ≤ B ≤ C ≤ D. Yuri also likes triangles and once he thought: how many non-degenerate triangles with integer sides x, y, and z exist, such that A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds?
Yuri is preparing problems for a new contest now, so he is very busy. That's why he asked you to calculate the number of triangles with described property.
The triangle is called non-degenerate if and only if its vertices are not collinear.
Input
The first line contains four integers: A, B, C and D (1 ≤ A ≤ B ≤ C ≤ D ≤ 5 ⋅ 10^5) — Yuri's favourite numbers.
Output
Print the number of non-degenerate triangles with integer sides x, y, and z such that the inequality A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds.
Examples
Input
1 2 3 4
Output
4
Input
1 2 2 5
Output
3
Input
500000 500000 500000 500000
Output
1
Note
In the first example Yuri can make up triangles with sides (1, 3, 3), (2, 2, 3), (2, 3, 3) and (2, 3, 4).
In the second example Yuri can make up triangles with sides (1, 2, 2), (2, 2, 2) and (2, 2, 3).
In the third example Yuri can make up only one equilateral triangle with sides equal to 5 ⋅ 10^5. | instruction | 0 | 20,423 | 23 | 40,846 |
Tags: binary search, implementation, math, two pointers
Correct Solution:
```
x = input().split(' ')
A = int(x[0])
B = int(x[1])
C = int(x[2])
D = int(x[3])
def gauss_count(n):
if n <= 0: return 0
return n*(n+1)//2
count = 0
for z in range(C, D+1):
if A + B > z:
count += (B-A+1) * (C-B+1)
continue
x0 = z-C+1
y0 = z-B+1
incl1 = gauss_count(B-x0+1)
excl1 = gauss_count(A-x0)
excl2 = gauss_count(B-y0)
count += max(0, incl1 - excl1 - excl2)
print(count)
``` | output | 1 | 20,423 | 23 | 40,847 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Like any unknown mathematician, Yuri has favourite numbers: A, B, C, and D, where A ≤ B ≤ C ≤ D. Yuri also likes triangles and once he thought: how many non-degenerate triangles with integer sides x, y, and z exist, such that A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds?
Yuri is preparing problems for a new contest now, so he is very busy. That's why he asked you to calculate the number of triangles with described property.
The triangle is called non-degenerate if and only if its vertices are not collinear.
Input
The first line contains four integers: A, B, C and D (1 ≤ A ≤ B ≤ C ≤ D ≤ 5 ⋅ 10^5) — Yuri's favourite numbers.
Output
Print the number of non-degenerate triangles with integer sides x, y, and z such that the inequality A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds.
Examples
Input
1 2 3 4
Output
4
Input
1 2 2 5
Output
3
Input
500000 500000 500000 500000
Output
1
Note
In the first example Yuri can make up triangles with sides (1, 3, 3), (2, 2, 3), (2, 3, 3) and (2, 3, 4).
In the second example Yuri can make up triangles with sides (1, 2, 2), (2, 2, 2) and (2, 2, 3).
In the third example Yuri can make up only one equilateral triangle with sides equal to 5 ⋅ 10^5. | instruction | 0 | 20,424 | 23 | 40,848 |
Tags: binary search, implementation, math, two pointers
Correct Solution:
```
(A, B, C, D) = map(int, input().split())
X = (A, B)
Y = (B, C)
Z = (C, D)
z_max = min(B + C - 1, D)
z_min = C
ans = 0
for z in range(z_min, z_max + 1):
x_min = max(0, A)
x_max = min(B, z)
y_min = max(0, B)
y_max = min(C, z)
if z < x_min + y_min:
ans += (x_max - x_min + 1) * (y_max - y_min + 1)
#print('!5',z,(x_max - x_min + 1) * (y_max - y_min + 1))
elif z > x_max + y_max:
continue
else:
z_up = z - y_max # x
z_down = z - y_min # x
z_left = z - x_min # y
z_right = z - x_max # y
if z_left <= y_max and z_left >= y_min:
if z_down <= x_max and z_down >= x_min:
ans += (x_max - x_min + 1) * (y_max - y_min + 1) - (z_left - y_min + 1) * (z_left - y_min + 2) // 2
#print('!4',z,(x_max - x_min + 1) * (y_max - y_min + 1) - (z_left - y_min + 1) * (z_left - y_min + 2) // 2)
else:
ke = y_max - z_right
ek = y_max - z_left
ans += (ke-ek+1)*(ke+ek)//2
#print('!3',z,(y_max - z_right) * (y_max - z_right + 1) // 2)
else:
if z_right <= y_max and z_right >= y_min:
ans += (y_max - z_right + 1) * (y_max - z_right) // 2
#print('!2',z,(y_max - z_right + 1) * (y_max - z_right) // 2)
else:
ans += (y_max - y_min + 1) * (x_max - z_up + x_max - z_down) // 2
#print('!1',z,(y_max - y_min + 1) * (x_max - z_up + x_max - z_down) // 2)
print(ans)
``` | output | 1 | 20,424 | 23 | 40,849 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Like any unknown mathematician, Yuri has favourite numbers: A, B, C, and D, where A ≤ B ≤ C ≤ D. Yuri also likes triangles and once he thought: how many non-degenerate triangles with integer sides x, y, and z exist, such that A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds?
Yuri is preparing problems for a new contest now, so he is very busy. That's why he asked you to calculate the number of triangles with described property.
The triangle is called non-degenerate if and only if its vertices are not collinear.
Input
The first line contains four integers: A, B, C and D (1 ≤ A ≤ B ≤ C ≤ D ≤ 5 ⋅ 10^5) — Yuri's favourite numbers.
Output
Print the number of non-degenerate triangles with integer sides x, y, and z such that the inequality A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds.
Examples
Input
1 2 3 4
Output
4
Input
1 2 2 5
Output
3
Input
500000 500000 500000 500000
Output
1
Note
In the first example Yuri can make up triangles with sides (1, 3, 3), (2, 2, 3), (2, 3, 3) and (2, 3, 4).
In the second example Yuri can make up triangles with sides (1, 2, 2), (2, 2, 2) and (2, 2, 3).
In the third example Yuri can make up only one equilateral triangle with sides equal to 5 ⋅ 10^5. | instruction | 0 | 20,425 | 23 | 40,850 |
Tags: binary search, implementation, math, two pointers
Correct Solution:
```
import sys
ints = (int(x) for x in sys.stdin.read().split())
sys.setrecursionlimit(3000)
def main():
a,b,c,d = (next(ints) for i in range(4))
ans = 0
A = (b-a+1)*(c-b+1)
h = min(c-b, b-a)
lo, hi = min(a+c, b+b), max(a+c, b+b)
for z in range(min(a+b, c), d+1):
if z < a+b: pass
elif z < lo: A -= 1 + z - (a+b)
elif z < hi: A -= 1 + h
elif z <= b+c: A -= 1 + (b+c) - z
else: assert A==0
if c<=z<=d:
ans += A
print(ans)
#s = sum(x+y>z for x in range(a,b+1) for y in range(b,c+1) for z in range(c,d+1))
#assert ans==s, (ans, s)
return
main()
``` | output | 1 | 20,425 | 23 | 40,851 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Like any unknown mathematician, Yuri has favourite numbers: A, B, C, and D, where A ≤ B ≤ C ≤ D. Yuri also likes triangles and once he thought: how many non-degenerate triangles with integer sides x, y, and z exist, such that A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds?
Yuri is preparing problems for a new contest now, so he is very busy. That's why he asked you to calculate the number of triangles with described property.
The triangle is called non-degenerate if and only if its vertices are not collinear.
Input
The first line contains four integers: A, B, C and D (1 ≤ A ≤ B ≤ C ≤ D ≤ 5 ⋅ 10^5) — Yuri's favourite numbers.
Output
Print the number of non-degenerate triangles with integer sides x, y, and z such that the inequality A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds.
Examples
Input
1 2 3 4
Output
4
Input
1 2 2 5
Output
3
Input
500000 500000 500000 500000
Output
1
Note
In the first example Yuri can make up triangles with sides (1, 3, 3), (2, 2, 3), (2, 3, 3) and (2, 3, 4).
In the second example Yuri can make up triangles with sides (1, 2, 2), (2, 2, 2) and (2, 2, 3).
In the third example Yuri can make up only one equilateral triangle with sides equal to 5 ⋅ 10^5. | instruction | 0 | 20,426 | 23 | 40,852 |
Tags: binary search, implementation, math, two pointers
Correct Solution:
```
import os
import sys
if os.path.exists('/mnt/c/Users/Square/square/codeforces'):
f = iter(open('C.txt').readlines())
def input():
return next(f)
else:
input = lambda: sys.stdin.readline().strip()
fprint = lambda *args: print(*args, flush=True)
A, B, C, D = map(int, input().split())
s = 0
def f(K):
if K <= 0:
return 0
return (K*(K+1)) // 2
for x in range(A, B+1):
T = x
L = min(C - B, T)
R = min(D - C, T)
# print(T, L, R)
# print(f(T), f(T-L), f(T-R), f(T-R-L))
s += f(T)
s -= f(T-L-1)
s -= f(T-R-1)
s += f(T-R-L-2)
# print()
print(s)
``` | output | 1 | 20,426 | 23 | 40,853 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Like any unknown mathematician, Yuri has favourite numbers: A, B, C, and D, where A ≤ B ≤ C ≤ D. Yuri also likes triangles and once he thought: how many non-degenerate triangles with integer sides x, y, and z exist, such that A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds?
Yuri is preparing problems for a new contest now, so he is very busy. That's why he asked you to calculate the number of triangles with described property.
The triangle is called non-degenerate if and only if its vertices are not collinear.
Input
The first line contains four integers: A, B, C and D (1 ≤ A ≤ B ≤ C ≤ D ≤ 5 ⋅ 10^5) — Yuri's favourite numbers.
Output
Print the number of non-degenerate triangles with integer sides x, y, and z such that the inequality A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds.
Examples
Input
1 2 3 4
Output
4
Input
1 2 2 5
Output
3
Input
500000 500000 500000 500000
Output
1
Note
In the first example Yuri can make up triangles with sides (1, 3, 3), (2, 2, 3), (2, 3, 3) and (2, 3, 4).
In the second example Yuri can make up triangles with sides (1, 2, 2), (2, 2, 2) and (2, 2, 3).
In the third example Yuri can make up only one equilateral triangle with sides equal to 5 ⋅ 10^5. | instruction | 0 | 20,427 | 23 | 40,854 |
Tags: binary search, implementation, math, two pointers
Correct Solution:
```
a, b, c, d = map(int, input().split())
ans = 0
ru = [0] * (10 ** 6 + 10)
for x in range(a, b + 1):
l = x + b
r = x + c + 1
ru[l] += 1
ru[r] -= 1
#print(ru[:d+5])
for i in range(10 ** 6 + 9):
ru[i + 1] += ru[i]
#print(ru[:d+5])
for i in range(10 ** 6 + 9):
ru[i + 1] += ru[i]
#print(ru[:d+5])
ans = 0
for z in range(c, d + 1):
ans += ru[-1] - ru[z]
print(ans)
``` | output | 1 | 20,427 | 23 | 40,855 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Like any unknown mathematician, Yuri has favourite numbers: A, B, C, and D, where A ≤ B ≤ C ≤ D. Yuri also likes triangles and once he thought: how many non-degenerate triangles with integer sides x, y, and z exist, such that A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds?
Yuri is preparing problems for a new contest now, so he is very busy. That's why he asked you to calculate the number of triangles with described property.
The triangle is called non-degenerate if and only if its vertices are not collinear.
Input
The first line contains four integers: A, B, C and D (1 ≤ A ≤ B ≤ C ≤ D ≤ 5 ⋅ 10^5) — Yuri's favourite numbers.
Output
Print the number of non-degenerate triangles with integer sides x, y, and z such that the inequality A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds.
Examples
Input
1 2 3 4
Output
4
Input
1 2 2 5
Output
3
Input
500000 500000 500000 500000
Output
1
Note
In the first example Yuri can make up triangles with sides (1, 3, 3), (2, 2, 3), (2, 3, 3) and (2, 3, 4).
In the second example Yuri can make up triangles with sides (1, 2, 2), (2, 2, 2) and (2, 2, 3).
In the third example Yuri can make up only one equilateral triangle with sides equal to 5 ⋅ 10^5.
Submitted Solution:
```
a,b,c,d=map(int,input().split())
num=[0]*(b+c+1)
for i in range(a,b+1):
num[i+b-1]+=1
num[i+c]-=1
from itertools import accumulate
num=list(accumulate(num))
ans=0
for i in range(len(num)):
ans+=num[i]*min(max(i+1-c,0),d-c+1)
print(ans)
``` | instruction | 0 | 20,428 | 23 | 40,856 |
Yes | output | 1 | 20,428 | 23 | 40,857 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Like any unknown mathematician, Yuri has favourite numbers: A, B, C, and D, where A ≤ B ≤ C ≤ D. Yuri also likes triangles and once he thought: how many non-degenerate triangles with integer sides x, y, and z exist, such that A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds?
Yuri is preparing problems for a new contest now, so he is very busy. That's why he asked you to calculate the number of triangles with described property.
The triangle is called non-degenerate if and only if its vertices are not collinear.
Input
The first line contains four integers: A, B, C and D (1 ≤ A ≤ B ≤ C ≤ D ≤ 5 ⋅ 10^5) — Yuri's favourite numbers.
Output
Print the number of non-degenerate triangles with integer sides x, y, and z such that the inequality A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds.
Examples
Input
1 2 3 4
Output
4
Input
1 2 2 5
Output
3
Input
500000 500000 500000 500000
Output
1
Note
In the first example Yuri can make up triangles with sides (1, 3, 3), (2, 2, 3), (2, 3, 3) and (2, 3, 4).
In the second example Yuri can make up triangles with sides (1, 2, 2), (2, 2, 2) and (2, 2, 3).
In the third example Yuri can make up only one equilateral triangle with sides equal to 5 ⋅ 10^5.
Submitted Solution:
```
a,b,c,d=map(int,input().split())
j=a
s=0
while(j<=b):
l=j+b
r=j+c
p = l - c
q = r - c
if l>d:
s+=(r-l+1)*(d-c+1)
elif r>d and l<=d:
if p>0:
s+=(r-d)*(d-c+1)+(((d-c)*(d-c+1)) // 2) - (((p - 1) * p) // 2)
else:
s+=(r - d)*(d - c + 1) + (((d - c) * (d - c + 1)) // 2)
elif r<=d:
if p <= 0 and q <= 0:
s += 0
elif p <= 0 and q > 0:
s += q * (q + 1) // 2
elif p > 0 and q > 0:
s += (q * (q + 1) // 2) - (((p - 1) * p) // 2)
j+=1
print(s)
``` | instruction | 0 | 20,429 | 23 | 40,858 |
Yes | output | 1 | 20,429 | 23 | 40,859 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Like any unknown mathematician, Yuri has favourite numbers: A, B, C, and D, where A ≤ B ≤ C ≤ D. Yuri also likes triangles and once he thought: how many non-degenerate triangles with integer sides x, y, and z exist, such that A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds?
Yuri is preparing problems for a new contest now, so he is very busy. That's why he asked you to calculate the number of triangles with described property.
The triangle is called non-degenerate if and only if its vertices are not collinear.
Input
The first line contains four integers: A, B, C and D (1 ≤ A ≤ B ≤ C ≤ D ≤ 5 ⋅ 10^5) — Yuri's favourite numbers.
Output
Print the number of non-degenerate triangles with integer sides x, y, and z such that the inequality A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds.
Examples
Input
1 2 3 4
Output
4
Input
1 2 2 5
Output
3
Input
500000 500000 500000 500000
Output
1
Note
In the first example Yuri can make up triangles with sides (1, 3, 3), (2, 2, 3), (2, 3, 3) and (2, 3, 4).
In the second example Yuri can make up triangles with sides (1, 2, 2), (2, 2, 2) and (2, 2, 3).
In the third example Yuri can make up only one equilateral triangle with sides equal to 5 ⋅ 10^5.
Submitted Solution:
```
a,b,c,d=map(int,input().split())
ans=0
for t in range(a+b,b+c+1):
M=min(b,t-b)
m=max(a,t-c)
dx=M-m+1
if c<=t-1<=d:
dx*=t-1-c+1
ans+=dx
elif t-1>d:
dx*=d-c+1
ans+=dx
print(ans)
``` | instruction | 0 | 20,430 | 23 | 40,860 |
Yes | output | 1 | 20,430 | 23 | 40,861 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Like any unknown mathematician, Yuri has favourite numbers: A, B, C, and D, where A ≤ B ≤ C ≤ D. Yuri also likes triangles and once he thought: how many non-degenerate triangles with integer sides x, y, and z exist, such that A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds?
Yuri is preparing problems for a new contest now, so he is very busy. That's why he asked you to calculate the number of triangles with described property.
The triangle is called non-degenerate if and only if its vertices are not collinear.
Input
The first line contains four integers: A, B, C and D (1 ≤ A ≤ B ≤ C ≤ D ≤ 5 ⋅ 10^5) — Yuri's favourite numbers.
Output
Print the number of non-degenerate triangles with integer sides x, y, and z such that the inequality A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds.
Examples
Input
1 2 3 4
Output
4
Input
1 2 2 5
Output
3
Input
500000 500000 500000 500000
Output
1
Note
In the first example Yuri can make up triangles with sides (1, 3, 3), (2, 2, 3), (2, 3, 3) and (2, 3, 4).
In the second example Yuri can make up triangles with sides (1, 2, 2), (2, 2, 2) and (2, 2, 3).
In the third example Yuri can make up only one equilateral triangle with sides equal to 5 ⋅ 10^5.
Submitted Solution:
```
[a,b,c,d] = input().split(' ')
a = int(a)
b = int(b)
c = int(c)
d = int(d)
def f(x):
if x<1:
return 0
else:
return x*(x+1)*(x+2)//6
print((a+2*b-c)*(b+1-a)*(c+1-b)//2 + f(c-a-b) - f(c-2*b-1) - f(b+c-d-1) + f(a+c-d-2) + f(2*b-d-2) - f(a+b-d-3))
``` | instruction | 0 | 20,431 | 23 | 40,862 |
Yes | output | 1 | 20,431 | 23 | 40,863 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Like any unknown mathematician, Yuri has favourite numbers: A, B, C, and D, where A ≤ B ≤ C ≤ D. Yuri also likes triangles and once he thought: how many non-degenerate triangles with integer sides x, y, and z exist, such that A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds?
Yuri is preparing problems for a new contest now, so he is very busy. That's why he asked you to calculate the number of triangles with described property.
The triangle is called non-degenerate if and only if its vertices are not collinear.
Input
The first line contains four integers: A, B, C and D (1 ≤ A ≤ B ≤ C ≤ D ≤ 5 ⋅ 10^5) — Yuri's favourite numbers.
Output
Print the number of non-degenerate triangles with integer sides x, y, and z such that the inequality A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds.
Examples
Input
1 2 3 4
Output
4
Input
1 2 2 5
Output
3
Input
500000 500000 500000 500000
Output
1
Note
In the first example Yuri can make up triangles with sides (1, 3, 3), (2, 2, 3), (2, 3, 3) and (2, 3, 4).
In the second example Yuri can make up triangles with sides (1, 2, 2), (2, 2, 2) and (2, 2, 3).
In the third example Yuri can make up only one equilateral triangle with sides equal to 5 ⋅ 10^5.
Submitted Solution:
```
import sys
readline = sys.stdin.readline
readall = sys.stdin.read
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')
def solve():
a, b, c, d = nm()
m = 10 ** 6 + 10
l = [0] * m
for i in range(a, b + 1):
l[i + b] += 1
l[i + c + 1] += -1
for i in range(m - 1):
l[i] += l[i - 1]
# for i in range(m - 2, -1, -1):
# l[i] += l[i + 1]
print(sum(l[i + 1] for i in range(c, d + 1)))
return
solve()
``` | instruction | 0 | 20,432 | 23 | 40,864 |
No | output | 1 | 20,432 | 23 | 40,865 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Like any unknown mathematician, Yuri has favourite numbers: A, B, C, and D, where A ≤ B ≤ C ≤ D. Yuri also likes triangles and once he thought: how many non-degenerate triangles with integer sides x, y, and z exist, such that A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds?
Yuri is preparing problems for a new contest now, so he is very busy. That's why he asked you to calculate the number of triangles with described property.
The triangle is called non-degenerate if and only if its vertices are not collinear.
Input
The first line contains four integers: A, B, C and D (1 ≤ A ≤ B ≤ C ≤ D ≤ 5 ⋅ 10^5) — Yuri's favourite numbers.
Output
Print the number of non-degenerate triangles with integer sides x, y, and z such that the inequality A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds.
Examples
Input
1 2 3 4
Output
4
Input
1 2 2 5
Output
3
Input
500000 500000 500000 500000
Output
1
Note
In the first example Yuri can make up triangles with sides (1, 3, 3), (2, 2, 3), (2, 3, 3) and (2, 3, 4).
In the second example Yuri can make up triangles with sides (1, 2, 2), (2, 2, 2) and (2, 2, 3).
In the third example Yuri can make up only one equilateral triangle with sides equal to 5 ⋅ 10^5.
Submitted Solution:
```
'''
Auther: ghoshashis545 Ashis Ghosh
College: jalpaiguri Govt Enggineerin College
Date:24/05/2020
'''
import sys
from collections import deque,defaultdict as dd
from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
from itertools import permutations
from datetime import datetime
from math import ceil,sqrt,log,gcd
def ii():return int(input())
def si():return input()
def mi():return map(int,input().split())
def li():return list(mi())
abc='abcdefghijklmnopqrstuvwxyz'
abd={'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod=1000000007
#mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def read():
tc=0
if tc:
input=sys.stdin.readline
else:
sys.stdin=open('input1.txt', 'r')
sys.stdout=open('output1.txt','w')
def solve():
a,b,c,d=mi()
ans=0
for i in range(c,min(b+c-1,d)+1):
x1=max((i-b+1),a)
x=(b-x1+1)
a1=min((x1-a),(b-a+1))
b1=c-b
m=min(a1,b1)
# print(x1,a1,x,b1)
ans1=(m+1)*x+(m*(m+1)//2)
ans+=ans1
print(ans)
if __name__ =="__main__":
# read()
solve()
``` | instruction | 0 | 20,433 | 23 | 40,866 |
No | output | 1 | 20,433 | 23 | 40,867 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Like any unknown mathematician, Yuri has favourite numbers: A, B, C, and D, where A ≤ B ≤ C ≤ D. Yuri also likes triangles and once he thought: how many non-degenerate triangles with integer sides x, y, and z exist, such that A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds?
Yuri is preparing problems for a new contest now, so he is very busy. That's why he asked you to calculate the number of triangles with described property.
The triangle is called non-degenerate if and only if its vertices are not collinear.
Input
The first line contains four integers: A, B, C and D (1 ≤ A ≤ B ≤ C ≤ D ≤ 5 ⋅ 10^5) — Yuri's favourite numbers.
Output
Print the number of non-degenerate triangles with integer sides x, y, and z such that the inequality A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds.
Examples
Input
1 2 3 4
Output
4
Input
1 2 2 5
Output
3
Input
500000 500000 500000 500000
Output
1
Note
In the first example Yuri can make up triangles with sides (1, 3, 3), (2, 2, 3), (2, 3, 3) and (2, 3, 4).
In the second example Yuri can make up triangles with sides (1, 2, 2), (2, 2, 2) and (2, 2, 3).
In the third example Yuri can make up only one equilateral triangle with sides equal to 5 ⋅ 10^5.
Submitted Solution:
```
a, b, c, d = map(int, input().split())
ans = 0
for i in range(a, b + 1):
j = b
if i + j <= c:
j = c - i + 1
if i + j == d:
ans += d - c
j += 1
if j <= c:
if c < i + b < d:
num = i + j - c
length = min(d - (i + j), c - j + 1)
ans += (num + length - 1) * (num + length) // 2 - num * (num - 1) // 2
if d - (i + j) < c - j + 1:
ans += d - c
j += d - (i + j) + 1
if c < i + j:
ans += (d - c + 1) * (c - j + 1)
elif c < i + j:
ans += (d - c + 1) * (c - j + 1)
print(ans)
``` | instruction | 0 | 20,434 | 23 | 40,868 |
No | output | 1 | 20,434 | 23 | 40,869 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Like any unknown mathematician, Yuri has favourite numbers: A, B, C, and D, where A ≤ B ≤ C ≤ D. Yuri also likes triangles and once he thought: how many non-degenerate triangles with integer sides x, y, and z exist, such that A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds?
Yuri is preparing problems for a new contest now, so he is very busy. That's why he asked you to calculate the number of triangles with described property.
The triangle is called non-degenerate if and only if its vertices are not collinear.
Input
The first line contains four integers: A, B, C and D (1 ≤ A ≤ B ≤ C ≤ D ≤ 5 ⋅ 10^5) — Yuri's favourite numbers.
Output
Print the number of non-degenerate triangles with integer sides x, y, and z such that the inequality A ≤ x ≤ B ≤ y ≤ C ≤ z ≤ D holds.
Examples
Input
1 2 3 4
Output
4
Input
1 2 2 5
Output
3
Input
500000 500000 500000 500000
Output
1
Note
In the first example Yuri can make up triangles with sides (1, 3, 3), (2, 2, 3), (2, 3, 3) and (2, 3, 4).
In the second example Yuri can make up triangles with sides (1, 2, 2), (2, 2, 2) and (2, 2, 3).
In the third example Yuri can make up only one equilateral triangle with sides equal to 5 ⋅ 10^5.
Submitted Solution:
```
class SegmentTree:
def __init__(self, data, default=0, func=lambda a,b:gcd(a,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# ------------------- fast io --------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------- fast io --------------------
from bisect import bisect_right, bisect_left
from fractions import Fraction
def pre(s):
n = len(s)
pi=[0]*n
for i in range(1,n):
j = pi[i-1]
while j and s[i] != s[j]:
j = pi[j-1]
if s[i] == s[j]:
j += 1
pi[i] = j
return pi
def prod(a):
ans = 1
for each in a:
ans = (ans * each)
return ans
from math import gcd
def lcm(a,b):return a*b//gcd(a,b)
def binary(x, length=16):
y = bin(x)[2:]
return y if len(y) >= length else "0"*(length - len(y)) + y
def sumrange(a,b):
return a*(b-a+1) + (b-a)*(b-a+1)//2
for _ in range(1):
#a, k = map(int, input().split())
a, b, c, d = map(int, input().split())
if a == d == 1:
print(0)
continue
#x, y = map(int, input().split())
#a = list(map(int, input().split()))
#sm = sum(a)
#for i in range(n):
#s = input()
#print("YES" if s else "NO")
ans = 0
for i in range(a, b+1):
if i + b > d:
ans += (d-c+1)*(c-b+1)
#print("Here")
elif i + b == d:
ans += (i+b-c) + (d-c+1)*(c-b)
elif i + c <= d:
#print(i+b, i+c, sumrange(3,4))
ans += sumrange(i+b, i+c) - c*(c-b+1)
else:
mid = d-i
its = mid - b + 1
ans += sumrange(i+b, i+b+its-1) - c*its
ans += (d-c+1)*(c-b+1-its)
print(ans)
``` | instruction | 0 | 20,435 | 23 | 40,870 |
No | output | 1 | 20,435 | 23 | 40,871 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a grid with n rows and m columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number k > 0 written on it, then exactly k of its neighboring cells have a number greater than 0 written on them. Note that if the number in the cell is 0, there is no such restriction on neighboring cells.
You are allowed to take any number in the grid and increase it by 1. You may apply this operation as many times as you want, to any numbers you want. Perform some operations (possibly zero) to make the grid good, or say that it is impossible. If there are multiple possible answers, you may find any of them.
Two cells are considered to be neighboring if they have a common edge.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n and m (2 ≤ n, m ≤ 300) — the number of rows and columns, respectively.
The following n lines contain m integers each, the j-th element in the i-th line a_{i, j} is the number written in the j-th cell of the i-th row (0 ≤ a_{i, j} ≤ 10^9).
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 10^5.
Output
If it is impossible to obtain a good grid, print a single line containing "NO".
Otherwise, print a single line containing "YES", followed by n lines each containing m integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (possibly zero).
If there are multiple possible answers, you may print any of them.
Example
Input
5
3 4
0 0 0 0
0 1 0 0
0 0 0 0
2 2
3 0
0 0
2 2
0 0
0 0
2 3
0 0 0
0 4 0
4 4
0 0 0 0
0 2 0 1
0 0 0 0
0 0 0 0
Output
YES
0 0 0 0
0 1 1 0
0 0 0 0
NO
YES
0 0
0 0
NO
YES
0 1 0 0
1 4 2 1
0 2 0 0
1 3 1 0
Note
In the first test case, we can obtain the resulting grid by increasing the number in row 2, column 3 once. Both of the cells that contain 1 have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid
$$$0\;1\;0\;0 0\;2\;1\;0 0\;0\;0\;0$$$
All of them are accepted as valid answers.
In the second test case, it is impossible to make the grid good.
In the third test case, notice that no cell has a number greater than zero on it, so the grid is automatically good. | instruction | 0 | 20,436 | 23 | 40,872 |
Tags: constructive algorithms, greedy
Correct Solution:
```
import math
from collections import defaultdict
def solve(n,m):
mat = []
for i in range(n):
temp = list(map(int,input().split()))
mat.append(temp)
# print(mat)
for i in range(n):
for j in range(m):
if i==0 or i==n-1:
if j==0 or j==m-1:
if mat[i][j]>2:
print("NO")
return "NO"
mat[i][j]=2
else:
if mat[i][j]>3:
print("NO")
return "NO"
mat[i][j] = 3
else:
if j==0 or j==m-1:
if mat[i][j]>3:
print("NO")
return "NO"
mat[i][j] = 3
else:
if mat[i][j]>4:
print("NO")
return "NO"
mat[i][j] = 4
print("YES")
for i in range(n):
print(*mat[i])
for _ in range(int(input())):
n,m= map(int,input().split())
solve(n,m)
``` | output | 1 | 20,436 | 23 | 40,873 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a grid with n rows and m columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number k > 0 written on it, then exactly k of its neighboring cells have a number greater than 0 written on them. Note that if the number in the cell is 0, there is no such restriction on neighboring cells.
You are allowed to take any number in the grid and increase it by 1. You may apply this operation as many times as you want, to any numbers you want. Perform some operations (possibly zero) to make the grid good, or say that it is impossible. If there are multiple possible answers, you may find any of them.
Two cells are considered to be neighboring if they have a common edge.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n and m (2 ≤ n, m ≤ 300) — the number of rows and columns, respectively.
The following n lines contain m integers each, the j-th element in the i-th line a_{i, j} is the number written in the j-th cell of the i-th row (0 ≤ a_{i, j} ≤ 10^9).
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 10^5.
Output
If it is impossible to obtain a good grid, print a single line containing "NO".
Otherwise, print a single line containing "YES", followed by n lines each containing m integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (possibly zero).
If there are multiple possible answers, you may print any of them.
Example
Input
5
3 4
0 0 0 0
0 1 0 0
0 0 0 0
2 2
3 0
0 0
2 2
0 0
0 0
2 3
0 0 0
0 4 0
4 4
0 0 0 0
0 2 0 1
0 0 0 0
0 0 0 0
Output
YES
0 0 0 0
0 1 1 0
0 0 0 0
NO
YES
0 0
0 0
NO
YES
0 1 0 0
1 4 2 1
0 2 0 0
1 3 1 0
Note
In the first test case, we can obtain the resulting grid by increasing the number in row 2, column 3 once. Both of the cells that contain 1 have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid
$$$0\;1\;0\;0 0\;2\;1\;0 0\;0\;0\;0$$$
All of them are accepted as valid answers.
In the second test case, it is impossible to make the grid good.
In the third test case, notice that no cell has a number greater than zero on it, so the grid is automatically good. | instruction | 0 | 20,437 | 23 | 40,874 |
Tags: constructive algorithms, greedy
Correct Solution:
```
#872
for _ in range(int(input())):
n,m=[int(x)for x in input().split()]
a=[]
c=[0,n-1]
d=[0,m-1]
x=0
flag=0
for i in range(n):
b=[int(x)for x in input().split()]
a.append(b)
for i in range(n):
for j in range(m):
if(i in c and j in d):
if(a[i][j]<=2):
a[i][j]=2
else:
flag=1
break
elif(i in c or j in d):
if(a[i][j]<=3):
a[i][j]=3
else:
flag=1
break
else:
if(a[i][j]<=4):
a[i][j]=4
else:
flag=1
break
if(flag):
x=1
break
if(x):
print("NO")
else:
print("YES")
for i in range(n):
for j in range(m):
print(a[i][j],end=" ")
print()
``` | output | 1 | 20,437 | 23 | 40,875 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a grid with n rows and m columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number k > 0 written on it, then exactly k of its neighboring cells have a number greater than 0 written on them. Note that if the number in the cell is 0, there is no such restriction on neighboring cells.
You are allowed to take any number in the grid and increase it by 1. You may apply this operation as many times as you want, to any numbers you want. Perform some operations (possibly zero) to make the grid good, or say that it is impossible. If there are multiple possible answers, you may find any of them.
Two cells are considered to be neighboring if they have a common edge.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n and m (2 ≤ n, m ≤ 300) — the number of rows and columns, respectively.
The following n lines contain m integers each, the j-th element in the i-th line a_{i, j} is the number written in the j-th cell of the i-th row (0 ≤ a_{i, j} ≤ 10^9).
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 10^5.
Output
If it is impossible to obtain a good grid, print a single line containing "NO".
Otherwise, print a single line containing "YES", followed by n lines each containing m integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (possibly zero).
If there are multiple possible answers, you may print any of them.
Example
Input
5
3 4
0 0 0 0
0 1 0 0
0 0 0 0
2 2
3 0
0 0
2 2
0 0
0 0
2 3
0 0 0
0 4 0
4 4
0 0 0 0
0 2 0 1
0 0 0 0
0 0 0 0
Output
YES
0 0 0 0
0 1 1 0
0 0 0 0
NO
YES
0 0
0 0
NO
YES
0 1 0 0
1 4 2 1
0 2 0 0
1 3 1 0
Note
In the first test case, we can obtain the resulting grid by increasing the number in row 2, column 3 once. Both of the cells that contain 1 have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid
$$$0\;1\;0\;0 0\;2\;1\;0 0\;0\;0\;0$$$
All of them are accepted as valid answers.
In the second test case, it is impossible to make the grid good.
In the third test case, notice that no cell has a number greater than zero on it, so the grid is automatically good. | instruction | 0 | 20,438 | 23 | 40,876 |
Tags: constructive algorithms, greedy
Correct Solution:
```
for _ in range(int(input())):
n,m=map(int,input().split())
l=[list(map(int,input().split())) for i in range(n)]
for i in range(n):
for j in range(m):
t=[]
count=0
flag=0
if l[i][j]>0:
if i-1>=0 and l[i-1][j]>0:
count+=1
elif i-1>=0 and l[i-1][j]==0:
t.append([i-1,j])
if i+1<n and l[i+1][j]>0:
count+=1
elif i+1<n and l[i+1][j]==0:
t.append([i+1,j])
if j-1>=0 and l[i][j-1]>0:
count+=1
elif j-1>=0 and l[i][j-1]==0:
t.append([i,j-1])
if j+1<m and l[i][j+1]>0:
count+=1
elif j+1<m and l[i][j+1]==0:
t.append([i,j+1])
if count==l[i][j]:
continue
elif l[i][j]-count>len(t):
flag=-1
break
if flag==-1:
break
if flag==-1:
print("NO")
else:
print("YES")
for i in range(n):
for j in range(m):
cou=0
if i-1>=0 :
cou+=1
if i+1<n:
cou+=1
if j-1>=0 :
cou+=1
if j+1<m:
cou+=1
l[i][j]=cou
for i in range(n):
for j in range(m):
print(l[i][j],end=" ")
print()
``` | output | 1 | 20,438 | 23 | 40,877 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a grid with n rows and m columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number k > 0 written on it, then exactly k of its neighboring cells have a number greater than 0 written on them. Note that if the number in the cell is 0, there is no such restriction on neighboring cells.
You are allowed to take any number in the grid and increase it by 1. You may apply this operation as many times as you want, to any numbers you want. Perform some operations (possibly zero) to make the grid good, or say that it is impossible. If there are multiple possible answers, you may find any of them.
Two cells are considered to be neighboring if they have a common edge.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n and m (2 ≤ n, m ≤ 300) — the number of rows and columns, respectively.
The following n lines contain m integers each, the j-th element in the i-th line a_{i, j} is the number written in the j-th cell of the i-th row (0 ≤ a_{i, j} ≤ 10^9).
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 10^5.
Output
If it is impossible to obtain a good grid, print a single line containing "NO".
Otherwise, print a single line containing "YES", followed by n lines each containing m integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (possibly zero).
If there are multiple possible answers, you may print any of them.
Example
Input
5
3 4
0 0 0 0
0 1 0 0
0 0 0 0
2 2
3 0
0 0
2 2
0 0
0 0
2 3
0 0 0
0 4 0
4 4
0 0 0 0
0 2 0 1
0 0 0 0
0 0 0 0
Output
YES
0 0 0 0
0 1 1 0
0 0 0 0
NO
YES
0 0
0 0
NO
YES
0 1 0 0
1 4 2 1
0 2 0 0
1 3 1 0
Note
In the first test case, we can obtain the resulting grid by increasing the number in row 2, column 3 once. Both of the cells that contain 1 have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid
$$$0\;1\;0\;0 0\;2\;1\;0 0\;0\;0\;0$$$
All of them are accepted as valid answers.
In the second test case, it is impossible to make the grid good.
In the third test case, notice that no cell has a number greater than zero on it, so the grid is automatically good. | instruction | 0 | 20,439 | 23 | 40,878 |
Tags: constructive algorithms, greedy
Correct Solution:
```
import math
t=int(input())
for _ in range(t):
n,m=map(int,input().split())
a=[]
for i in range(n):
a.append(list(map(int,input().split())))
f=0
f1=0
for i in range(n):
for j in range(m):
c=0
if (i==0 and j==0) or (i==0 and j==(m-1)) or (i==(n-1) and j==0) or (i==(n-1) and j==(m-1)):
c=2
elif i==0 or i==(n-1) or j==0 or j==(m-1):
c=3
else:
c=4
if a[i][j]<=c:
a[i][j]=c
else:
f=1
break
if f==1:
f1=1
break
if f1==0:
print("YES")
for i in range(n):
print(*a[i])
else:
print("NO")
``` | output | 1 | 20,439 | 23 | 40,879 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a grid with n rows and m columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number k > 0 written on it, then exactly k of its neighboring cells have a number greater than 0 written on them. Note that if the number in the cell is 0, there is no such restriction on neighboring cells.
You are allowed to take any number in the grid and increase it by 1. You may apply this operation as many times as you want, to any numbers you want. Perform some operations (possibly zero) to make the grid good, or say that it is impossible. If there are multiple possible answers, you may find any of them.
Two cells are considered to be neighboring if they have a common edge.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n and m (2 ≤ n, m ≤ 300) — the number of rows and columns, respectively.
The following n lines contain m integers each, the j-th element in the i-th line a_{i, j} is the number written in the j-th cell of the i-th row (0 ≤ a_{i, j} ≤ 10^9).
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 10^5.
Output
If it is impossible to obtain a good grid, print a single line containing "NO".
Otherwise, print a single line containing "YES", followed by n lines each containing m integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (possibly zero).
If there are multiple possible answers, you may print any of them.
Example
Input
5
3 4
0 0 0 0
0 1 0 0
0 0 0 0
2 2
3 0
0 0
2 2
0 0
0 0
2 3
0 0 0
0 4 0
4 4
0 0 0 0
0 2 0 1
0 0 0 0
0 0 0 0
Output
YES
0 0 0 0
0 1 1 0
0 0 0 0
NO
YES
0 0
0 0
NO
YES
0 1 0 0
1 4 2 1
0 2 0 0
1 3 1 0
Note
In the first test case, we can obtain the resulting grid by increasing the number in row 2, column 3 once. Both of the cells that contain 1 have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid
$$$0\;1\;0\;0 0\;2\;1\;0 0\;0\;0\;0$$$
All of them are accepted as valid answers.
In the second test case, it is impossible to make the grid good.
In the third test case, notice that no cell has a number greater than zero on it, so the grid is automatically good. | instruction | 0 | 20,440 | 23 | 40,880 |
Tags: constructive algorithms, greedy
Correct Solution:
```
import sys
def input():
return sys.stdin.readline().rstrip()
def input_split():
return [int(i) for i in input().split()]
testCases = int(input())
answers = []
def make_ideal(grid):
global n, m
for i in range(n):
for j in range(m):
if (i == 0 or i == n-1) and (j==0 or j == m-1):
#corner
if grid[i][j] > 2:
return False
else:
grid[i][j] = 2
elif i == 0 or i == n-1 or j ==0 or j == m-1:
if grid[i][j] > 3:
return False
else:
grid[i][j] = 3
else:
if grid[i][j] > 4:
return False
else:
grid[i][j] = 4
return True
for _ in range(testCases):
#take input
n, m = input_split()
# grid = [ for _ in range(n)]
grid = []
for _ in range(n):
grid.append(input_split())
success = make_ideal(grid)
if success:
print('YES')
for i in range(n):
print(*grid[i], sep = ' ')
else:
print('NO')
# answers.append(ans)
# print(*answers, sep = '\n')
``` | output | 1 | 20,440 | 23 | 40,881 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a grid with n rows and m columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number k > 0 written on it, then exactly k of its neighboring cells have a number greater than 0 written on them. Note that if the number in the cell is 0, there is no such restriction on neighboring cells.
You are allowed to take any number in the grid and increase it by 1. You may apply this operation as many times as you want, to any numbers you want. Perform some operations (possibly zero) to make the grid good, or say that it is impossible. If there are multiple possible answers, you may find any of them.
Two cells are considered to be neighboring if they have a common edge.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n and m (2 ≤ n, m ≤ 300) — the number of rows and columns, respectively.
The following n lines contain m integers each, the j-th element in the i-th line a_{i, j} is the number written in the j-th cell of the i-th row (0 ≤ a_{i, j} ≤ 10^9).
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 10^5.
Output
If it is impossible to obtain a good grid, print a single line containing "NO".
Otherwise, print a single line containing "YES", followed by n lines each containing m integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (possibly zero).
If there are multiple possible answers, you may print any of them.
Example
Input
5
3 4
0 0 0 0
0 1 0 0
0 0 0 0
2 2
3 0
0 0
2 2
0 0
0 0
2 3
0 0 0
0 4 0
4 4
0 0 0 0
0 2 0 1
0 0 0 0
0 0 0 0
Output
YES
0 0 0 0
0 1 1 0
0 0 0 0
NO
YES
0 0
0 0
NO
YES
0 1 0 0
1 4 2 1
0 2 0 0
1 3 1 0
Note
In the first test case, we can obtain the resulting grid by increasing the number in row 2, column 3 once. Both of the cells that contain 1 have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid
$$$0\;1\;0\;0 0\;2\;1\;0 0\;0\;0\;0$$$
All of them are accepted as valid answers.
In the second test case, it is impossible to make the grid good.
In the third test case, notice that no cell has a number greater than zero on it, so the grid is automatically good. | instruction | 0 | 20,441 | 23 | 40,882 |
Tags: constructive algorithms, greedy
Correct Solution:
```
for t in range(int(input())):
n,m=map(int,input().split())
grid = list()
for i in range(n):
grid.append(list(map(int,input().split())))
corner_ok = (grid[0][0]<=2) and (grid[0][m-1]<=2) and (grid[n-1][0]<=2) and (grid[n-1][m-1]<=2)
edge_ok = True
for i in range(1,m-1):
edge_ok = edge_ok and (grid[0][i]<=3) and (grid[n-1][i]<=3)
for i in range(1,n-1):
edge_ok = edge_ok and (grid[i][0]<=3) and (grid[i][m-1]<=3)
inner_ok = True
for i in range(1,n-1):
for j in range(1,m-1):
inner_ok = inner_ok and (grid[i][j]<=4)
if(corner_ok and edge_ok and inner_ok):
grid[0][0]=2
grid[0][m-1]=2
grid[n-1][0]=2
grid[n-1][m-1]=2
for i in range(1,m-1):
grid[0][i]=3
grid[n-1][i]=3
for i in range(1,n-1):
grid[i][0]=3
grid[i][m-1]=3
for i in range(1,n-1):
for j in range(1,m-1):
grid[i][j]=4
print("YES")
for i in range(n):
for j in range(m):
print(grid[i][j],end=' ')
print()
else:
print("NO")
``` | output | 1 | 20,441 | 23 | 40,883 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a grid with n rows and m columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number k > 0 written on it, then exactly k of its neighboring cells have a number greater than 0 written on them. Note that if the number in the cell is 0, there is no such restriction on neighboring cells.
You are allowed to take any number in the grid and increase it by 1. You may apply this operation as many times as you want, to any numbers you want. Perform some operations (possibly zero) to make the grid good, or say that it is impossible. If there are multiple possible answers, you may find any of them.
Two cells are considered to be neighboring if they have a common edge.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n and m (2 ≤ n, m ≤ 300) — the number of rows and columns, respectively.
The following n lines contain m integers each, the j-th element in the i-th line a_{i, j} is the number written in the j-th cell of the i-th row (0 ≤ a_{i, j} ≤ 10^9).
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 10^5.
Output
If it is impossible to obtain a good grid, print a single line containing "NO".
Otherwise, print a single line containing "YES", followed by n lines each containing m integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (possibly zero).
If there are multiple possible answers, you may print any of them.
Example
Input
5
3 4
0 0 0 0
0 1 0 0
0 0 0 0
2 2
3 0
0 0
2 2
0 0
0 0
2 3
0 0 0
0 4 0
4 4
0 0 0 0
0 2 0 1
0 0 0 0
0 0 0 0
Output
YES
0 0 0 0
0 1 1 0
0 0 0 0
NO
YES
0 0
0 0
NO
YES
0 1 0 0
1 4 2 1
0 2 0 0
1 3 1 0
Note
In the first test case, we can obtain the resulting grid by increasing the number in row 2, column 3 once. Both of the cells that contain 1 have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid
$$$0\;1\;0\;0 0\;2\;1\;0 0\;0\;0\;0$$$
All of them are accepted as valid answers.
In the second test case, it is impossible to make the grid good.
In the third test case, notice that no cell has a number greater than zero on it, so the grid is automatically good. | instruction | 0 | 20,442 | 23 | 40,884 |
Tags: constructive algorithms, greedy
Correct Solution:
```
# input = open('file.txt').readline
for _ in range( int(input()) ):
n , m = map( int , input().strip().split(" ") )
grid = []
for __ in range( n ):
arr = list( map( int , input().strip().split(" ") ) )
grid.append(arr)
flag = True
for i in range(n):
for j in range(m):
nij = 0
up = (i-1 , j)
dw = (i+1 , j)
ri = (i , j-1)
le = (i , j+1)
pos = [ up , dw , ri , le ]
for pi , pj in pos:
if pi < n and pi > -1 and pj < m and pj > -1:
nij += 1
if grid[i][j] <= nij:
grid[i][j] = nij
else:
flag = False
break
if not flag:
break
if not flag:
print('NO')
else:
print('YES')
for gr in grid:
print(*gr)
``` | output | 1 | 20,442 | 23 | 40,885 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a grid with n rows and m columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number k > 0 written on it, then exactly k of its neighboring cells have a number greater than 0 written on them. Note that if the number in the cell is 0, there is no such restriction on neighboring cells.
You are allowed to take any number in the grid and increase it by 1. You may apply this operation as many times as you want, to any numbers you want. Perform some operations (possibly zero) to make the grid good, or say that it is impossible. If there are multiple possible answers, you may find any of them.
Two cells are considered to be neighboring if they have a common edge.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n and m (2 ≤ n, m ≤ 300) — the number of rows and columns, respectively.
The following n lines contain m integers each, the j-th element in the i-th line a_{i, j} is the number written in the j-th cell of the i-th row (0 ≤ a_{i, j} ≤ 10^9).
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 10^5.
Output
If it is impossible to obtain a good grid, print a single line containing "NO".
Otherwise, print a single line containing "YES", followed by n lines each containing m integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (possibly zero).
If there are multiple possible answers, you may print any of them.
Example
Input
5
3 4
0 0 0 0
0 1 0 0
0 0 0 0
2 2
3 0
0 0
2 2
0 0
0 0
2 3
0 0 0
0 4 0
4 4
0 0 0 0
0 2 0 1
0 0 0 0
0 0 0 0
Output
YES
0 0 0 0
0 1 1 0
0 0 0 0
NO
YES
0 0
0 0
NO
YES
0 1 0 0
1 4 2 1
0 2 0 0
1 3 1 0
Note
In the first test case, we can obtain the resulting grid by increasing the number in row 2, column 3 once. Both of the cells that contain 1 have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid
$$$0\;1\;0\;0 0\;2\;1\;0 0\;0\;0\;0$$$
All of them are accepted as valid answers.
In the second test case, it is impossible to make the grid good.
In the third test case, notice that no cell has a number greater than zero on it, so the grid is automatically good. | instruction | 0 | 20,443 | 23 | 40,886 |
Tags: constructive algorithms, greedy
Correct Solution:
```
# -*- coding: utf-8 -*-
# import bisect
# import heapq
# import math
# import random
# from collections import Counter, defaultdict, deque
# from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
# from functools import lru_cache, reduce
# from itertools import combinations, combinations_with_replacement, product, permutations
# from operator import add, mul, sub
import sys
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
# @mt
def slv(N, M, A):
B = [[0] * M for _ in range(N)]
for i in range(N):
for j in range(M):
if i-1 >= 0:
B[i][j] += 1
if i+1 < N:
B[i][j] += 1
if j-1 >= 0:
B[i][j] += 1
if j+1 < M:
B[i][j] += 1
for i in range(N):
for j in range(M):
if A[i][j] > B[i][j]:
print('NO')
return
print('YES')
for r in B:
print(*r)
def main():
for _ in range(read_int()):
N, M = read_int_n()
A = [read_int_n() for _ in range(N)]
slv(N, M, A)
if __name__ == '__main__':
main()
``` | output | 1 | 20,443 | 23 | 40,887 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a grid with n rows and m columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number k > 0 written on it, then exactly k of its neighboring cells have a number greater than 0 written on them. Note that if the number in the cell is 0, there is no such restriction on neighboring cells.
You are allowed to take any number in the grid and increase it by 1. You may apply this operation as many times as you want, to any numbers you want. Perform some operations (possibly zero) to make the grid good, or say that it is impossible. If there are multiple possible answers, you may find any of them.
Two cells are considered to be neighboring if they have a common edge.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n and m (2 ≤ n, m ≤ 300) — the number of rows and columns, respectively.
The following n lines contain m integers each, the j-th element in the i-th line a_{i, j} is the number written in the j-th cell of the i-th row (0 ≤ a_{i, j} ≤ 10^9).
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 10^5.
Output
If it is impossible to obtain a good grid, print a single line containing "NO".
Otherwise, print a single line containing "YES", followed by n lines each containing m integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (possibly zero).
If there are multiple possible answers, you may print any of them.
Example
Input
5
3 4
0 0 0 0
0 1 0 0
0 0 0 0
2 2
3 0
0 0
2 2
0 0
0 0
2 3
0 0 0
0 4 0
4 4
0 0 0 0
0 2 0 1
0 0 0 0
0 0 0 0
Output
YES
0 0 0 0
0 1 1 0
0 0 0 0
NO
YES
0 0
0 0
NO
YES
0 1 0 0
1 4 2 1
0 2 0 0
1 3 1 0
Note
In the first test case, we can obtain the resulting grid by increasing the number in row 2, column 3 once. Both of the cells that contain 1 have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid
$$$0\;1\;0\;0 0\;2\;1\;0 0\;0\;0\;0$$$
All of them are accepted as valid answers.
In the second test case, it is impossible to make the grid good.
In the third test case, notice that no cell has a number greater than zero on it, so the grid is automatically good.
Submitted Solution:
```
for u in range(int(input())):
n,m=map(int,input().split())
s=[]
p=1
for i in range(n):
s.append(list(map(int,input().split())))
l=[]
for i in range(m):
l.append(3)
l[0],l[-1]=2,2
for i in range(n-2):
l.append(3)
for j in range(m-2):
l.append(4)
l.append(3)
l.append(2)
for i in range(m-2):
l.append(3)
l.append(2)
for i in range(n):
for j in range(m):
if(s[i][j]>l[i*m+j]):
p=0
break
if(p==0):
print("NO")
else:
print("YES")
for i in range(n):
for j in range(m):
print(l[m*i+j],end=' ')
print()
``` | instruction | 0 | 20,444 | 23 | 40,888 |
Yes | output | 1 | 20,444 | 23 | 40,889 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a grid with n rows and m columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number k > 0 written on it, then exactly k of its neighboring cells have a number greater than 0 written on them. Note that if the number in the cell is 0, there is no such restriction on neighboring cells.
You are allowed to take any number in the grid and increase it by 1. You may apply this operation as many times as you want, to any numbers you want. Perform some operations (possibly zero) to make the grid good, or say that it is impossible. If there are multiple possible answers, you may find any of them.
Two cells are considered to be neighboring if they have a common edge.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n and m (2 ≤ n, m ≤ 300) — the number of rows and columns, respectively.
The following n lines contain m integers each, the j-th element in the i-th line a_{i, j} is the number written in the j-th cell of the i-th row (0 ≤ a_{i, j} ≤ 10^9).
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 10^5.
Output
If it is impossible to obtain a good grid, print a single line containing "NO".
Otherwise, print a single line containing "YES", followed by n lines each containing m integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (possibly zero).
If there are multiple possible answers, you may print any of them.
Example
Input
5
3 4
0 0 0 0
0 1 0 0
0 0 0 0
2 2
3 0
0 0
2 2
0 0
0 0
2 3
0 0 0
0 4 0
4 4
0 0 0 0
0 2 0 1
0 0 0 0
0 0 0 0
Output
YES
0 0 0 0
0 1 1 0
0 0 0 0
NO
YES
0 0
0 0
NO
YES
0 1 0 0
1 4 2 1
0 2 0 0
1 3 1 0
Note
In the first test case, we can obtain the resulting grid by increasing the number in row 2, column 3 once. Both of the cells that contain 1 have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid
$$$0\;1\;0\;0 0\;2\;1\;0 0\;0\;0\;0$$$
All of them are accepted as valid answers.
In the second test case, it is impossible to make the grid good.
In the third test case, notice that no cell has a number greater than zero on it, so the grid is automatically good.
Submitted Solution:
```
# import sys
# input=sys.stdin.readline
t=int(input())
for _ in range(t):
n,m=list(map(int,input().split()))
a=[]
for i in range(n):
a.append(list(map(int,input().split())))
b=[]
for i in range(n):
b.append([4]*m)
for i in range(1,m-1):
b[0][i]=3
b[-1][i]=3
for i in range(1,n-1):
b[i][0]=3
b[i][-1]=3
b[0][0]=2
b[0][-1]=2
b[-1][0]=2
b[-1][-1]=2
e=0
for i in range(n):
for j in range(m):
if a[i][j]>b[i][j]:
e=1
break
if e==1:
print("NO")
else:
print("YES")
for i in range(n):
print(*b[i])
``` | instruction | 0 | 20,445 | 23 | 40,890 |
Yes | output | 1 | 20,445 | 23 | 40,891 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a grid with n rows and m columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number k > 0 written on it, then exactly k of its neighboring cells have a number greater than 0 written on them. Note that if the number in the cell is 0, there is no such restriction on neighboring cells.
You are allowed to take any number in the grid and increase it by 1. You may apply this operation as many times as you want, to any numbers you want. Perform some operations (possibly zero) to make the grid good, or say that it is impossible. If there are multiple possible answers, you may find any of them.
Two cells are considered to be neighboring if they have a common edge.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n and m (2 ≤ n, m ≤ 300) — the number of rows and columns, respectively.
The following n lines contain m integers each, the j-th element in the i-th line a_{i, j} is the number written in the j-th cell of the i-th row (0 ≤ a_{i, j} ≤ 10^9).
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 10^5.
Output
If it is impossible to obtain a good grid, print a single line containing "NO".
Otherwise, print a single line containing "YES", followed by n lines each containing m integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (possibly zero).
If there are multiple possible answers, you may print any of them.
Example
Input
5
3 4
0 0 0 0
0 1 0 0
0 0 0 0
2 2
3 0
0 0
2 2
0 0
0 0
2 3
0 0 0
0 4 0
4 4
0 0 0 0
0 2 0 1
0 0 0 0
0 0 0 0
Output
YES
0 0 0 0
0 1 1 0
0 0 0 0
NO
YES
0 0
0 0
NO
YES
0 1 0 0
1 4 2 1
0 2 0 0
1 3 1 0
Note
In the first test case, we can obtain the resulting grid by increasing the number in row 2, column 3 once. Both of the cells that contain 1 have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid
$$$0\;1\;0\;0 0\;2\;1\;0 0\;0\;0\;0$$$
All of them are accepted as valid answers.
In the second test case, it is impossible to make the grid good.
In the third test case, notice that no cell has a number greater than zero on it, so the grid is automatically good.
Submitted Solution:
```
T = int(input())
for i in range(T):
#n = int(input())
n,m = map(int, input().split())
#a,b = map(int, input().split())
#a = [int(i) for i in input().split()]
#a = list(input())
a = [0]*n
for i in range(n):
a[i] = [int(i) for i in input().split()]
d = False
for i in range(n):
for j in range(m):
if (i==0 and j==0) or (i==n-1 and j==m-1) or (i==0 and j==m-1) or (j==0 and i==n-1):
if a[i][j] > 2:
print('NO')
d = True
break
elif i==0 or j==0 or i==n-1 or j==m-1:
if a[i][j] > 3:
print('NO')
d = True
break
else:
if a[i][j] > 4:
print('NO')
d = True
break
if d:
break
if d:
continue
else:
print('YES')
for i in range(n):
for j in range(m):
if (i==0 and j==0) or (i==n-1 and j==m-1) or (i==0 and j==m-1) or (j==0 and i==n-1):
print('2',end=' ')
elif i==0 or j==0 or i==n-1 or j==m-1:
print('3',end=' ')
else:
print('4',end=' ')
print()
``` | instruction | 0 | 20,446 | 23 | 40,892 |
Yes | output | 1 | 20,446 | 23 | 40,893 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a grid with n rows and m columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number k > 0 written on it, then exactly k of its neighboring cells have a number greater than 0 written on them. Note that if the number in the cell is 0, there is no such restriction on neighboring cells.
You are allowed to take any number in the grid and increase it by 1. You may apply this operation as many times as you want, to any numbers you want. Perform some operations (possibly zero) to make the grid good, or say that it is impossible. If there are multiple possible answers, you may find any of them.
Two cells are considered to be neighboring if they have a common edge.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n and m (2 ≤ n, m ≤ 300) — the number of rows and columns, respectively.
The following n lines contain m integers each, the j-th element in the i-th line a_{i, j} is the number written in the j-th cell of the i-th row (0 ≤ a_{i, j} ≤ 10^9).
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 10^5.
Output
If it is impossible to obtain a good grid, print a single line containing "NO".
Otherwise, print a single line containing "YES", followed by n lines each containing m integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (possibly zero).
If there are multiple possible answers, you may print any of them.
Example
Input
5
3 4
0 0 0 0
0 1 0 0
0 0 0 0
2 2
3 0
0 0
2 2
0 0
0 0
2 3
0 0 0
0 4 0
4 4
0 0 0 0
0 2 0 1
0 0 0 0
0 0 0 0
Output
YES
0 0 0 0
0 1 1 0
0 0 0 0
NO
YES
0 0
0 0
NO
YES
0 1 0 0
1 4 2 1
0 2 0 0
1 3 1 0
Note
In the first test case, we can obtain the resulting grid by increasing the number in row 2, column 3 once. Both of the cells that contain 1 have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid
$$$0\;1\;0\;0 0\;2\;1\;0 0\;0\;0\;0$$$
All of them are accepted as valid answers.
In the second test case, it is impossible to make the grid good.
In the third test case, notice that no cell has a number greater than zero on it, so the grid is automatically good.
Submitted Solution:
```
import sys, math,os
from io import BytesIO, IOBase
#data = BytesIO(os.read(0,os.fstat(0).st_size)).readline
# from bisect import bisect_left as bl, bisect_right as br, insort
# from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter
# from itertools import permutations,combinations
# from decimal import Decimal
def data(): return sys.stdin.readline().strip()
def mdata(): return list(map(int, data().split()))
def outl(var): sys.stdout.write(' '.join(map(str, var)) + '\n')
def out(var): sys.stdout.write(str(var) + '\n')
#sys.setrecursionlimit(100000 + 1)
INF = 10**9
mod = 998244353
step=[(1,0),(-1,0),(0,1),(0,-1)]
for t in range(int(data())):
n,m=mdata()
mat=[mdata() for i in range(n)]
mat1=[[0]*m for i in range(n)]
flag=True
for i in range(n):
for j in range(m):
cnt=0
for a,b in step:
if -1<i+a<n and -1<j+b<m:
cnt+=1
if cnt<mat[i][j]:
flag=False
break
mat1[i][j]=cnt
if flag==False:
out("NO")
else:
out("YES")
for i in range(n):
outl(mat1[i])
``` | instruction | 0 | 20,447 | 23 | 40,894 |
Yes | output | 1 | 20,447 | 23 | 40,895 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a grid with n rows and m columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number k > 0 written on it, then exactly k of its neighboring cells have a number greater than 0 written on them. Note that if the number in the cell is 0, there is no such restriction on neighboring cells.
You are allowed to take any number in the grid and increase it by 1. You may apply this operation as many times as you want, to any numbers you want. Perform some operations (possibly zero) to make the grid good, or say that it is impossible. If there are multiple possible answers, you may find any of them.
Two cells are considered to be neighboring if they have a common edge.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n and m (2 ≤ n, m ≤ 300) — the number of rows and columns, respectively.
The following n lines contain m integers each, the j-th element in the i-th line a_{i, j} is the number written in the j-th cell of the i-th row (0 ≤ a_{i, j} ≤ 10^9).
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 10^5.
Output
If it is impossible to obtain a good grid, print a single line containing "NO".
Otherwise, print a single line containing "YES", followed by n lines each containing m integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (possibly zero).
If there are multiple possible answers, you may print any of them.
Example
Input
5
3 4
0 0 0 0
0 1 0 0
0 0 0 0
2 2
3 0
0 0
2 2
0 0
0 0
2 3
0 0 0
0 4 0
4 4
0 0 0 0
0 2 0 1
0 0 0 0
0 0 0 0
Output
YES
0 0 0 0
0 1 1 0
0 0 0 0
NO
YES
0 0
0 0
NO
YES
0 1 0 0
1 4 2 1
0 2 0 0
1 3 1 0
Note
In the first test case, we can obtain the resulting grid by increasing the number in row 2, column 3 once. Both of the cells that contain 1 have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid
$$$0\;1\;0\;0 0\;2\;1\;0 0\;0\;0\;0$$$
All of them are accepted as valid answers.
In the second test case, it is impossible to make the grid good.
In the third test case, notice that no cell has a number greater than zero on it, so the grid is automatically good.
Submitted Solution:
```
t=int(input())
while t>0:
t-=1
n,m=map(int,input().split())
s=[]
for i in range(n):
a=list(map(int,input().split()))
s.append(a)
z=True
for i in range(n):
for j in range(m):
if i==0 or i==n-1:
if j==0 or j==m-1:
if s[i][j]<2:
s[i][j]=2
else:
z=False
break
else:
if s[i][j]<3:
s[i][j]=3
else:
#print['NO']
z=False
break
else:
if j==0 or j==m-1:
if s[i][j]<3:
s[i][j]=3
else:
#print['NO']
z=False
break
else:
if s[i][j]<4:
s[i][j]=4
else:
#print['NO']
z=False
break
if z==True:
print('YES')
for i in range(n):
for j in s[i]:
print(j,end=' ')
print()
else:
print('NO')
``` | instruction | 0 | 20,448 | 23 | 40,896 |
No | output | 1 | 20,448 | 23 | 40,897 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a grid with n rows and m columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number k > 0 written on it, then exactly k of its neighboring cells have a number greater than 0 written on them. Note that if the number in the cell is 0, there is no such restriction on neighboring cells.
You are allowed to take any number in the grid and increase it by 1. You may apply this operation as many times as you want, to any numbers you want. Perform some operations (possibly zero) to make the grid good, or say that it is impossible. If there are multiple possible answers, you may find any of them.
Two cells are considered to be neighboring if they have a common edge.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n and m (2 ≤ n, m ≤ 300) — the number of rows and columns, respectively.
The following n lines contain m integers each, the j-th element in the i-th line a_{i, j} is the number written in the j-th cell of the i-th row (0 ≤ a_{i, j} ≤ 10^9).
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 10^5.
Output
If it is impossible to obtain a good grid, print a single line containing "NO".
Otherwise, print a single line containing "YES", followed by n lines each containing m integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (possibly zero).
If there are multiple possible answers, you may print any of them.
Example
Input
5
3 4
0 0 0 0
0 1 0 0
0 0 0 0
2 2
3 0
0 0
2 2
0 0
0 0
2 3
0 0 0
0 4 0
4 4
0 0 0 0
0 2 0 1
0 0 0 0
0 0 0 0
Output
YES
0 0 0 0
0 1 1 0
0 0 0 0
NO
YES
0 0
0 0
NO
YES
0 1 0 0
1 4 2 1
0 2 0 0
1 3 1 0
Note
In the first test case, we can obtain the resulting grid by increasing the number in row 2, column 3 once. Both of the cells that contain 1 have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid
$$$0\;1\;0\;0 0\;2\;1\;0 0\;0\;0\;0$$$
All of them are accepted as valid answers.
In the second test case, it is impossible to make the grid good.
In the third test case, notice that no cell has a number greater than zero on it, so the grid is automatically good.
Submitted Solution:
```
# Problem: B. Neighbor Grid
# Contest: Codeforces - Codeforces Global Round 9
# URL: https://codeforces.com/contest/1375/problem/B
# Memory Limit: 256 MB
# Time Limit: 1000 ms
# Powered by CP Editor (https://github.com/cpeditor/cpeditor)
from sys import stdin
def get_ints(): return list(map(int, stdin.readline().strip().split()))
steps= [[0,1],[1,0],[0,-1],[-1,0]]
for _ in range(int(input())):
n,m = get_ints()
corns = [[0,0],[n-1,0],[0,m-1],[n-1,m-1]]
ar= [ get_ints() for x in range(n)]
flag = True
for i in range(n):
for j in range(m):
if ar[i][i] == 0:
continue
if [i,j] in corns:
if ar[i][j] > 2:
flag = False
break
if i==0 or j==0 or i == n-1 or j==m-1:
if ar[i][j] > 3:
flag = False
break
else:
if ar[i][j] >4:
flag = False
break
cnt = ar[i][j]
nm = 0
for ix,jx in steps:
newi = ix+i
newj = jx+j
if newi < 0 or newj <0 or newi > n-1 or newj > m-1:
continue
if ar[newi][newj] != 0:
nm+=1
if nm == cnt:
continue
for ix,jx in steps:
if cnt <=0:
break
newi = ix+i
newj = jx+j
if newi < 0 or newj <0 or newi > n-1 or newj > m-1:
continue
if ar[newi][newj] != 0:
cnt-=1
continue
ar[newi][newj] = 1
cnt-=1
if cnt >0:
flag = False
break
if not flag:
break
if flag:
print("YES")
for row in ar:
print(" ".join([str(x) for x in row]))
else:
print("NO")
``` | instruction | 0 | 20,449 | 23 | 40,898 |
No | output | 1 | 20,449 | 23 | 40,899 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a grid with n rows and m columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number k > 0 written on it, then exactly k of its neighboring cells have a number greater than 0 written on them. Note that if the number in the cell is 0, there is no such restriction on neighboring cells.
You are allowed to take any number in the grid and increase it by 1. You may apply this operation as many times as you want, to any numbers you want. Perform some operations (possibly zero) to make the grid good, or say that it is impossible. If there are multiple possible answers, you may find any of them.
Two cells are considered to be neighboring if they have a common edge.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n and m (2 ≤ n, m ≤ 300) — the number of rows and columns, respectively.
The following n lines contain m integers each, the j-th element in the i-th line a_{i, j} is the number written in the j-th cell of the i-th row (0 ≤ a_{i, j} ≤ 10^9).
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 10^5.
Output
If it is impossible to obtain a good grid, print a single line containing "NO".
Otherwise, print a single line containing "YES", followed by n lines each containing m integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (possibly zero).
If there are multiple possible answers, you may print any of them.
Example
Input
5
3 4
0 0 0 0
0 1 0 0
0 0 0 0
2 2
3 0
0 0
2 2
0 0
0 0
2 3
0 0 0
0 4 0
4 4
0 0 0 0
0 2 0 1
0 0 0 0
0 0 0 0
Output
YES
0 0 0 0
0 1 1 0
0 0 0 0
NO
YES
0 0
0 0
NO
YES
0 1 0 0
1 4 2 1
0 2 0 0
1 3 1 0
Note
In the first test case, we can obtain the resulting grid by increasing the number in row 2, column 3 once. Both of the cells that contain 1 have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid
$$$0\;1\;0\;0 0\;2\;1\;0 0\;0\;0\;0$$$
All of them are accepted as valid answers.
In the second test case, it is impossible to make the grid good.
In the third test case, notice that no cell has a number greater than zero on it, so the grid is automatically good.
Submitted Solution:
```
# Problem: B. Neighbor Grid
# Contest: Codeforces - Codeforces Global Round 9
# URL: https://codeforces.com/contest/1375/problem/B
# Memory Limit: 256 MB
# Time Limit: 1000 ms
# Powered by CP Editor (https://github.com/cpeditor/cpeditor)
from sys import stdin
def get_ints(): return list(map(int, stdin.readline().strip().split()))
steps= [[0,1],[1,0],[0,-1],[-1,0]]
for _ in range(int(input())):
n,m = get_ints()
corns = [[0,0],[n-1,0],[0,m-1],[n-1,m-1]]
ar= [ get_ints() for x in range(n)]
flag = True
for i in range(n):
for j in range(m):
if ar[i][i] == 0:
continue
if [i,j] in corns:
if ar[i][j] > 2:
flag = False
break
if i==0 or j==0 or i == n-1 or j==m-1:
if ar[i][j] > 3:
flag = False
break
else:
if ar[i][j] >4:
flag = False
break
cnt = ar[i][j]
for ix,jx in steps:
newi = ix+i
newj = jx+j
if newi < 0 or newj <0 or newi > n-1 or newj > m-1:
continue
if ar[newi][newj] != 0:
cnt-=1
continue
if cnt <=0:
break
ar[newi][newj] = 1
cnt-=1
if cnt >0:
flag = False
break
if not flag:
break
if flag:
print("YES")
for row in ar:
print(" ".join([str(x) for x in row]))
else:
print("NO")
``` | instruction | 0 | 20,450 | 23 | 40,900 |
No | output | 1 | 20,450 | 23 | 40,901 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a grid with n rows and m columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number k > 0 written on it, then exactly k of its neighboring cells have a number greater than 0 written on them. Note that if the number in the cell is 0, there is no such restriction on neighboring cells.
You are allowed to take any number in the grid and increase it by 1. You may apply this operation as many times as you want, to any numbers you want. Perform some operations (possibly zero) to make the grid good, or say that it is impossible. If there are multiple possible answers, you may find any of them.
Two cells are considered to be neighboring if they have a common edge.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n and m (2 ≤ n, m ≤ 300) — the number of rows and columns, respectively.
The following n lines contain m integers each, the j-th element in the i-th line a_{i, j} is the number written in the j-th cell of the i-th row (0 ≤ a_{i, j} ≤ 10^9).
It is guaranteed that the sum of n ⋅ m over all test cases does not exceed 10^5.
Output
If it is impossible to obtain a good grid, print a single line containing "NO".
Otherwise, print a single line containing "YES", followed by n lines each containing m integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (possibly zero).
If there are multiple possible answers, you may print any of them.
Example
Input
5
3 4
0 0 0 0
0 1 0 0
0 0 0 0
2 2
3 0
0 0
2 2
0 0
0 0
2 3
0 0 0
0 4 0
4 4
0 0 0 0
0 2 0 1
0 0 0 0
0 0 0 0
Output
YES
0 0 0 0
0 1 1 0
0 0 0 0
NO
YES
0 0
0 0
NO
YES
0 1 0 0
1 4 2 1
0 2 0 0
1 3 1 0
Note
In the first test case, we can obtain the resulting grid by increasing the number in row 2, column 3 once. Both of the cells that contain 1 have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid
$$$0\;1\;0\;0 0\;2\;1\;0 0\;0\;0\;0$$$
All of them are accepted as valid answers.
In the second test case, it is impossible to make the grid good.
In the third test case, notice that no cell has a number greater than zero on it, so the grid is automatically good.
Submitted Solution:
```
# from math import factorial as fac
from collections import defaultdict
# from copy import deepcopy
import sys, math
f = None
try:
f = open('q1.input', 'r')
except IOError:
f = sys.stdin
if 'xrange' in dir(__builtins__):
range = xrange
# print(f.readline())
sys.setrecursionlimit(10**2)
def print_case_iterable(case_num, iterable):
print("Case #{}: {}".format(case_num," ".join(map(str,iterable))))
def print_case_number(case_num, iterable):
print("Case #{}: {}".format(case_num,iterable))
def print_iterable(A):
print (' '.join(A))
def read_int():
return int(f.readline().strip())
def read_int_array():
return [int(x) for x in f.readline().strip().split(" ")]
def rns():
a = [x for x in f.readline().split(" ")]
return int(a[0]), a[1].strip()
def read_string():
return list(f.readline().strip())
def ri():
return int(f.readline().strip())
def ria():
return [int(x) for x in f.readline().strip().split(" ")]
def rns():
a = [x for x in f.readline().split(" ")]
return int(a[0]), a[1].strip()
def rs():
return list(f.readline().strip())
def bi(x):
return bin(x)[2:]
from collections import deque
import math
NUMBER = 10**9 + 7
# NUMBER = 998244353
def factorial(n) :
M = NUMBER
f = 1
for i in range(1, n + 1):
f = (f * i) % M # Now f never can
# exceed 10^9+7
return f
def mult(a,b):
return (a * b) % NUMBER
def minus(a , b):
return (a - b) % NUMBER
def plus(a , b):
return (a + b) % NUMBER
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, y, x = egcd(b % a, a)
return (g, x - (b // a) * y, y)
def modinv(a):
m = NUMBER
g, x, y = egcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
def choose(n,k):
if n < k:
assert false
return mult(factorial(n), modinv(mult(factorial(k),factorial(n-k)))) % NUMBER
from collections import deque, defaultdict
import heapq
from types import GeneratorType
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
def dfs(g, timeIn, timeOut,depths,parents):
# assign In-time to node u
cnt = 0
# node, neig_i, parent, depth
stack = [[1,0,0,0]]
while stack:
v,neig_i,parent,depth = stack[-1]
parents[v] = parent
depths[v] = depth
# print (v)
if neig_i == 0:
timeIn[v] = cnt
cnt+=1
while neig_i < len(g[v]):
u = g[v][neig_i]
if u == parent:
neig_i+=1
continue
stack[-1][1] = neig_i + 1
stack.append([u,0,v,depth+1])
break
if neig_i == len(g[v]):
stack.pop()
timeOut[v] = cnt
cnt += 1
# def isAncestor(u: int, v: int, timeIn: list, timeOut: list) -> str:
# return timeIn[u] <= timeIn[v] and timeOut[v] <= timeOut[u]
cnt = 0
@bootstrap
def dfs(v,adj,timeIn, timeOut,depths,parents,parent=0,depth=0):
global cnt
parents[v] = parent
depths[v] = depth
timeIn[v] = cnt
cnt+=1
for u in adj[v]:
if u == parent:
continue
yield dfs(u,adj,timeIn,timeOut,depths,parents,v,depth+1)
timeOut[v] = cnt
cnt+=1
yield
def gcd(a,b):
if a == 0:
return b
return gcd(b % a, a)
# Function to return LCM of two numbers
def lcm(a,b):
return (a*b) / gcd(a,b)
def get_num_2_5(n):
twos = 0
fives = 0
while n>0 and n%2 == 0:
n//=2
twos+=1
while n>0 and n%5 == 0:
n//=5
fives+=1
return (twos,fives)
def shift(a,i,num):
for _ in range(num):
a[i],a[i+1],a[i+2] = a[i+2],a[i],a[i+1]
def solution(a,n,m):
for i in range(1,n-1):
for j in range(1,m-1):
if a[i][j] > 4:
return "NO"
a[i][j] = 4
for i in [0,n-1]:
for j in range(1,m-1):
if a[i][j] > 3:
return "NO"
a[i][j] = 3
for j in [0,m-1]:
for i in range(1,n-1):
if a[i][j] > 3:
return "NO"
a[i][j] = 3
for i,j in [(0,0),(0,m-1),(n-1,0),(n-1,m-1)]:
if a[i][j] > 2:
return "NO"
a[i][j] = 2
print ("YES")
for row in a:
print(' '.join(map(str,row)))
def main():
T = 1
T = ri()
for i in range(T):
# n = ri()
# s = rs()
# data = []
n,m = ria()
data = []
for _ in range(n):
data.append(ria())
# a = ria()
# b = ria()
x = solution(data,n,m)
continue
if 'xrange' not in dir(__builtins__):
print(x)
else:
print >>output,str(x)# "Case #"+str(i+1)+':',
if 'xrange' in dir(__builtins__):
print(output.getvalue())
output.close()
if 'xrange' in dir(__builtins__):
import cStringIO
output = cStringIO.StringIO()
#example usage:
# for l in res:
# print >>output, str(len(l)) + ' ' + ' '.join(l)
if __name__ == '__main__':
main()
``` | instruction | 0 | 20,451 | 23 | 40,902 |
No | output | 1 | 20,451 | 23 | 40,903 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Yura is tasked to build a closed fence in shape of an arbitrary non-degenerate simple quadrilateral. He's already got three straight fence segments with known lengths a, b, and c. Now he needs to find out some possible integer length d of the fourth straight fence segment so that he can build the fence using these four segments. In other words, the fence should have a quadrilateral shape with side lengths equal to a, b, c, and d. Help Yura, find any possible length of the fourth side.
A non-degenerate simple quadrilateral is such a quadrilateral that no three of its corners lie on the same line, and it does not cross itself.
Input
The first line contains a single integer t — the number of test cases (1 ≤ t ≤ 1000). The next t lines describe the test cases.
Each line contains three integers a, b, and c — the lengths of the three fence segments (1 ≤ a, b, c ≤ 10^9).
Output
For each test case print a single integer d — the length of the fourth fence segment that is suitable for building the fence. If there are multiple answers, print any. We can show that an answer always exists.
Example
Input
2
1 2 3
12 34 56
Output
4
42
Note
We can build a quadrilateral with sides 1, 2, 3, 4.
We can build a quadrilateral with sides 12, 34, 56, 42. | instruction | 0 | 20,468 | 23 | 40,936 |
Tags: geometry, math
Correct Solution:
```
for ctr in range(int(input())):
a,b,c=map(int,input().split())
print(max(a,c,b)+1)
``` | output | 1 | 20,468 | 23 | 40,937 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Yura is tasked to build a closed fence in shape of an arbitrary non-degenerate simple quadrilateral. He's already got three straight fence segments with known lengths a, b, and c. Now he needs to find out some possible integer length d of the fourth straight fence segment so that he can build the fence using these four segments. In other words, the fence should have a quadrilateral shape with side lengths equal to a, b, c, and d. Help Yura, find any possible length of the fourth side.
A non-degenerate simple quadrilateral is such a quadrilateral that no three of its corners lie on the same line, and it does not cross itself.
Input
The first line contains a single integer t — the number of test cases (1 ≤ t ≤ 1000). The next t lines describe the test cases.
Each line contains three integers a, b, and c — the lengths of the three fence segments (1 ≤ a, b, c ≤ 10^9).
Output
For each test case print a single integer d — the length of the fourth fence segment that is suitable for building the fence. If there are multiple answers, print any. We can show that an answer always exists.
Example
Input
2
1 2 3
12 34 56
Output
4
42
Note
We can build a quadrilateral with sides 1, 2, 3, 4.
We can build a quadrilateral with sides 12, 34, 56, 42. | instruction | 0 | 20,469 | 23 | 40,938 |
Tags: geometry, math
Correct Solution:
```
from math import sqrt
for _ in range(int(input())):
a,b,c= sorted(map(int,input().split()))
print(int(sqrt((c-a)*(c-a)+b*b)))
``` | output | 1 | 20,469 | 23 | 40,939 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Yura is tasked to build a closed fence in shape of an arbitrary non-degenerate simple quadrilateral. He's already got three straight fence segments with known lengths a, b, and c. Now he needs to find out some possible integer length d of the fourth straight fence segment so that he can build the fence using these four segments. In other words, the fence should have a quadrilateral shape with side lengths equal to a, b, c, and d. Help Yura, find any possible length of the fourth side.
A non-degenerate simple quadrilateral is such a quadrilateral that no three of its corners lie on the same line, and it does not cross itself.
Input
The first line contains a single integer t — the number of test cases (1 ≤ t ≤ 1000). The next t lines describe the test cases.
Each line contains three integers a, b, and c — the lengths of the three fence segments (1 ≤ a, b, c ≤ 10^9).
Output
For each test case print a single integer d — the length of the fourth fence segment that is suitable for building the fence. If there are multiple answers, print any. We can show that an answer always exists.
Example
Input
2
1 2 3
12 34 56
Output
4
42
Note
We can build a quadrilateral with sides 1, 2, 3, 4.
We can build a quadrilateral with sides 12, 34, 56, 42. | instruction | 0 | 20,470 | 23 | 40,940 |
Tags: geometry, math
Correct Solution:
```
from sys import stdin, stdout
t=int(stdin.readline())
for _ in range(t):
a,b,c=map(int,stdin.readline().split())
print(int(((a-b)**2+c**2)**0.5)+1)
``` | output | 1 | 20,470 | 23 | 40,941 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Yura is tasked to build a closed fence in shape of an arbitrary non-degenerate simple quadrilateral. He's already got three straight fence segments with known lengths a, b, and c. Now he needs to find out some possible integer length d of the fourth straight fence segment so that he can build the fence using these four segments. In other words, the fence should have a quadrilateral shape with side lengths equal to a, b, c, and d. Help Yura, find any possible length of the fourth side.
A non-degenerate simple quadrilateral is such a quadrilateral that no three of its corners lie on the same line, and it does not cross itself.
Input
The first line contains a single integer t — the number of test cases (1 ≤ t ≤ 1000). The next t lines describe the test cases.
Each line contains three integers a, b, and c — the lengths of the three fence segments (1 ≤ a, b, c ≤ 10^9).
Output
For each test case print a single integer d — the length of the fourth fence segment that is suitable for building the fence. If there are multiple answers, print any. We can show that an answer always exists.
Example
Input
2
1 2 3
12 34 56
Output
4
42
Note
We can build a quadrilateral with sides 1, 2, 3, 4.
We can build a quadrilateral with sides 12, 34, 56, 42. | instruction | 0 | 20,471 | 23 | 40,942 |
Tags: geometry, math
Correct Solution:
```
import math
t=int(input())
for _ in range(t):
arr=list(map(int,input().split()))
arr.sort()
x=arr[0]
y=arr[1]
z=arr[2]
ans= math.ceil(math.sqrt((z-y)**2 + x**2))
print(ans)
``` | output | 1 | 20,471 | 23 | 40,943 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Yura is tasked to build a closed fence in shape of an arbitrary non-degenerate simple quadrilateral. He's already got three straight fence segments with known lengths a, b, and c. Now he needs to find out some possible integer length d of the fourth straight fence segment so that he can build the fence using these four segments. In other words, the fence should have a quadrilateral shape with side lengths equal to a, b, c, and d. Help Yura, find any possible length of the fourth side.
A non-degenerate simple quadrilateral is such a quadrilateral that no three of its corners lie on the same line, and it does not cross itself.
Input
The first line contains a single integer t — the number of test cases (1 ≤ t ≤ 1000). The next t lines describe the test cases.
Each line contains three integers a, b, and c — the lengths of the three fence segments (1 ≤ a, b, c ≤ 10^9).
Output
For each test case print a single integer d — the length of the fourth fence segment that is suitable for building the fence. If there are multiple answers, print any. We can show that an answer always exists.
Example
Input
2
1 2 3
12 34 56
Output
4
42
Note
We can build a quadrilateral with sides 1, 2, 3, 4.
We can build a quadrilateral with sides 12, 34, 56, 42. | instruction | 0 | 20,472 | 23 | 40,944 |
Tags: geometry, math
Correct Solution:
```
import sys
def In():
return sys.stdin.readline()
def Out(x):
return sys.stdout.write(str(x)+'\n')
t=int(In())
for i in range(t):
a,b,c=map(int,In().split())
m=max(a-b-c,b-a-c,c-a-b)
n=a+b+c
ans=max(m+1,1,n-1)
Out(ans)
``` | output | 1 | 20,472 | 23 | 40,945 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Yura is tasked to build a closed fence in shape of an arbitrary non-degenerate simple quadrilateral. He's already got three straight fence segments with known lengths a, b, and c. Now he needs to find out some possible integer length d of the fourth straight fence segment so that he can build the fence using these four segments. In other words, the fence should have a quadrilateral shape with side lengths equal to a, b, c, and d. Help Yura, find any possible length of the fourth side.
A non-degenerate simple quadrilateral is such a quadrilateral that no three of its corners lie on the same line, and it does not cross itself.
Input
The first line contains a single integer t — the number of test cases (1 ≤ t ≤ 1000). The next t lines describe the test cases.
Each line contains three integers a, b, and c — the lengths of the three fence segments (1 ≤ a, b, c ≤ 10^9).
Output
For each test case print a single integer d — the length of the fourth fence segment that is suitable for building the fence. If there are multiple answers, print any. We can show that an answer always exists.
Example
Input
2
1 2 3
12 34 56
Output
4
42
Note
We can build a quadrilateral with sides 1, 2, 3, 4.
We can build a quadrilateral with sides 12, 34, 56, 42. | instruction | 0 | 20,473 | 23 | 40,946 |
Tags: geometry, math
Correct Solution:
```
# @oj: codeforces
# @id: hitwanyang
# @email: 296866643@qq.com
# @date: 2020-10-09 16:07
# @url:https://codeforc.es/contest/1422/problem/A
import sys,os
from io import BytesIO, IOBase
import collections,itertools,bisect,heapq,math,string
from decimal import *
# region fastio
BUFSIZE = 8192
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
## 注意嵌套括号!!!!!!
## 先有思路,再写代码,别着急!!!
## 先有朴素解法,不要有思维定式,试着换思路解决
def main():
t=int(input())
for i in range(t):
a,b,c=map(int,input().split())
res=[a,b,c]
sr=sorted(res)
mx,mn=a+b+c,max(0,res[2]-res[1]-res[0])
print (mx-1)
if __name__ == "__main__":
main()
``` | output | 1 | 20,473 | 23 | 40,947 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Yura is tasked to build a closed fence in shape of an arbitrary non-degenerate simple quadrilateral. He's already got three straight fence segments with known lengths a, b, and c. Now he needs to find out some possible integer length d of the fourth straight fence segment so that he can build the fence using these four segments. In other words, the fence should have a quadrilateral shape with side lengths equal to a, b, c, and d. Help Yura, find any possible length of the fourth side.
A non-degenerate simple quadrilateral is such a quadrilateral that no three of its corners lie on the same line, and it does not cross itself.
Input
The first line contains a single integer t — the number of test cases (1 ≤ t ≤ 1000). The next t lines describe the test cases.
Each line contains three integers a, b, and c — the lengths of the three fence segments (1 ≤ a, b, c ≤ 10^9).
Output
For each test case print a single integer d — the length of the fourth fence segment that is suitable for building the fence. If there are multiple answers, print any. We can show that an answer always exists.
Example
Input
2
1 2 3
12 34 56
Output
4
42
Note
We can build a quadrilateral with sides 1, 2, 3, 4.
We can build a quadrilateral with sides 12, 34, 56, 42. | instruction | 0 | 20,474 | 23 | 40,948 |
Tags: geometry, math
Correct Solution:
```
t = int(input())
results = []
for q in range(t):
b, c, d = [int(i) for i in input().split()]
result = b + c + d - 1
results.append(result)
for i in results:
print(i)
``` | output | 1 | 20,474 | 23 | 40,949 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Yura is tasked to build a closed fence in shape of an arbitrary non-degenerate simple quadrilateral. He's already got three straight fence segments with known lengths a, b, and c. Now he needs to find out some possible integer length d of the fourth straight fence segment so that he can build the fence using these four segments. In other words, the fence should have a quadrilateral shape with side lengths equal to a, b, c, and d. Help Yura, find any possible length of the fourth side.
A non-degenerate simple quadrilateral is such a quadrilateral that no three of its corners lie on the same line, and it does not cross itself.
Input
The first line contains a single integer t — the number of test cases (1 ≤ t ≤ 1000). The next t lines describe the test cases.
Each line contains three integers a, b, and c — the lengths of the three fence segments (1 ≤ a, b, c ≤ 10^9).
Output
For each test case print a single integer d — the length of the fourth fence segment that is suitable for building the fence. If there are multiple answers, print any. We can show that an answer always exists.
Example
Input
2
1 2 3
12 34 56
Output
4
42
Note
We can build a quadrilateral with sides 1, 2, 3, 4.
We can build a quadrilateral with sides 12, 34, 56, 42. | instruction | 0 | 20,475 | 23 | 40,950 |
Tags: geometry, math
Correct Solution:
```
import os
import sys
import io
import functools
import copy
import math
# input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline # 神奇快读，无法运行调试
GANS = []
# def print(*args): # 神奇快写，最后得写上os.write
# global GANS
# for i in args:
# GANS.append(f'{i}'.encode())
def cmp(x,y):
if x[1]==y[1]:
return -(y[0]-x[0])
return -(x[1]-y[1])
t = int(input())
for _ in range(t):
n,m,s = map(int,input().split())
l = [n,m,s]
l.sort()
print(l[2])
``` | output | 1 | 20,475 | 23 | 40,951 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Yura is tasked to build a closed fence in shape of an arbitrary non-degenerate simple quadrilateral. He's already got three straight fence segments with known lengths a, b, and c. Now he needs to find out some possible integer length d of the fourth straight fence segment so that he can build the fence using these four segments. In other words, the fence should have a quadrilateral shape with side lengths equal to a, b, c, and d. Help Yura, find any possible length of the fourth side.
A non-degenerate simple quadrilateral is such a quadrilateral that no three of its corners lie on the same line, and it does not cross itself.
Input
The first line contains a single integer t — the number of test cases (1 ≤ t ≤ 1000). The next t lines describe the test cases.
Each line contains three integers a, b, and c — the lengths of the three fence segments (1 ≤ a, b, c ≤ 10^9).
Output
For each test case print a single integer d — the length of the fourth fence segment that is suitable for building the fence. If there are multiple answers, print any. We can show that an answer always exists.
Example
Input
2
1 2 3
12 34 56
Output
4
42
Note
We can build a quadrilateral with sides 1, 2, 3, 4.
We can build a quadrilateral with sides 12, 34, 56, 42.
Submitted Solution:
```
t = input()
for i in range(int(t)):
a, b, c = input().split()
a, b, c = int(a), int(b), int(c)
print(a+b+c-1)
``` | instruction | 0 | 20,476 | 23 | 40,952 |
Yes | output | 1 | 20,476 | 23 | 40,953 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Yura is tasked to build a closed fence in shape of an arbitrary non-degenerate simple quadrilateral. He's already got three straight fence segments with known lengths a, b, and c. Now he needs to find out some possible integer length d of the fourth straight fence segment so that he can build the fence using these four segments. In other words, the fence should have a quadrilateral shape with side lengths equal to a, b, c, and d. Help Yura, find any possible length of the fourth side.
A non-degenerate simple quadrilateral is such a quadrilateral that no three of its corners lie on the same line, and it does not cross itself.
Input
The first line contains a single integer t — the number of test cases (1 ≤ t ≤ 1000). The next t lines describe the test cases.
Each line contains three integers a, b, and c — the lengths of the three fence segments (1 ≤ a, b, c ≤ 10^9).
Output
For each test case print a single integer d — the length of the fourth fence segment that is suitable for building the fence. If there are multiple answers, print any. We can show that an answer always exists.
Example
Input
2
1 2 3
12 34 56
Output
4
42
Note
We can build a quadrilateral with sides 1, 2, 3, 4.
We can build a quadrilateral with sides 12, 34, 56, 42.
Submitted Solution:
```
"""
// Author : snape_here - Susanta Mukherjee
"""
from __future__ import division, print_function
import os,sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
def ii(): return int(input())
def fi(): return float(input())
def si(): return input()
def msi(): return map(str,input().split())
def mi(): return map(int,input().split())
def li(): return list(mi())
def read():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
def gcd(x, y):
while y:
x, y = y, x % y
return x
def lcm(x, y):
return (x*y)//(gcd(x,y))
mod=1000000007
def modInverse(b,m):
g = gcd(b, m)
if (g != 1):
return -1
else:
return pow(b, m - 2, m)
def ceil(x,y):
if x%y==0:
return x//y
else:
return x//y+1
def modu(a,b,m):
a = a % m
inv = modInverse(b,m)
if(inv == -1):
return -999999999
else:
return (inv*a)%m
from math import log,sqrt,factorial,cos,tan,sin,radians,floor
import bisect
from decimal import *
getcontext().prec = 8
abc="abcdefghijklmnopqrstuvwxyz"
pi=3.141592653589793238
def fn(n):
c=0
while n%2==0:
c+=1
n//=2
return c
def main():
for _ in range(ii()):
l=li()
l.sort()
if l[0]==l[1]:
print(l[2])
elif l[1]==l[2]:
print(l[0])
else:
print(l[2])
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
#read()
main()
``` | instruction | 0 | 20,477 | 23 | 40,954 |
Yes | output | 1 | 20,477 | 23 | 40,955 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Yura is tasked to build a closed fence in shape of an arbitrary non-degenerate simple quadrilateral. He's already got three straight fence segments with known lengths a, b, and c. Now he needs to find out some possible integer length d of the fourth straight fence segment so that he can build the fence using these four segments. In other words, the fence should have a quadrilateral shape with side lengths equal to a, b, c, and d. Help Yura, find any possible length of the fourth side.
A non-degenerate simple quadrilateral is such a quadrilateral that no three of its corners lie on the same line, and it does not cross itself.
Input
The first line contains a single integer t — the number of test cases (1 ≤ t ≤ 1000). The next t lines describe the test cases.
Each line contains three integers a, b, and c — the lengths of the three fence segments (1 ≤ a, b, c ≤ 10^9).
Output
For each test case print a single integer d — the length of the fourth fence segment that is suitable for building the fence. If there are multiple answers, print any. We can show that an answer always exists.
Example
Input
2
1 2 3
12 34 56
Output
4
42
Note
We can build a quadrilateral with sides 1, 2, 3, 4.
We can build a quadrilateral with sides 12, 34, 56, 42.
Submitted Solution:
```
for s in[*open(0)][1:]:a=*map(int,s.split()),;print(sum(a)-1)
``` | instruction | 0 | 20,478 | 23 | 40,956 |
Yes | output | 1 | 20,478 | 23 | 40,957 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Yura is tasked to build a closed fence in shape of an arbitrary non-degenerate simple quadrilateral. He's already got three straight fence segments with known lengths a, b, and c. Now he needs to find out some possible integer length d of the fourth straight fence segment so that he can build the fence using these four segments. In other words, the fence should have a quadrilateral shape with side lengths equal to a, b, c, and d. Help Yura, find any possible length of the fourth side.
A non-degenerate simple quadrilateral is such a quadrilateral that no three of its corners lie on the same line, and it does not cross itself.
Input
The first line contains a single integer t — the number of test cases (1 ≤ t ≤ 1000). The next t lines describe the test cases.
Each line contains three integers a, b, and c — the lengths of the three fence segments (1 ≤ a, b, c ≤ 10^9).
Output
For each test case print a single integer d — the length of the fourth fence segment that is suitable for building the fence. If there are multiple answers, print any. We can show that an answer always exists.
Example
Input
2
1 2 3
12 34 56
Output
4
42
Note
We can build a quadrilateral with sides 1, 2, 3, 4.
We can build a quadrilateral with sides 12, 34, 56, 42.
Submitted Solution:
```
t=int(input())
for _ in range(t):
arr=list(map(int,input().split()))
print(sum(arr)-1)
``` | instruction | 0 | 20,479 | 23 | 40,958 |
Yes | output | 1 | 20,479 | 23 | 40,959 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Yura is tasked to build a closed fence in shape of an arbitrary non-degenerate simple quadrilateral. He's already got three straight fence segments with known lengths a, b, and c. Now he needs to find out some possible integer length d of the fourth straight fence segment so that he can build the fence using these four segments. In other words, the fence should have a quadrilateral shape with side lengths equal to a, b, c, and d. Help Yura, find any possible length of the fourth side.
A non-degenerate simple quadrilateral is such a quadrilateral that no three of its corners lie on the same line, and it does not cross itself.
Input
The first line contains a single integer t — the number of test cases (1 ≤ t ≤ 1000). The next t lines describe the test cases.
Each line contains three integers a, b, and c — the lengths of the three fence segments (1 ≤ a, b, c ≤ 10^9).
Output
For each test case print a single integer d — the length of the fourth fence segment that is suitable for building the fence. If there are multiple answers, print any. We can show that an answer always exists.
Example
Input
2
1 2 3
12 34 56
Output
4
42
Note
We can build a quadrilateral with sides 1, 2, 3, 4.
We can build a quadrilateral with sides 12, 34, 56, 42.
Submitted Solution:
```
import math
t = int(input())
for i in range(t):
a,b,c = input().split()
a,b,c = int(a), int(b), int(c)
print(int((a+b+c)/3))
``` | instruction | 0 | 20,480 | 23 | 40,960 |
No | output | 1 | 20,480 | 23 | 40,961 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Yura is tasked to build a closed fence in shape of an arbitrary non-degenerate simple quadrilateral. He's already got three straight fence segments with known lengths a, b, and c. Now he needs to find out some possible integer length d of the fourth straight fence segment so that he can build the fence using these four segments. In other words, the fence should have a quadrilateral shape with side lengths equal to a, b, c, and d. Help Yura, find any possible length of the fourth side.
A non-degenerate simple quadrilateral is such a quadrilateral that no three of its corners lie on the same line, and it does not cross itself.
Input
The first line contains a single integer t — the number of test cases (1 ≤ t ≤ 1000). The next t lines describe the test cases.
Each line contains three integers a, b, and c — the lengths of the three fence segments (1 ≤ a, b, c ≤ 10^9).
Output
For each test case print a single integer d — the length of the fourth fence segment that is suitable for building the fence. If there are multiple answers, print any. We can show that an answer always exists.
Example
Input
2
1 2 3
12 34 56
Output
4
42
Note
We can build a quadrilateral with sides 1, 2, 3, 4.
We can build a quadrilateral with sides 12, 34, 56, 42.
Submitted Solution:
```
n=int(input())
for i in range(0,n,1):
a,b,c = input().split()
d=a+b+c
print(c)
``` | instruction | 0 | 20,481 | 23 | 40,962 |
No | output | 1 | 20,481 | 23 | 40,963 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Yura is tasked to build a closed fence in shape of an arbitrary non-degenerate simple quadrilateral. He's already got three straight fence segments with known lengths a, b, and c. Now he needs to find out some possible integer length d of the fourth straight fence segment so that he can build the fence using these four segments. In other words, the fence should have a quadrilateral shape with side lengths equal to a, b, c, and d. Help Yura, find any possible length of the fourth side.
A non-degenerate simple quadrilateral is such a quadrilateral that no three of its corners lie on the same line, and it does not cross itself.
Input
The first line contains a single integer t — the number of test cases (1 ≤ t ≤ 1000). The next t lines describe the test cases.
Each line contains three integers a, b, and c — the lengths of the three fence segments (1 ≤ a, b, c ≤ 10^9).
Output
For each test case print a single integer d — the length of the fourth fence segment that is suitable for building the fence. If there are multiple answers, print any. We can show that an answer always exists.
Example
Input
2
1 2 3
12 34 56
Output
4
42
Note
We can build a quadrilateral with sides 1, 2, 3, 4.
We can build a quadrilateral with sides 12, 34, 56, 42.
Submitted Solution:
```
#: Author - Soumya Saurav
import sys,io,os,time
from collections import defaultdict
from collections import Counter
from collections import deque
from itertools import combinations
from itertools import permutations
import bisect,math,heapq
alphabet = "abcdefghijklmnopqrstuvwxyz"
input = sys.stdin.readline
########################################
for ii in range(int(input())):
arr = list(map(int , input().split()))
arr.sort()
theta = math.atan((arr[2]-arr[0])/arr[1])
#print(theta,arr)
print(math.floor(arr[1]/math.cos(theta)))
'''
# Wrap solution for more recursion depth
#submit as python3
import collections,sys,threading
sys.setrecursionlimit(10**9)
threading.stack_size(10**8)
threading.Thread(target=solve).start()
'''
``` | instruction | 0 | 20,482 | 23 | 40,964 |
No | output | 1 | 20,482 | 23 | 40,965 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Yura is tasked to build a closed fence in shape of an arbitrary non-degenerate simple quadrilateral. He's already got three straight fence segments with known lengths a, b, and c. Now he needs to find out some possible integer length d of the fourth straight fence segment so that he can build the fence using these four segments. In other words, the fence should have a quadrilateral shape with side lengths equal to a, b, c, and d. Help Yura, find any possible length of the fourth side.
A non-degenerate simple quadrilateral is such a quadrilateral that no three of its corners lie on the same line, and it does not cross itself.
Input
The first line contains a single integer t — the number of test cases (1 ≤ t ≤ 1000). The next t lines describe the test cases.
Each line contains three integers a, b, and c — the lengths of the three fence segments (1 ≤ a, b, c ≤ 10^9).
Output
For each test case print a single integer d — the length of the fourth fence segment that is suitable for building the fence. If there are multiple answers, print any. We can show that an answer always exists.
Example
Input
2
1 2 3
12 34 56
Output
4
42
Note
We can build a quadrilateral with sides 1, 2, 3, 4.
We can build a quadrilateral with sides 12, 34, 56, 42.
Submitted Solution:
```
for _ in range(int(input())):
a,b,c=map(int,input().split())
print(a+c-b)
``` | instruction | 0 | 20,483 | 23 | 40,966 |
No | output | 1 | 20,483 | 23 | 40,967 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ayrat is looking for the perfect code. He decided to start his search from an infinite field tiled by hexagons. For convenience the coordinate system is introduced, take a look at the picture to see how the coordinates of hexagon are defined:
<image> <image> Ayrat is searching through the field. He started at point (0, 0) and is moving along the spiral (see second picture). Sometimes he forgets where he is now. Help Ayrat determine his location after n moves.
Input
The only line of the input contains integer n (0 ≤ n ≤ 1018) — the number of Ayrat's moves.
Output
Print two integers x and y — current coordinates of Ayrat coordinates.
Examples
Input
3
Output
-2 0
Input
7
Output
3 2
Submitted Solution:
```
from functools import reduce
from decimal import *
import math
import itertools
class pair(list):
def __init__(self, a, b):
list.__init__(self, (a, b))
def __add__(self, q): return pair(self[0]+q[0], self[1]+q[1])
def __sub__(self, q): return pair(self[0]-q[0], self[1]-q[1])
def __mul__(self, k): return pair(k*self[0], k*self[1])
def __neg__(self): return pair(-self[0], -self[1])
setcontext(ExtendedContext)
getcontext().prec = 100
a, b, c = pair(1,2), pair(-2,0), pair(-1,2)
n = int(input())
k = int(((Decimal(3 + 4*n) / Decimal(3)).sqrt() - Decimal(1)) // 2)
n1 = n - 3*k*(k+1)
x, y = n1//(k+1), n1%(k+1)
L = [c, b, -a, -c, -b, a]
M = [pair(0,0)] + list(itertools.accumulate(L))
if n1 == 0:
ans = pair(2,0)*k
else:
ans = pair(2,0)*(k+1) + M[x]*(k+1) + L[x]*y
print(ans[0], ans[1])
``` | instruction | 0 | 20,731 | 23 | 41,462 |
Yes | output | 1 | 20,731 | 23 | 41,463 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n points on a line with their coordinates xi. Find the point x so the sum of distances to the given points is minimal.
Input
The first line contains integer n (1 ≤ n ≤ 3·105) — the number of points on the line.
The second line contains n integers xi ( - 109 ≤ xi ≤ 109) — the coordinates of the given n points.
Output
Print the only integer x — the position of the optimal point on the line. If there are several optimal points print the position of the leftmost one. It is guaranteed that the answer is always the integer.
Example
Input
4
1 2 3 4
Output
2 | instruction | 0 | 20,766 | 23 | 41,532 |
Tags: brute force, sortings
Correct Solution:
```
##n = int(input())
##a = list(map(int, input().split()))
##print(" ".join(map(str, res)))
n = int(input())
x = list(map(int, input().split()))
x.sort()
print(x[int((n+1)/2)-1])
``` | output | 1 | 20,766 | 23 | 41,533 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n points on a line with their coordinates xi. Find the point x so the sum of distances to the given points is minimal.
Input
The first line contains integer n (1 ≤ n ≤ 3·105) — the number of points on the line.
The second line contains n integers xi ( - 109 ≤ xi ≤ 109) — the coordinates of the given n points.
Output
Print the only integer x — the position of the optimal point on the line. If there are several optimal points print the position of the leftmost one. It is guaranteed that the answer is always the integer.
Example
Input
4
1 2 3 4
Output
2 | instruction | 0 | 20,767 | 23 | 41,534 |
Tags: brute force, sortings
Correct Solution:
```
n=int(input())
l=list(map(int,input().split()))
l.sort()
x=n//2
if n%2==0:
x-=1
print(l[x])
``` | output | 1 | 20,767 | 23 | 41,535 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.