text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Beroffice text editor has a wide range of features that help working with text. One of the features is an automatic search for typos and suggestions of how to fix them.
Beroffice works only with small English letters (i.e. with 26 letters from a to z). Beroffice thinks that a word is typed with a typo if there are three or more consonants in a row in the word. The only exception is that if the block of consonants has all letters the same, then this block (even if its length is greater than three) is not considered a typo. Formally, a word is typed with a typo if there is a block of not less that three consonants in a row, and there are at least two different letters in this block.
For example:
* the following words have typos: "hellno", "hackcerrs" and "backtothefutttture";
* the following words don't have typos: "helllllooooo", "tobeornottobe" and "oooooo".
When Beroffice editor finds a word with a typo, it inserts as little as possible number of spaces in this word (dividing it into several words) in such a way that each of the resulting words is typed without any typos.
Implement this feature of Beroffice editor. Consider the following letters as the only vowels: 'a', 'e', 'i', 'o' and 'u'. All the other letters are consonants in this problem.
Input
The only line contains a non-empty word consisting of small English letters. The length of the word is between 1 and 3000 letters.
Output
Print the given word without any changes if there are no typos.
If there is at least one typo in the word, insert the minimum number of spaces into the word so that each of the resulting words doesn't have any typos. If there are multiple solutions, print any of them.
Examples
Input
hellno
Output
hell no
Input
abacaba
Output
abacaba
Input
asdfasdf
Output
asd fasd f
Submitted Solution:
```
s = input()
g = {'a', 'e', 'i', 'o', 'u'}
l = 0
lc = ""
for ch in s:
if ch not in g and lc != ch:
l+=1
else: l=0
if l>2 and lc != ch:
print(" ", end="")
l = 1
lc = ch
print(ch, end="")
```
No
| 8,100 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Beroffice text editor has a wide range of features that help working with text. One of the features is an automatic search for typos and suggestions of how to fix them.
Beroffice works only with small English letters (i.e. with 26 letters from a to z). Beroffice thinks that a word is typed with a typo if there are three or more consonants in a row in the word. The only exception is that if the block of consonants has all letters the same, then this block (even if its length is greater than three) is not considered a typo. Formally, a word is typed with a typo if there is a block of not less that three consonants in a row, and there are at least two different letters in this block.
For example:
* the following words have typos: "hellno", "hackcerrs" and "backtothefutttture";
* the following words don't have typos: "helllllooooo", "tobeornottobe" and "oooooo".
When Beroffice editor finds a word with a typo, it inserts as little as possible number of spaces in this word (dividing it into several words) in such a way that each of the resulting words is typed without any typos.
Implement this feature of Beroffice editor. Consider the following letters as the only vowels: 'a', 'e', 'i', 'o' and 'u'. All the other letters are consonants in this problem.
Input
The only line contains a non-empty word consisting of small English letters. The length of the word is between 1 and 3000 letters.
Output
Print the given word without any changes if there are no typos.
If there is at least one typo in the word, insert the minimum number of spaces into the word so that each of the resulting words doesn't have any typos. If there are multiple solutions, print any of them.
Examples
Input
hellno
Output
hell no
Input
abacaba
Output
abacaba
Input
asdfasdf
Output
asd fasd f
Submitted Solution:
```
import re
s = list(input())
#s = list("orfyaenanabsdfckumulsbolo")
vowels = "aeiou"
c = ""
sections = []
for i in range(len(s)):
if s[i] in vowels:
sections.append(c)
sections.append(s[i])
c = ""
elif i == len(s) - 1:
c += s[i]
sections.append(c)
else:
c += s[i]
new = []
for i in range(len(sections)):
blurb = sections[i]
length = len(blurb)
if length >= 4 and length % 2 == 0:
for j in range(length // 2):
if j == (length // 2) - 1:
new.append(blurb)
else:
new.append(blurb[:2] + " ")
blurb = blurb[2:]
elif length >= 4 and length % 2 != 0:
for j in range(length // 2):
if j == (length // 2) - 1:
new.append(blurb)
else:
new.append(blurb[:2] + " ")
blurb = blurb[2:]
elif length >= 3:
new.append(blurb[:2] + " ")
new.append(blurb[2:])
else:
new.append(blurb)
t = ""
new_s = t.join(new)
print(new_s)
```
No
| 8,101 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Beroffice text editor has a wide range of features that help working with text. One of the features is an automatic search for typos and suggestions of how to fix them.
Beroffice works only with small English letters (i.e. with 26 letters from a to z). Beroffice thinks that a word is typed with a typo if there are three or more consonants in a row in the word. The only exception is that if the block of consonants has all letters the same, then this block (even if its length is greater than three) is not considered a typo. Formally, a word is typed with a typo if there is a block of not less that three consonants in a row, and there are at least two different letters in this block.
For example:
* the following words have typos: "hellno", "hackcerrs" and "backtothefutttture";
* the following words don't have typos: "helllllooooo", "tobeornottobe" and "oooooo".
When Beroffice editor finds a word with a typo, it inserts as little as possible number of spaces in this word (dividing it into several words) in such a way that each of the resulting words is typed without any typos.
Implement this feature of Beroffice editor. Consider the following letters as the only vowels: 'a', 'e', 'i', 'o' and 'u'. All the other letters are consonants in this problem.
Input
The only line contains a non-empty word consisting of small English letters. The length of the word is between 1 and 3000 letters.
Output
Print the given word without any changes if there are no typos.
If there is at least one typo in the word, insert the minimum number of spaces into the word so that each of the resulting words doesn't have any typos. If there are multiple solutions, print any of them.
Examples
Input
hellno
Output
hell no
Input
abacaba
Output
abacaba
Input
asdfasdf
Output
asd fasd f
Submitted Solution:
```
def Dif(string):
if s.count(s[0]) != len(s):
return True
else:
return False
s = input()
s1 = ''
b = False
for i in range(len(s)):
if s[i] != 'a' and s[i] != 'e' and s[i] != 'i' and s[i] != 'o' and s[i] != 'u':
s1 += s[i]
if len(s1) > 2 and Dif(s1):
b = True
break
else:
s1 = ''
if b:
s1 = ''
s2 = ''
for i in range(len(s)):
if s[i] == 'a' or s[i] == 'e' or s[i] == 'i' or s[i] == 'o' or s[i] == 'u':
if len(s1) > 0 and s1[-1] == ' ':
s1 = s1[:len(s1) - 1:] + s[i]
else:
s1 += s[i]
s2 = ''
else:
s2 += s[i]
s1 += s[i]
if len(s2) > 1 and Dif(s2):
s1 += ' '
s2 = ''
s = s1
print(s)
```
No
| 8,102 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Evlampiy has found one more cool application to process photos. However the application has certain limitations.
Each photo i has a contrast vi. In order for the processing to be truly of high quality, the application must receive at least k photos with contrasts which differ as little as possible.
Evlampiy already knows the contrast vi for each of his n photos. Now he wants to split the photos into groups, so that each group contains at least k photos. As a result, each photo must belong to exactly one group.
He considers a processing time of the j-th group to be the difference between the maximum and minimum values of vi in the group. Because of multithreading the processing time of a division into groups is the maximum processing time among all groups.
Split n photos into groups in a such way that the processing time of the division is the minimum possible, i.e. that the the maximum processing time over all groups as least as possible.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 3·105) — number of photos and minimum size of a group.
The second line contains n integers v1, v2, ..., vn (1 ≤ vi ≤ 109), where vi is the contrast of the i-th photo.
Output
Print the minimal processing time of the division into groups.
Examples
Input
5 2
50 110 130 40 120
Output
20
Input
4 1
2 3 4 1
Output
0
Note
In the first example the photos should be split into 2 groups: [40, 50] and [110, 120, 130]. The processing time of the first group is 10, and the processing time of the second group is 20. Maximum among 10 and 20 is 20. It is impossible to split the photos into groups in a such way that the processing time of division is less than 20.
In the second example the photos should be split into four groups, each containing one photo. So the minimal possible processing time of a division is 0.
Tags: binary search, dp
Correct Solution:
```
def f(m):
global dp, sdp
l = 0
for i in range(n):
while l < n and v[l] < v[i] - m:
l += 1
if l - 1 > i - k:
dp[i] = False
else:
dp[i] = (sdp[i - k + 1] != sdp[l - 1])
sdp[i + 1] = sdp[i] + (1 if dp[i] else 0)
return dp[n - 1]
n, k = map(int, input().split())
dp = [False for i in range(n + 2)]
sdp = [0 for i in range(n + 2)]
dp[-1] = True
sdp[0] = 1
v = list(map(int, input().split()))
v.sort()
le = -1
r = v[-1] - v[0]
while r - le > 1:
m = (r + le) // 2
if f(m):
r = m
else:
le = m
print(r)
```
| 8,103 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Evlampiy has found one more cool application to process photos. However the application has certain limitations.
Each photo i has a contrast vi. In order for the processing to be truly of high quality, the application must receive at least k photos with contrasts which differ as little as possible.
Evlampiy already knows the contrast vi for each of his n photos. Now he wants to split the photos into groups, so that each group contains at least k photos. As a result, each photo must belong to exactly one group.
He considers a processing time of the j-th group to be the difference between the maximum and minimum values of vi in the group. Because of multithreading the processing time of a division into groups is the maximum processing time among all groups.
Split n photos into groups in a such way that the processing time of the division is the minimum possible, i.e. that the the maximum processing time over all groups as least as possible.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 3·105) — number of photos and minimum size of a group.
The second line contains n integers v1, v2, ..., vn (1 ≤ vi ≤ 109), where vi is the contrast of the i-th photo.
Output
Print the minimal processing time of the division into groups.
Examples
Input
5 2
50 110 130 40 120
Output
20
Input
4 1
2 3 4 1
Output
0
Note
In the first example the photos should be split into 2 groups: [40, 50] and [110, 120, 130]. The processing time of the first group is 10, and the processing time of the second group is 20. Maximum among 10 and 20 is 20. It is impossible to split the photos into groups in a such way that the processing time of division is less than 20.
In the second example the photos should be split into four groups, each containing one photo. So the minimal possible processing time of a division is 0.
Tags: binary search, dp
Correct Solution:
```
from bisect import bisect_left, bisect_right
class Result:
def __init__(self, index, value):
self.index = index
self.value = value
class BinarySearch:
def __init__(self):
pass
@staticmethod
def greater_than(num: int, func, size: int = 1):
"""Searches for smallest element greater than num!"""
if isinstance(func, list):
index = bisect_right(func, num)
if index == len(func):
return Result(None, None)
else:
return Result(index, func[index])
else:
alpha, omega = 0, size - 1
if func(omega) <= num:
return Result(None, None)
while alpha < omega:
if func(alpha) > num:
return Result(alpha, func(alpha))
if omega == alpha + 1:
return Result(omega, func(omega))
mid = (alpha + omega) // 2
if func(mid) > num:
omega = mid
else:
alpha = mid
@staticmethod
def less_than(num: int, func, size: int = 1):
"""Searches for largest element less than num!"""
if isinstance(func, list):
index = bisect_left(func, num) - 1
if index == -1:
return Result(None, None)
else:
return Result(index, func[index])
else:
alpha, omega = 0, size - 1
if func(alpha) >= num:
return Result(None, None)
while alpha < omega:
if func(omega) < num:
return Result(omega, func(omega))
if omega == alpha + 1:
return Result(alpha, func(alpha))
mid = (alpha + omega) // 2
if func(mid) < num:
alpha = mid
else:
omega = mid
# ------------------- 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 math import gcd, ceil
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
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
for _ in range(int(input()) if not True else 1):
# l, r, m = map(int, input().split())
n, k = map(int, input().split())
# c, d = map(int, input().split())
a = sorted(list(map(int, input().split())))
if k == 1:
print(0)
continue
# b = list(map(int, input().split()))
bs = BinarySearch()
a=[0] + a
d = [False]*(n+1)
def check(x):
dp = list(d)
dp[0] = True
if a[k] - a[1] <= x:
dp[k] = True
else:return 0
cur = 1
for i in range(k+1, n+1):
while cur <= n and a[i]-a[cur] > x:
cur += 1
while cur <= n and not dp[cur-1]:
cur += 1
if cur <= i-k+1:
dp[i] = True
return dp[-1]
alpha, omega = 0, 10 ** 9
ans = omega
while alpha < omega:
mid = (alpha + omega) // 2
x = mid
if check(x):
omega = mid
ans = omega
else:
alpha = mid + 1
print(ans)
```
| 8,104 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Evlampiy has found one more cool application to process photos. However the application has certain limitations.
Each photo i has a contrast vi. In order for the processing to be truly of high quality, the application must receive at least k photos with contrasts which differ as little as possible.
Evlampiy already knows the contrast vi for each of his n photos. Now he wants to split the photos into groups, so that each group contains at least k photos. As a result, each photo must belong to exactly one group.
He considers a processing time of the j-th group to be the difference between the maximum and minimum values of vi in the group. Because of multithreading the processing time of a division into groups is the maximum processing time among all groups.
Split n photos into groups in a such way that the processing time of the division is the minimum possible, i.e. that the the maximum processing time over all groups as least as possible.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 3·105) — number of photos and minimum size of a group.
The second line contains n integers v1, v2, ..., vn (1 ≤ vi ≤ 109), where vi is the contrast of the i-th photo.
Output
Print the minimal processing time of the division into groups.
Examples
Input
5 2
50 110 130 40 120
Output
20
Input
4 1
2 3 4 1
Output
0
Note
In the first example the photos should be split into 2 groups: [40, 50] and [110, 120, 130]. The processing time of the first group is 10, and the processing time of the second group is 20. Maximum among 10 and 20 is 20. It is impossible to split the photos into groups in a such way that the processing time of division is less than 20.
In the second example the photos should be split into four groups, each containing one photo. So the minimal possible processing time of a division is 0.
Submitted Solution:
```
import sys
def min_cluster(ls, k):
print('min_cluster(', ls, ',', k, ')', file=sys.stderr)
if len(ls) == 0:
return 0
order = sorted(zip(map(lambda x: x[0], ls), list(range(len(ls)))), reverse=True)
print(order, file=sys.stderr)
rs = []
for o in order:
if min(o[1], len(ls) - o[1] - 1) >= k - 1:
# on peut cut
print('cut à', o, file=sys.stderr)
return max(min_cluster(ls[0:o[1]], k), min_cluster(ls[o[1] + 1:], k))
else: # on peut pas cut
r = sum(lse[0] for lse in ls)
rs.append(r)
r = max(rs)
print(' return:', r, file=sys.stderr)
return r
n, k = map(int, input().split())
v = list(sorted(map(int, input().split())))
if k == 1:
print(0)
exit(0)
li = []
for i in range(1, n):
t = v[i] - v[i - 1]
li.append((t, v[i - 1], v[i]))
print(li, file=sys.stderr)
print(min_cluster(li, k))
```
No
| 8,105 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Evlampiy has found one more cool application to process photos. However the application has certain limitations.
Each photo i has a contrast vi. In order for the processing to be truly of high quality, the application must receive at least k photos with contrasts which differ as little as possible.
Evlampiy already knows the contrast vi for each of his n photos. Now he wants to split the photos into groups, so that each group contains at least k photos. As a result, each photo must belong to exactly one group.
He considers a processing time of the j-th group to be the difference between the maximum and minimum values of vi in the group. Because of multithreading the processing time of a division into groups is the maximum processing time among all groups.
Split n photos into groups in a such way that the processing time of the division is the minimum possible, i.e. that the the maximum processing time over all groups as least as possible.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 3·105) — number of photos and minimum size of a group.
The second line contains n integers v1, v2, ..., vn (1 ≤ vi ≤ 109), where vi is the contrast of the i-th photo.
Output
Print the minimal processing time of the division into groups.
Examples
Input
5 2
50 110 130 40 120
Output
20
Input
4 1
2 3 4 1
Output
0
Note
In the first example the photos should be split into 2 groups: [40, 50] and [110, 120, 130]. The processing time of the first group is 10, and the processing time of the second group is 20. Maximum among 10 and 20 is 20. It is impossible to split the photos into groups in a such way that the processing time of division is less than 20.
In the second example the photos should be split into four groups, each containing one photo. So the minimal possible processing time of a division is 0.
Submitted Solution:
```
def f(m):
start = 0
for i in range(n):
if v[i] > v[start] + m:
if i - start >= k:
start = i
else:
return False
#if n - start < k:
# return False
return True
n, k = map(int, input().split())
v = list(map(int, input().split()))
v.sort()
l = -1
r = v[-1] - v[0]
while r - l > 1:
m = (r + l) // 2
if f(m):
r = m
else:
l = m
ans = r
for i in range(r - 100, r):
if f(i):
ans = i
print(ans)
```
No
| 8,106 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Evlampiy has found one more cool application to process photos. However the application has certain limitations.
Each photo i has a contrast vi. In order for the processing to be truly of high quality, the application must receive at least k photos with contrasts which differ as little as possible.
Evlampiy already knows the contrast vi for each of his n photos. Now he wants to split the photos into groups, so that each group contains at least k photos. As a result, each photo must belong to exactly one group.
He considers a processing time of the j-th group to be the difference between the maximum and minimum values of vi in the group. Because of multithreading the processing time of a division into groups is the maximum processing time among all groups.
Split n photos into groups in a such way that the processing time of the division is the minimum possible, i.e. that the the maximum processing time over all groups as least as possible.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 3·105) — number of photos and minimum size of a group.
The second line contains n integers v1, v2, ..., vn (1 ≤ vi ≤ 109), where vi is the contrast of the i-th photo.
Output
Print the minimal processing time of the division into groups.
Examples
Input
5 2
50 110 130 40 120
Output
20
Input
4 1
2 3 4 1
Output
0
Note
In the first example the photos should be split into 2 groups: [40, 50] and [110, 120, 130]. The processing time of the first group is 10, and the processing time of the second group is 20. Maximum among 10 and 20 is 20. It is impossible to split the photos into groups in a such way that the processing time of division is less than 20.
In the second example the photos should be split into four groups, each containing one photo. So the minimal possible processing time of a division is 0.
Submitted Solution:
```
import sys
def min_cluster(ls, k):
print('min_cluster(', ls, ',', k, ')', file=sys.stderr)
if len(ls) == 1:
return ls[0][0]
order = sorted(zip(map(lambda x: x[0], ls), list(range(len(ls)))), reverse=True)
print(order, file=sys.stderr)
for o in order:
if min(o[1], len(ls) - o[1] - 1) >= k - 1:
# on peut cut
print('cut à', o, file=sys.stderr)
return max(min_cluster(ls[0:o[1]], k), min_cluster(ls[o[1] + 1:], k))
else: # on peut pas cut
r = sum(lse[0] for lse in ls)
print(' return:', r, file=sys.stderr)
return r
n, k = map(int, input().split())
v = list(sorted(map(int, input().split())))
if k == 1:
print(0)
exit(0)
li = []
for i in range(1, n):
t = v[i] - v[i - 1]
li.append((t, v[i - 1], v[i]))
print(li, file=sys.stderr)
print(min_cluster(li, k))
```
No
| 8,107 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Evlampiy has found one more cool application to process photos. However the application has certain limitations.
Each photo i has a contrast vi. In order for the processing to be truly of high quality, the application must receive at least k photos with contrasts which differ as little as possible.
Evlampiy already knows the contrast vi for each of his n photos. Now he wants to split the photos into groups, so that each group contains at least k photos. As a result, each photo must belong to exactly one group.
He considers a processing time of the j-th group to be the difference between the maximum and minimum values of vi in the group. Because of multithreading the processing time of a division into groups is the maximum processing time among all groups.
Split n photos into groups in a such way that the processing time of the division is the minimum possible, i.e. that the the maximum processing time over all groups as least as possible.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 3·105) — number of photos and minimum size of a group.
The second line contains n integers v1, v2, ..., vn (1 ≤ vi ≤ 109), where vi is the contrast of the i-th photo.
Output
Print the minimal processing time of the division into groups.
Examples
Input
5 2
50 110 130 40 120
Output
20
Input
4 1
2 3 4 1
Output
0
Note
In the first example the photos should be split into 2 groups: [40, 50] and [110, 120, 130]. The processing time of the first group is 10, and the processing time of the second group is 20. Maximum among 10 and 20 is 20. It is impossible to split the photos into groups in a such way that the processing time of division is less than 20.
In the second example the photos should be split into four groups, each containing one photo. So the minimal possible processing time of a division is 0.
Submitted Solution:
```
def check(mid):
i = 0
c = 0
for j in range(n):
if v[j] - v[i] <= mid:
c += 1
else:
if c < k:
return False
c = 0
i = j
return True
def binSearch(a, b):
left, right = a - 1, b + 1
while right - left > 1:
mid = (left + right) // 2
if check(mid):
right = mid
else:
left = mid
return right
n, k = map(int, input().split())
v = sorted(list(map(int, input().split())))
if k == 1:
print(0)
else:
print(binSearch(0, 10 ** 9))
```
No
| 8,108 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Students went into a class to write a test and sat in some way. The teacher thought: "Probably they sat in this order to copy works of each other. I need to rearrange them in such a way that students that were neighbors are not neighbors in a new seating."
The class can be represented as a matrix with n rows and m columns with a student in each cell. Two students are neighbors if cells in which they sit have a common side.
Let's enumerate students from 1 to n·m in order of rows. So a student who initially sits in the cell in row i and column j has a number (i - 1)·m + j. You have to find a matrix with n rows and m columns in which all numbers from 1 to n·m appear exactly once and adjacent numbers in the original matrix are not adjacent in it, or determine that there is no such matrix.
Input
The only line contains two integers n and m (1 ≤ n, m ≤ 105; n·m ≤ 105) — the number of rows and the number of columns in the required matrix.
Output
If there is no such matrix, output "NO" (without quotes).
Otherwise in the first line output "YES" (without quotes), and in the next n lines output m integers which form the required matrix.
Examples
Input
2 4
Output
YES
5 4 7 2
3 6 1 8
Input
2 1
Output
NO
Note
In the first test case the matrix initially looks like this:
1 2 3 4
5 6 7 8
It's easy to see that there are no two students that are adjacent in both matrices.
In the second test case there are only two possible seatings and in both of them students with numbers 1 and 2 are neighbors.
Tags: brute force, constructive algorithms, math
Correct Solution:
```
import sys, itertools
#f = open('input', 'r')
f = sys.stdin
def near(i,n,m):
x = i//m
y = i%m
d = [[0, -1], [0, 1], [-1, 0], [1, 0]]
ns = []
for dx, dy in d:
nx=x+dx
ny=y+dy
if nx>=0 and nx<n and ny>=0 and ny<m:
ns.append(nx*m+ny)
return ns
def check(p, n, m):
d = [[0, -1], [0, 1], [-1, 0], [1, 0]]
for x in range(n):
for y in range(m):
ns = near(p[x*m+y],n,m)
for dx, dy in d:
nx=x+dx
ny=y+dy
if nx>=0 and nx<n and ny>=0 and ny<m and p[nx*m+ny] in ns:
return True
return False
n, m = map(int, f.readline().split())
reverse=False
if n>m:
t1 = list(range(n*m))
t2 = []
for i in range(m):
for j in range(n):
t2.append(t1[j*m+i])
t=n;n=m;m=t
reverse=True
def ans(n,m):
if m>=5:
p = []
for i in range(n):
t3 = []
for j in range(m):
if j*2+i%2 >= m:
break
t3.append(j*2+i%2)
for j in range(m-len(t3)):
if j*2+1-i%2 >= m:
break
t3.append(j*2+1-i%2)
p += [x+i*m for x in t3]
return p
if n==1 and m==1:
return [0]
if n==1 and m<=3:
return False
if n==2 and m<=3:
return False
if n==3 and m==4:
return [4,3,6,1,2,5,0,7,9,11,8,10]
if n==4:
return [4, 3, 6, 1, 2, 5, 0, 7, 12, 11, 14, 9, 15, 13, 11, 14]
for p in list(itertools.permutations(list(range(n*m)), n*m)):
failed = check(p,n,m)
if not failed:
return p
return True
p = ans(n,m)
if p:
print('YES')
if reverse:
for j in range(m):
print(' '.join(str(t2[p[i*m+j]]+1) for i in range(n)))
else:
for i in range(n):
print(' '.join(str(p[i*m+j]+1) for j in range(m)))
else:
print('NO')
```
| 8,109 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Students went into a class to write a test and sat in some way. The teacher thought: "Probably they sat in this order to copy works of each other. I need to rearrange them in such a way that students that were neighbors are not neighbors in a new seating."
The class can be represented as a matrix with n rows and m columns with a student in each cell. Two students are neighbors if cells in which they sit have a common side.
Let's enumerate students from 1 to n·m in order of rows. So a student who initially sits in the cell in row i and column j has a number (i - 1)·m + j. You have to find a matrix with n rows and m columns in which all numbers from 1 to n·m appear exactly once and adjacent numbers in the original matrix are not adjacent in it, or determine that there is no such matrix.
Input
The only line contains two integers n and m (1 ≤ n, m ≤ 105; n·m ≤ 105) — the number of rows and the number of columns in the required matrix.
Output
If there is no such matrix, output "NO" (without quotes).
Otherwise in the first line output "YES" (without quotes), and in the next n lines output m integers which form the required matrix.
Examples
Input
2 4
Output
YES
5 4 7 2
3 6 1 8
Input
2 1
Output
NO
Note
In the first test case the matrix initially looks like this:
1 2 3 4
5 6 7 8
It's easy to see that there are no two students that are adjacent in both matrices.
In the second test case there are only two possible seatings and in both of them students with numbers 1 and 2 are neighbors.
Tags: brute force, constructive algorithms, math
Correct Solution:
```
def transpos(a,n,m):
b = []
for i in range(m):
b.append([a[j][i] for j in range(n)])
return(b)
def printarr(a):
for i in range(len(a)):
for j in range(len(a[i])):
print(a[i][j], end = ' ')
print("")
n,m = [int(i) for i in input().split()]
a = []
for i in range(n):
a.append([i*m + j for j in range(1,m+1)])
#printarr(transpos(a,n,m))
transp_flag = False
if n > m:
tmp = m
m = n
n = tmp
a = transpos(a,m,n)
transp_flag = True
# m >= n
if m < 3 and m != 1:
print("NO")
elif m == 1:
print("YES")
print(1)
else:
if m == 3:
if n < 3: print("NO")
else:
print("YES")
printarr([[5,9,3],[7,2,4],[1,6,8]])
elif m == 4:
for i in range(n):
tmp = a[i][:]
if i%2 == 0:
a[i] = [tmp[1],tmp[3],tmp[0],tmp[2]]
else:
a[i] = [tmp[2],tmp[0],tmp[3],tmp[1]]
else:
for i in range(n):
if i%2 == 0:
tmp1 = [a[i][j] for j in range(m) if j%2 == 0]
tmp2 = [a[i][j] for j in range(m) if j%2 == 1]
if i%2 == 1:
tmp1 = [a[i][j] for j in range(m) if j%2 == 1]
tmp2 = [a[i][j] for j in range(m) if j%2 == 0]
a[i] = tmp1 + tmp2
if m > 3:
if transp_flag: a = transpos(a,n,m)
print("YES")
printarr(a)
```
| 8,110 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Students went into a class to write a test and sat in some way. The teacher thought: "Probably they sat in this order to copy works of each other. I need to rearrange them in such a way that students that were neighbors are not neighbors in a new seating."
The class can be represented as a matrix with n rows and m columns with a student in each cell. Two students are neighbors if cells in which they sit have a common side.
Let's enumerate students from 1 to n·m in order of rows. So a student who initially sits in the cell in row i and column j has a number (i - 1)·m + j. You have to find a matrix with n rows and m columns in which all numbers from 1 to n·m appear exactly once and adjacent numbers in the original matrix are not adjacent in it, or determine that there is no such matrix.
Input
The only line contains two integers n and m (1 ≤ n, m ≤ 105; n·m ≤ 105) — the number of rows and the number of columns in the required matrix.
Output
If there is no such matrix, output "NO" (without quotes).
Otherwise in the first line output "YES" (without quotes), and in the next n lines output m integers which form the required matrix.
Examples
Input
2 4
Output
YES
5 4 7 2
3 6 1 8
Input
2 1
Output
NO
Note
In the first test case the matrix initially looks like this:
1 2 3 4
5 6 7 8
It's easy to see that there are no two students that are adjacent in both matrices.
In the second test case there are only two possible seatings and in both of them students with numbers 1 and 2 are neighbors.
Tags: brute force, constructive algorithms, math
Correct Solution:
```
def get_answer(m, n):
if (m, n) in [(1, 2), (2, 1), (1, 3), (3, 1), (2, 2), (2, 3), (3, 2)]:
return ("NO", [])
elif (n == 1):
mat = [[i] for i in range(2, m+1, 2)] + [[i] for i in range(1, m+1, 2)]
return ("YES", mat)
elif n == 2:
bs = [[2, 3], [7, 6], [4, 1], [8, 5]]
mat = []
for i in range(m//4):
for u in bs:
if i % 2 == 0: # like bs
mat.append([x + 8*i for x in u])
else:
'''
2 3
7 6
4 1
8 5
11 10 (10 11 is invalid -> flip figure)
14 15
9 12
13 16
'''
mat.append([x + 8*i for x in reversed(u)])
if m % 4 == 1:
'''
2 3 m*n 3
7 6 2 6
4 1 -> 7 1
8 5 4 5
(11 10) 8 m*n-1
(...) (11 10)
(...)
'''
mat.insert(4, [0, 0])
for i in range(4, 0, -1):
mat[i][0] = mat[i-1][0]
mat[0][0] = m*n
mat[4][1] = m*n-1
elif m % 4 == 2:
if (m//4) % 2 == 1:
'''
9 12
2 3 2 3
... -> ...
8 5 8 5
11 10
'''
mat = [[m*n-3, m*n]] + mat + [[m*n-1, m*n-2]]
else:
'''
17 20
2 3 2 3
... -> ...
13 16 13 16
18 19
'''
mat = [[m*n-3, m*n]] + mat + [[m*n-2, m*n-1]]
elif m % 4 == 3:
'''
13 12
2 3 10 3
7 6 2 6
4 1 7 1
8 5 -> 4 5
8 9
11 14
'''
mat.insert(4, [0, 0])
for i in range(4, 0, -1):
mat[i][0] = mat[i-1][0]
mat[0][0] = m*n-4
mat[4][1] = m*n-5
mat = [[m*n-1, m*n-2]] + mat + [[m*n-3, m*n]]
return ("YES", mat)
elif n == 3:
bs = [[6, 1, 8], [7, 5, 3], [2, 9, 4]]
mat = []
for i in range(m//3):
for u in bs:
mat.append([x + 9*i for x in u])
if m % 3 == 1:
'''
11 1 12
6 1 8 6 10 8
7 5 3 -> 7 5 3
2 9 4 2 9 4
'''
mat = [[m*n-1, m*n-2, m*n]] + mat
mat[0][1], mat[1][1] = mat[1][1], mat[0][1]
elif m % 3 == 2:
'''
11 1 12
6 1 8 6 10 8
7 5 3 -> 7 5 3
2 9 4 2 13 4
14 9 15
'''
mat = [[m*n-4, m*n-5, m*n-3]] + mat + [[m*n-1, m*n-2, m*n]]
mat[0][1], mat[1][1] = mat[1][1], mat[0][1]
mat[m-2][1], mat[m-1][1] = mat[m-1][1], mat[m-2][1]
return ("YES", mat)
mat = []
for i in range(m):
if i % 2 == 0:
mat.append([i*n+j for j in range(2, n+1, 2)] + [i*n+j for j in range(1, n+1, 2)])
else:
if n != 4:
mat.append([i*n+j for j in range(1, n+1, 2)] + [i*n+j for j in range(2, n+1, 2)])
else:
mat.append([i*n+j for j in range(n-(n%2==0), 0, -2)] + [i*n+j for j in range(n-(n%2==1), 0, -2)])
return ("YES", mat)
m, n = input().split()
m = int(m)
n = int(n)
res = get_answer(m, n)
print(res[0])
# print(m, n)
if res[0] == "YES":
for i in range(m):
for j in range(n):
print(res[1][i][j], end=' ')
print()
```
| 8,111 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Students went into a class to write a test and sat in some way. The teacher thought: "Probably they sat in this order to copy works of each other. I need to rearrange them in such a way that students that were neighbors are not neighbors in a new seating."
The class can be represented as a matrix with n rows and m columns with a student in each cell. Two students are neighbors if cells in which they sit have a common side.
Let's enumerate students from 1 to n·m in order of rows. So a student who initially sits in the cell in row i and column j has a number (i - 1)·m + j. You have to find a matrix with n rows and m columns in which all numbers from 1 to n·m appear exactly once and adjacent numbers in the original matrix are not adjacent in it, or determine that there is no such matrix.
Input
The only line contains two integers n and m (1 ≤ n, m ≤ 105; n·m ≤ 105) — the number of rows and the number of columns in the required matrix.
Output
If there is no such matrix, output "NO" (without quotes).
Otherwise in the first line output "YES" (without quotes), and in the next n lines output m integers which form the required matrix.
Examples
Input
2 4
Output
YES
5 4 7 2
3 6 1 8
Input
2 1
Output
NO
Note
In the first test case the matrix initially looks like this:
1 2 3 4
5 6 7 8
It's easy to see that there are no two students that are adjacent in both matrices.
In the second test case there are only two possible seatings and in both of them students with numbers 1 and 2 are neighbors.
Tags: brute force, constructive algorithms, math
Correct Solution:
```
def get_answer(m, n):
if (m, n) in [(1, 2), (2, 1), (1, 3), (3, 1), (2, 2), (2, 3), (3, 2)]:
return ("NO", [])
elif (m == 1):
mat = [[i for i in range(2, n+1, 2)] + [i for i in range(1, n+1, 2)]]
return ("YES", mat)
elif (n == 1):
mat = [[i] for i in range(2, m+1, 2)] + [[i] for i in range(1, m+1, 2)]
return ("YES", mat)
elif n == 2:
bs = [[2, 3], [7, 6], [4, 1], [8, 5]]
mat = []
for i in range(m//4):
for u in bs:
if i % 2 == 0: # like bs
mat.append([x + 8*i for x in u])
else:
'''
2 3
7 6
4 1
8 5
11 10 (10 11 is invalid -> flip figure)
14 15
9 12
13 16
'''
mat.append([x + 8*i for x in reversed(u)])
if m % 4 == 1:
'''
2 3 m*n 3
7 6 2 6
4 1 -> 7 1
8 5 4 5
(11 10) 8 m*n-1
(...) (11 10)
(...)
'''
mat.insert(4, [0, 0])
for i in range(4, 0, -1):
mat[i][0] = mat[i-1][0]
mat[0][0] = m*n
mat[4][1] = m*n-1
elif m % 4 == 2:
if (m//4) % 2 == 1:
'''
9 12
2 3 2 3
... -> ...
8 5 8 5
11 10
'''
mat = [[m*n-3, m*n]] + mat + [[m*n-1, m*n-2]]
else:
'''
17 20
2 3 2 3
... -> ...
13 16 13 16
18 19
'''
mat = [[m*n-3, m*n]] + mat + [[m*n-2, m*n-1]]
elif m % 4 == 3:
'''
13 12
2 3 10 3
7 6 2 6
4 1 7 1
8 5 -> 4 5
8 9
11 14
'''
mat.insert(4, [0, 0])
for i in range(4, 0, -1):
mat[i][0] = mat[i-1][0]
mat[0][0] = m*n-4
mat[4][1] = m*n-5
mat = [[m*n-1, m*n-2]] + mat + [[m*n-3, m*n]]
return ("YES", mat)
elif n == 3:
bs = [[6, 1, 8], [7, 5, 3], [2, 9, 4]]
mat = []
for i in range(m//3):
for u in bs:
mat.append([x + 9*i for x in u])
if m % 3 == 1:
'''
11 1 12
6 1 8 6 10 8
7 5 3 -> 7 5 3
2 9 4 2 9 4
'''
mat = [[m*n-1, m*n-2, m*n]] + mat
mat[0][1], mat[1][1] = mat[1][1], mat[0][1]
elif m % 3 == 2:
'''
11 1 12
6 1 8 6 10 8
7 5 3 -> 7 5 3
2 9 4 2 13 4
14 9 15
'''
mat = [[m*n-4, m*n-5, m*n-3]] + mat + [[m*n-1, m*n-2, m*n]]
mat[0][1], mat[1][1] = mat[1][1], mat[0][1]
mat[m-2][1], mat[m-1][1] = mat[m-1][1], mat[m-2][1]
return ("YES", mat)
mat = []
for i in range(m):
if i % 2 == 0:
mat.append([i*n+j for j in range(2, n+1, 2)] + [i*n+j for j in range(1, n+1, 2)])
else:
if n != 4:
mat.append([i*n+j for j in range(1, n+1, 2)] + [i*n+j for j in range(2, n+1, 2)])
else:
mat.append([i*n+j for j in range(n-(n%2==0), 0, -2)] + [i*n+j for j in range(n-(n%2==1), 0, -2)])
return ("YES", mat)
m, n = input().split()
m = int(m)
n = int(n)
res = get_answer(m, n)
print(res[0])
# print(m, n)
if res[0] == "YES":
for i in range(m):
for j in range(n):
print(res[1][i][j], end=' ')
print()
```
| 8,112 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Students went into a class to write a test and sat in some way. The teacher thought: "Probably they sat in this order to copy works of each other. I need to rearrange them in such a way that students that were neighbors are not neighbors in a new seating."
The class can be represented as a matrix with n rows and m columns with a student in each cell. Two students are neighbors if cells in which they sit have a common side.
Let's enumerate students from 1 to n·m in order of rows. So a student who initially sits in the cell in row i and column j has a number (i - 1)·m + j. You have to find a matrix with n rows and m columns in which all numbers from 1 to n·m appear exactly once and adjacent numbers in the original matrix are not adjacent in it, or determine that there is no such matrix.
Input
The only line contains two integers n and m (1 ≤ n, m ≤ 105; n·m ≤ 105) — the number of rows and the number of columns in the required matrix.
Output
If there is no such matrix, output "NO" (without quotes).
Otherwise in the first line output "YES" (without quotes), and in the next n lines output m integers which form the required matrix.
Examples
Input
2 4
Output
YES
5 4 7 2
3 6 1 8
Input
2 1
Output
NO
Note
In the first test case the matrix initially looks like this:
1 2 3 4
5 6 7 8
It's easy to see that there are no two students that are adjacent in both matrices.
In the second test case there are only two possible seatings and in both of them students with numbers 1 and 2 are neighbors.
Tags: brute force, constructive algorithms, math
Correct Solution:
```
n,m=map(int,input().strip().split(' '))
arr=[]
cnt=1
if(n*m==1):
print("YES")
print(1)
elif((n==1 and(m==2 or m==3)) or ((n==2) and (m==1 or m==2 or m==3)) or ((n==3) and (m==1 or m==2 )) ):
print("NO")
elif(n==3 and m==3):
print("YES")
print(6,1,8)
print(7,5,3)
print(2,9,4)
else:
print("YES")
if(m>=n):
for i in range(n):
l=[]
for j in range(m):
l.append(cnt)
cnt+=1
arr.append(l)
ans=[]
for i in range(n):
l=arr[i]
odd=[]
even=[]
for j in range(m):
if((j+1)%2==0):
even.append(l[j])
else:
odd.append(l[j])
if(((i+1)%2)==1):
if(n%2==1 and m%2==1):
odd.extend(even)
ans.append(odd)
elif(m%2==1 and n%2==0):
odd.extend(even)
ans.append(odd)
else:
even.extend(odd)
ans.append(even)
else:
if(n%2==1 and m%2==1):
even.extend(odd)
ans.append(even)
elif(m%2==1 and n%2==0):
even.extend(odd)
ans.append(even)
else:
even.reverse()
odd.reverse()
odd.extend(even)
ans.append(odd)
for i in range(n):
for j in range(m):
print(ans[i][j],end=' ')
print()
else:
temp=n
n=m
m=temp
cnt=1
for i in range(n):
l=[]
p=cnt
for j in range(m):
l.append(p)
p+=n
cnt+=1
arr.append(l)
ans=[]
for i in range(n):
l=arr[i]
odd=[]
even=[]
for j in range(m):
if((j+1)%2==0):
even.append(l[j])
else:
odd.append(l[j])
if(((i+1)%2)==1):
if(n%2==1 and m%2==1):
odd.extend(even)
ans.append(odd)
elif(m%2==1 and n%2==0):
odd.extend(even)
ans.append(odd)
else:
even.extend(odd)
ans.append(even)
else:
if(n%2==1 and m%2==1):
even.extend(odd)
ans.append(even)
elif(m%2==1 and n%2==0):
even.extend(odd)
ans.append(even)
else:
even.reverse()
odd.reverse()
odd.extend(even)
ans.append(odd)
for i in range(m):
for j in range(n):
print(ans[j][i],end=' ')
print()
```
| 8,113 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Students went into a class to write a test and sat in some way. The teacher thought: "Probably they sat in this order to copy works of each other. I need to rearrange them in such a way that students that were neighbors are not neighbors in a new seating."
The class can be represented as a matrix with n rows and m columns with a student in each cell. Two students are neighbors if cells in which they sit have a common side.
Let's enumerate students from 1 to n·m in order of rows. So a student who initially sits in the cell in row i and column j has a number (i - 1)·m + j. You have to find a matrix with n rows and m columns in which all numbers from 1 to n·m appear exactly once and adjacent numbers in the original matrix are not adjacent in it, or determine that there is no such matrix.
Input
The only line contains two integers n and m (1 ≤ n, m ≤ 105; n·m ≤ 105) — the number of rows and the number of columns in the required matrix.
Output
If there is no such matrix, output "NO" (without quotes).
Otherwise in the first line output "YES" (without quotes), and in the next n lines output m integers which form the required matrix.
Examples
Input
2 4
Output
YES
5 4 7 2
3 6 1 8
Input
2 1
Output
NO
Note
In the first test case the matrix initially looks like this:
1 2 3 4
5 6 7 8
It's easy to see that there are no two students that are adjacent in both matrices.
In the second test case there are only two possible seatings and in both of them students with numbers 1 and 2 are neighbors.
Tags: brute force, constructive algorithms, math
Correct Solution:
```
def get_answer(m, n):
if (m, n) in [(1, 2), (2, 1), (1, 3), (3, 1), (2, 2), (2, 3), (3, 2)]:
return ("NO", [])
elif (m == 1):
mat = [[i for i in range(2, n+1, 2)] + [i for i in range(1, n+1, 2)]]
return ("YES", mat)
elif (n == 1):
mat = [[i] for i in range(2, m+1, 2)] + [[i] for i in range(1, m+1, 2)]
return ("YES", mat)
elif n == 2:
bs = [[2, 3], [7, 6], [4, 1], [8, 5]]
mat = []
for i in range(m//4):
for u in bs:
if i % 2 == 0:
mat.append([x + 8*i for x in u])
else:
mat.append([x + 8*i for x in reversed(u)])
if m % 4 == 1:
mat.insert(4, [0, 0])
for i in range(4, 0, -1):
mat[i][0] = mat[i-1][0]
mat[0][0] = m*n
mat[4][1] = m*n-1
elif m % 4 == 2:
if (m//4) % 2 == 1:
mat = [[m*n-3, m*n]] + mat + [[m*n-1, m*n-2]]
else:
mat = [[m*n-3, m*n]] + mat + [[m*n-2, m*n-1]]
elif m % 4 == 3:
mat.insert(4, [0, 0])
for i in range(4, 0, -1):
mat[i][0] = mat[i-1][0]
mat[0][0] = m*n-4
mat[4][1] = m*n-5
mat = [[m*n-1, m*n-2]] + mat + [[m*n-3, m*n]]
return ("YES", mat)
elif n == 3:
bs = [[6, 1, 8], [7, 5, 3], [2, 9, 4]]
mat = []
for i in range(m//3):
for u in bs:
mat.append([x + 9*i for x in u])
if m % 3 == 1:
mat = [[m*n-1, m*n-2, m*n]] + mat
mat[0][1], mat[1][1] = mat[1][1], mat[0][1]
elif m % 3 == 2:
mat = [[m*n-4, m*n-5, m*n-3]] + mat + [[m*n-1, m*n-2, m*n]]
mat[0][1], mat[1][1] = mat[1][1], mat[0][1]
mat[m-2][1], mat[m-1][1] = mat[m-1][1], mat[m-2][1]
return ("YES", mat)
mat = []
for i in range(m):
if i % 2 == 0:
mat.append([i*n+j for j in range(2, n+1, 2)] + [i*n+j for j in range(1, n+1, 2)])
else:
if n != 4:
mat.append([i*n+j for j in range(1, n+1, 2)] + [i*n+j for j in range(2, n+1, 2)])
else:
mat.append([i*n+j for j in range(n-(n%2==0), 0, -2)] + [i*n+j for j in range(n-(n%2==1), 0, -2)])
return ("YES", mat)
m, n = input().split()
m = int(m)
n = int(n)
res = get_answer(m, n)
print(res[0])
# print(m, n)
if res[0] == "YES":
for i in range(m):
for j in range(n):
print(res[1][i][j], end=' ')
print()
```
| 8,114 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Students went into a class to write a test and sat in some way. The teacher thought: "Probably they sat in this order to copy works of each other. I need to rearrange them in such a way that students that were neighbors are not neighbors in a new seating."
The class can be represented as a matrix with n rows and m columns with a student in each cell. Two students are neighbors if cells in which they sit have a common side.
Let's enumerate students from 1 to n·m in order of rows. So a student who initially sits in the cell in row i and column j has a number (i - 1)·m + j. You have to find a matrix with n rows and m columns in which all numbers from 1 to n·m appear exactly once and adjacent numbers in the original matrix are not adjacent in it, or determine that there is no such matrix.
Input
The only line contains two integers n and m (1 ≤ n, m ≤ 105; n·m ≤ 105) — the number of rows and the number of columns in the required matrix.
Output
If there is no such matrix, output "NO" (without quotes).
Otherwise in the first line output "YES" (without quotes), and in the next n lines output m integers which form the required matrix.
Examples
Input
2 4
Output
YES
5 4 7 2
3 6 1 8
Input
2 1
Output
NO
Note
In the first test case the matrix initially looks like this:
1 2 3 4
5 6 7 8
It's easy to see that there are no two students that are adjacent in both matrices.
In the second test case there are only two possible seatings and in both of them students with numbers 1 and 2 are neighbors.
Tags: brute force, constructive algorithms, math
Correct Solution:
```
import bisect
def list_output(s):
print(' '.join(map(str, s)))
def list_input(s='int'):
if s == 'int':
return list(map(int, input().split()))
elif s == 'float':
return list(map(float, input().split()))
return list(map(str, input().split()))
n, m = map(int, input().split())
swapped = False
if n > m:
n, m = m, n
swapped = True
def check(M):
for i in range(n):
for j in range(m):
if i-1 >= 0 and M[i-1][j] + m == M[i][j]:
return False
if i+1 < n and M[i+1][j] == M[i][j] + m:
return False
if j-1 >= 0 and M[i][j-1] + 1 == M[i][j]:
return False
if j+1 < m and M[i][j+1] == M[i][j] + 1:
return False
return True
def transpose(M):
n = len(M)
m = len(M[0])
R = [[0 for i in range(n)] for j in range(m)]
for i in range(n):
for j in range(m):
R[j][i] = M[i][j]
return R
if n == 1 and m == 1:
print('YES')
print('1')
exit(0)
if n <= 2 and m <= 3:
print('NO')
exit(0)
R = list()
if n == 3 and m == 3:
R.append([4, 3, 8])
R.append([9, 1, 6])
R.append([5, 7, 2])
elif m == 4:
if n == 1:
R.append([3, 1, 4, 2])
elif n == 2:
R.append([5, 4, 7, 2])
R.append([3, 6, 1, 8])
elif n == 3:
R.append([5, 4, 7, 2])
R.append([3, 6, 1, 8])
R.append([11, 9, 12, 10])
elif n == 4:
R.append([5, 4, 7, 2])
R.append([3, 6, 1, 8])
R.append([11, 9, 12, 10])
R.append([14, 16, 15, 13])
else:
M = [[(i-1) * m + j for j in range(1, m+1)] for i in range(1, n+1)]
for i in range(n):
row = list()
if i%2 == 0:
for j in range(0, m, 2):
row.append(M[i][j])
for j in range(1, m, 2):
row.append(M[i][j])
else:
for j in range(1, m, 2):
row.append(M[i][j])
for j in range(0, m, 2):
row.append(M[i][j])
R.append(row)
if swapped:
M = [[(i-1) * n + j for j in range(1, n+1)] for i in range(1, m+1)]
M = transpose(M)
S = [[0 for j in range(m)] for i in range(n)]
for i in range(n):
for j in range(m):
r = (R[i][j]-1) // m
c = (R[i][j]-1) % m
S[i][j] = M[r][c]
R = transpose(S)
n, m = m, n
#print(check(R))
print('YES')
for i in range(n):
print(' '.join(map(str, R[i])))
```
| 8,115 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Students went into a class to write a test and sat in some way. The teacher thought: "Probably they sat in this order to copy works of each other. I need to rearrange them in such a way that students that were neighbors are not neighbors in a new seating."
The class can be represented as a matrix with n rows and m columns with a student in each cell. Two students are neighbors if cells in which they sit have a common side.
Let's enumerate students from 1 to n·m in order of rows. So a student who initially sits in the cell in row i and column j has a number (i - 1)·m + j. You have to find a matrix with n rows and m columns in which all numbers from 1 to n·m appear exactly once and adjacent numbers in the original matrix are not adjacent in it, or determine that there is no such matrix.
Input
The only line contains two integers n and m (1 ≤ n, m ≤ 105; n·m ≤ 105) — the number of rows and the number of columns in the required matrix.
Output
If there is no such matrix, output "NO" (without quotes).
Otherwise in the first line output "YES" (without quotes), and in the next n lines output m integers which form the required matrix.
Examples
Input
2 4
Output
YES
5 4 7 2
3 6 1 8
Input
2 1
Output
NO
Note
In the first test case the matrix initially looks like this:
1 2 3 4
5 6 7 8
It's easy to see that there are no two students that are adjacent in both matrices.
In the second test case there are only two possible seatings and in both of them students with numbers 1 and 2 are neighbors.
Submitted Solution:
```
def get_answer(m, n):
if (m, n) in [(1, 2), (2, 1), (1, 3), (3, 1), (2, 2), (2, 3), (3, 2)]:
return ("NO", [])
elif m == n == 1:
return ("YES", [[1]])
elif (m == 1):
mat = [[i for i in range(2, n+1, 2)] + [i for i in range(1, n+1, 2)]]
# print(mat)
return ("YES", mat)
elif (n == 1):
mat = [[i] for i in range(2, m+1, 2)] + [[i] for i in range(1, m+1, 2)]
# print(mat)
return ("YES", mat)
elif n == 2:
'''
s = get_answer(2, max(m, n))
res = []
for i in range(m):
res.append([0] * n)
for j in range(n):
res[i][j] = s[1][j][i]
return ("YES", res)
'''
return ("NO", [])
mat = []
for i in range(m):
# mat.append([])
# for j in range(n):
# mat[i].append(i*n+j+1)
if i % 2 == 0:
# mat.append([i*n+j for j in range(n-(n%2==0), 0, -2)] + [i*n+j for j in range(n-(n%2==1), 0, -2)])
mat.append([i*n+j for j in range(2, n+1, 2)] + [i*n+j for j in range(1, n+1, 2)])
else:
if n != 4:
mat.append([i*n+j for j in range(1, n+1, 2)] + [i*n+j for j in range(2, n+1, 2)])
else:
mat.append([i*n+j for j in range(n-(n%2==0), 0, -2)] + [i*n+j for j in range(n-(n%2==1), 0, -2)])
return ("YES", mat)
m, n = input().split()
m = int(m)
n = int(n)
# res = get_answer(min(m, n), max(m, n))
res = get_answer(m, n)
# print(res[0])
print(m, n)
if res[0] == "YES":
# if m <= n:
if 1 == 1:
for i in range(m):
for j in range(n):
print(res[1][i][j], end=' ')
print()
else:
for i in range(m):
for j in range(n):
print(res[1][j][i], end=' ')
print()
```
No
| 8,116 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Students went into a class to write a test and sat in some way. The teacher thought: "Probably they sat in this order to copy works of each other. I need to rearrange them in such a way that students that were neighbors are not neighbors in a new seating."
The class can be represented as a matrix with n rows and m columns with a student in each cell. Two students are neighbors if cells in which they sit have a common side.
Let's enumerate students from 1 to n·m in order of rows. So a student who initially sits in the cell in row i and column j has a number (i - 1)·m + j. You have to find a matrix with n rows and m columns in which all numbers from 1 to n·m appear exactly once and adjacent numbers in the original matrix are not adjacent in it, or determine that there is no such matrix.
Input
The only line contains two integers n and m (1 ≤ n, m ≤ 105; n·m ≤ 105) — the number of rows and the number of columns in the required matrix.
Output
If there is no such matrix, output "NO" (without quotes).
Otherwise in the first line output "YES" (without quotes), and in the next n lines output m integers which form the required matrix.
Examples
Input
2 4
Output
YES
5 4 7 2
3 6 1 8
Input
2 1
Output
NO
Note
In the first test case the matrix initially looks like this:
1 2 3 4
5 6 7 8
It's easy to see that there are no two students that are adjacent in both matrices.
In the second test case there are only two possible seatings and in both of them students with numbers 1 and 2 are neighbors.
Submitted Solution:
```
n,m=map(int,input().strip().split(' '))
arr=[]
cnt=1
if(n*m==1):
print("YES")
print(1)
elif((n==1 and(m==2 or m==3)) or ((n==2) and (m==1 or m==2 or m==3)) or ((n==3) and (m==1 or m==2 )) ):
print("NO")
elif(n==3 and m==3):
print("YES")
print(6,1,8)
print(7,5,3)
print(2,9,4)
else:
print("YES")
if(m>=n):
for i in range(n):
l=[]
for j in range(m):
l.append(cnt)
cnt+=1
arr.append(l)
ans=[]
for i in range(n):
l=arr[i]
odd=[]
even=[]
for j in range(m):
if((j+1)%2==0):
even.append(l[j])
else:
odd.append(l[j])
if(((i+1)%2)==1):
if(n%2==1 and m%2==1):
odd.extend(even)
ans.append(odd)
else:
even.extend(odd)
ans.append(even)
else:
if(n%2==1 and m%2==1):
even.extend(odd)
ans.append(even)
else:
even.reverse()
odd.reverse()
odd.extend(even)
ans.append(odd)
for i in range(n):
for j in range(m):
print(ans[i][j],end=' ')
print()
else:
temp=n
n=m
m=temp
cnt=1
for i in range(n):
l=[]
p=cnt
for j in range(m):
l.append(p)
p+=n
cnt+=1
arr.append(l)
ans=[]
for i in range(n):
l=arr[i]
odd=[]
even=[]
for j in range(m):
if((j+1)%2==0):
even.append(l[j])
else:
odd.append(l[j])
if(((i+1)%2)==1):
even.extend(odd)
ans.append(even)
else:
even.reverse()
odd.reverse()
odd.extend(even)
ans.append(odd)
for i in range(m):
for j in range(n):
print(ans[j][i],end=' ')
print()
```
No
| 8,117 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Students went into a class to write a test and sat in some way. The teacher thought: "Probably they sat in this order to copy works of each other. I need to rearrange them in such a way that students that were neighbors are not neighbors in a new seating."
The class can be represented as a matrix with n rows and m columns with a student in each cell. Two students are neighbors if cells in which they sit have a common side.
Let's enumerate students from 1 to n·m in order of rows. So a student who initially sits in the cell in row i and column j has a number (i - 1)·m + j. You have to find a matrix with n rows and m columns in which all numbers from 1 to n·m appear exactly once and adjacent numbers in the original matrix are not adjacent in it, or determine that there is no such matrix.
Input
The only line contains two integers n and m (1 ≤ n, m ≤ 105; n·m ≤ 105) — the number of rows and the number of columns in the required matrix.
Output
If there is no such matrix, output "NO" (without quotes).
Otherwise in the first line output "YES" (without quotes), and in the next n lines output m integers which form the required matrix.
Examples
Input
2 4
Output
YES
5 4 7 2
3 6 1 8
Input
2 1
Output
NO
Note
In the first test case the matrix initially looks like this:
1 2 3 4
5 6 7 8
It's easy to see that there are no two students that are adjacent in both matrices.
In the second test case there are only two possible seatings and in both of them students with numbers 1 and 2 are neighbors.
Submitted Solution:
```
def get_answer(m, n):
if (m, n) in [(1, 2), (2, 1), (1, 3), (3, 1)]:
return ("NO", [])
elif m == n == 1:
return ("YES", [[1]])
elif (m == 1):
mat = [[i for i in range(2, n+1, 2)] + [i for i in range(1, n+1, 2)]]
# print(mat)
return ("YES", mat)
elif (n == 1):
mat = [[i] for i in range(2, m+1, 2)] + [[i] for i in range(1, m+1, 2)]
# print(mat)
return ("YES", mat)
mat = []
for i in range(m):
mat.append([])
for j in range(n):
mat[i].append(i*n+j+1)
_mat = [[]] * m
lst = 0
for i in range(0, m, 2):
_mat[i] = list(mat[i//2])
lst = i//2
# print(lst)
for i in range(1, m, 2):
_mat[i] = list(mat[lst+(i+1)//2])
mat = list(_mat)
# return ("YES", mat)
for i in range(m):
mat[i] = mat[i][n-i%n:] + mat[i][:n-i%n]
# return ("YES", mat)
for j in range(n):
col = []
for i in range(m):
col.append(mat[i][j])
col = col[m-j%m:] + col[:m-j%m]
for i in range(m):
mat[i][j] = col[i]
return ("YES", mat)
m, n = input().split()
m = int(m)
n = int(n)
res = get_answer(m, n)
print(res[0])
if res[0] == "YES":
for i in range(m):
for j in range(n):
print(res[1][i][j], end=' ')
print()
```
No
| 8,118 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Students went into a class to write a test and sat in some way. The teacher thought: "Probably they sat in this order to copy works of each other. I need to rearrange them in such a way that students that were neighbors are not neighbors in a new seating."
The class can be represented as a matrix with n rows and m columns with a student in each cell. Two students are neighbors if cells in which they sit have a common side.
Let's enumerate students from 1 to n·m in order of rows. So a student who initially sits in the cell in row i and column j has a number (i - 1)·m + j. You have to find a matrix with n rows and m columns in which all numbers from 1 to n·m appear exactly once and adjacent numbers in the original matrix are not adjacent in it, or determine that there is no such matrix.
Input
The only line contains two integers n and m (1 ≤ n, m ≤ 105; n·m ≤ 105) — the number of rows and the number of columns in the required matrix.
Output
If there is no such matrix, output "NO" (without quotes).
Otherwise in the first line output "YES" (without quotes), and in the next n lines output m integers which form the required matrix.
Examples
Input
2 4
Output
YES
5 4 7 2
3 6 1 8
Input
2 1
Output
NO
Note
In the first test case the matrix initially looks like this:
1 2 3 4
5 6 7 8
It's easy to see that there are no two students that are adjacent in both matrices.
In the second test case there are only two possible seatings and in both of them students with numbers 1 and 2 are neighbors.
Submitted Solution:
```
n,m=map(int,input().strip().split(' '))
arr=[]
cnt=1
if(n*m==1):
print("YES")
print(1)
elif((n==1 and(m==2 or m==3)) or ((n==2) and (m==1 or m==2 or m==3)) or ((n==3) and (m==1 or m==2 or m==3)) ):
print("NO")
else:
print("YES")
if(m>=n):
for i in range(n):
l=[]
for j in range(m):
l.append(cnt)
cnt+=1
arr.append(l)
ans=[]
for i in range(n):
l=arr[i]
odd=[]
even=[]
for j in range(m):
if((j+1)%2==0):
even.append(l[j])
else:
odd.append(l[j])
if(((i+1)%2)==1):
even.extend(odd)
ans.append(even)
else:
even.reverse()
odd.reverse()
odd.extend(even)
ans.append(odd)
for i in range(n):
for j in range(m):
print(ans[i][j],end=' ')
print()
else:
temp=n
n=m
m=temp
cnt=1
for i in range(n):
l=[]
p=cnt
for j in range(m):
l.append(p)
p+=n
cnt+=1
arr.append(l)
ans=[]
for i in range(n):
l=arr[i]
odd=[]
even=[]
for j in range(m):
if((j+1)%2==0):
even.append(l[j])
else:
odd.append(l[j])
if(((i+1)%2)==1):
even.extend(odd)
ans.append(even)
else:
even.reverse()
odd.reverse()
odd.extend(even)
ans.append(odd)
for i in range(m):
for j in range(n):
print(ans[j][i],end=' ')
print()
```
No
| 8,119 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When registering in a social network, users are allowed to create their own convenient login to make it easier to share contacts, print it on business cards, etc.
Login is an arbitrary sequence of lower and uppercase latin letters, digits and underline symbols («_»). However, in order to decrease the number of frauds and user-inattention related issues, it is prohibited to register a login if it is similar with an already existing login. More precisely, two logins s and t are considered similar if we can transform s to t via a sequence of operations of the following types:
* transform lowercase letters to uppercase and vice versa;
* change letter «O» (uppercase latin letter) to digit «0» and vice versa;
* change digit «1» (one) to any letter among «l» (lowercase latin «L»), «I» (uppercase latin «i») and vice versa, or change one of these letters to other.
For example, logins «Codeforces» and «codef0rces» as well as «OO0OOO00O0OOO0O00OOO0OO_lol» and «OO0OOO0O00OOO0O00OO0OOO_1oI» are considered similar whereas «Codeforces» and «Code_forces» are not.
You're given a list of existing logins with no two similar amonst and a newly created user login. Check whether this new login is similar with any of the existing ones.
Input
The first line contains a non-empty string s consisting of lower and uppercase latin letters, digits and underline symbols («_») with length not exceeding 50 — the login itself.
The second line contains a single integer n (1 ≤ n ≤ 1 000) — the number of existing logins.
The next n lines describe the existing logins, following the same constraints as the user login (refer to the first line of the input). It's guaranteed that no two existing logins are similar.
Output
Print «Yes» (without quotes), if user can register via this login, i.e. none of the existing logins is similar with it.
Otherwise print «No» (without quotes).
Examples
Input
1_wat
2
2_wat
wat_1
Output
Yes
Input
000
3
00
ooA
oOo
Output
No
Input
_i_
3
__i_
_1_
I
Output
No
Input
La0
3
2a0
La1
1a0
Output
No
Input
abc
1
aBc
Output
No
Input
0Lil
2
LIL0
0Ril
Output
Yes
Note
In the second sample case the user wants to create a login consisting of three zeros. It's impossible due to collision with the third among the existing.
In the third sample case the new login is similar with the second one.
Tags: *special, strings
Correct Solution:
```
s1 = input()
abc = 'qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM'
for y in range(0, 26):
s1 = s1.replace(abc[y], abc[y + 26])
s1 = s1.replace("O", "0")
s1 = s1.replace("L", "1")
s1 = s1.replace("I", "1")
n=int(input())
d=[]
d.append(s1)
for i in range(0,n):
s=input()
for y in range(0,26):
s = s.replace(abc[y],abc[y+26])
s = s.replace("O", "0")
s = s.replace("L","1")
s = s.replace("I","1")
if not s in d:
d.append(s)
if len(d) != n + 1:
print('No')
else:
print('Yes')
```
| 8,120 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When registering in a social network, users are allowed to create their own convenient login to make it easier to share contacts, print it on business cards, etc.
Login is an arbitrary sequence of lower and uppercase latin letters, digits and underline symbols («_»). However, in order to decrease the number of frauds and user-inattention related issues, it is prohibited to register a login if it is similar with an already existing login. More precisely, two logins s and t are considered similar if we can transform s to t via a sequence of operations of the following types:
* transform lowercase letters to uppercase and vice versa;
* change letter «O» (uppercase latin letter) to digit «0» and vice versa;
* change digit «1» (one) to any letter among «l» (lowercase latin «L»), «I» (uppercase latin «i») and vice versa, or change one of these letters to other.
For example, logins «Codeforces» and «codef0rces» as well as «OO0OOO00O0OOO0O00OOO0OO_lol» and «OO0OOO0O00OOO0O00OO0OOO_1oI» are considered similar whereas «Codeforces» and «Code_forces» are not.
You're given a list of existing logins with no two similar amonst and a newly created user login. Check whether this new login is similar with any of the existing ones.
Input
The first line contains a non-empty string s consisting of lower and uppercase latin letters, digits and underline symbols («_») with length not exceeding 50 — the login itself.
The second line contains a single integer n (1 ≤ n ≤ 1 000) — the number of existing logins.
The next n lines describe the existing logins, following the same constraints as the user login (refer to the first line of the input). It's guaranteed that no two existing logins are similar.
Output
Print «Yes» (without quotes), if user can register via this login, i.e. none of the existing logins is similar with it.
Otherwise print «No» (without quotes).
Examples
Input
1_wat
2
2_wat
wat_1
Output
Yes
Input
000
3
00
ooA
oOo
Output
No
Input
_i_
3
__i_
_1_
I
Output
No
Input
La0
3
2a0
La1
1a0
Output
No
Input
abc
1
aBc
Output
No
Input
0Lil
2
LIL0
0Ril
Output
Yes
Note
In the second sample case the user wants to create a login consisting of three zeros. It's impossible due to collision with the third among the existing.
In the third sample case the new login is similar with the second one.
Tags: *special, strings
Correct Solution:
```
def norm(s):
d = ord('A') - ord('a')
s11 = ''
for i in range(len(s)):
if ord('a') <= ord(s[i]) <= ord('z'):
s11 += chr(ord(s[i]) + d)
else:
s11 += s[i]
s = s11
s = s.replace('O', '0')
s = s.replace('L', '1')
s = s.replace('I', '1')
return s
s = norm(input())
n = int(input())
ok = True
for i in range(n):
s1 = input()
if norm(s1) == s:
ok = False
break
if ok:
print('Yes')
else:
print('No')
```
| 8,121 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When registering in a social network, users are allowed to create their own convenient login to make it easier to share contacts, print it on business cards, etc.
Login is an arbitrary sequence of lower and uppercase latin letters, digits and underline symbols («_»). However, in order to decrease the number of frauds and user-inattention related issues, it is prohibited to register a login if it is similar with an already existing login. More precisely, two logins s and t are considered similar if we can transform s to t via a sequence of operations of the following types:
* transform lowercase letters to uppercase and vice versa;
* change letter «O» (uppercase latin letter) to digit «0» and vice versa;
* change digit «1» (one) to any letter among «l» (lowercase latin «L»), «I» (uppercase latin «i») and vice versa, or change one of these letters to other.
For example, logins «Codeforces» and «codef0rces» as well as «OO0OOO00O0OOO0O00OOO0OO_lol» and «OO0OOO0O00OOO0O00OO0OOO_1oI» are considered similar whereas «Codeforces» and «Code_forces» are not.
You're given a list of existing logins with no two similar amonst and a newly created user login. Check whether this new login is similar with any of the existing ones.
Input
The first line contains a non-empty string s consisting of lower and uppercase latin letters, digits and underline symbols («_») with length not exceeding 50 — the login itself.
The second line contains a single integer n (1 ≤ n ≤ 1 000) — the number of existing logins.
The next n lines describe the existing logins, following the same constraints as the user login (refer to the first line of the input). It's guaranteed that no two existing logins are similar.
Output
Print «Yes» (without quotes), if user can register via this login, i.e. none of the existing logins is similar with it.
Otherwise print «No» (without quotes).
Examples
Input
1_wat
2
2_wat
wat_1
Output
Yes
Input
000
3
00
ooA
oOo
Output
No
Input
_i_
3
__i_
_1_
I
Output
No
Input
La0
3
2a0
La1
1a0
Output
No
Input
abc
1
aBc
Output
No
Input
0Lil
2
LIL0
0Ril
Output
Yes
Note
In the second sample case the user wants to create a login consisting of three zeros. It's impossible due to collision with the third among the existing.
In the third sample case the new login is similar with the second one.
Tags: *special, strings
Correct Solution:
```
s,n=input(),int(input())
s=s.replace('O','0')
s=s.replace('o','0')
for _ in range(n):
stp=''
a=input()
if len(a)==len(s):
for i in range(len(a)):
if a[i] in '1lILi' and s[i] in '1lILi':
stp+=a[i]
else:
stp+=s[i]
a=a.replace('O','0')
a=a.replace('o','0')
stp=stp.lower()
a=a.lower()
if a==stp:
print('No')
break
else: print('Yes')
```
| 8,122 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When registering in a social network, users are allowed to create their own convenient login to make it easier to share contacts, print it on business cards, etc.
Login is an arbitrary sequence of lower and uppercase latin letters, digits and underline symbols («_»). However, in order to decrease the number of frauds and user-inattention related issues, it is prohibited to register a login if it is similar with an already existing login. More precisely, two logins s and t are considered similar if we can transform s to t via a sequence of operations of the following types:
* transform lowercase letters to uppercase and vice versa;
* change letter «O» (uppercase latin letter) to digit «0» and vice versa;
* change digit «1» (one) to any letter among «l» (lowercase latin «L»), «I» (uppercase latin «i») and vice versa, or change one of these letters to other.
For example, logins «Codeforces» and «codef0rces» as well as «OO0OOO00O0OOO0O00OOO0OO_lol» and «OO0OOO0O00OOO0O00OO0OOO_1oI» are considered similar whereas «Codeforces» and «Code_forces» are not.
You're given a list of existing logins with no two similar amonst and a newly created user login. Check whether this new login is similar with any of the existing ones.
Input
The first line contains a non-empty string s consisting of lower and uppercase latin letters, digits and underline symbols («_») with length not exceeding 50 — the login itself.
The second line contains a single integer n (1 ≤ n ≤ 1 000) — the number of existing logins.
The next n lines describe the existing logins, following the same constraints as the user login (refer to the first line of the input). It's guaranteed that no two existing logins are similar.
Output
Print «Yes» (without quotes), if user can register via this login, i.e. none of the existing logins is similar with it.
Otherwise print «No» (without quotes).
Examples
Input
1_wat
2
2_wat
wat_1
Output
Yes
Input
000
3
00
ooA
oOo
Output
No
Input
_i_
3
__i_
_1_
I
Output
No
Input
La0
3
2a0
La1
1a0
Output
No
Input
abc
1
aBc
Output
No
Input
0Lil
2
LIL0
0Ril
Output
Yes
Note
In the second sample case the user wants to create a login consisting of three zeros. It's impossible due to collision with the third among the existing.
In the third sample case the new login is similar with the second one.
Tags: *special, strings
Correct Solution:
```
def is_similar(one, two):
one = one.lower()
two = two.lower()
one = one.replace('o', '0')
one = one.replace('i', '1')
one = one.replace('l', '1')
two = two.replace('o', '0')
two = two.replace('i', '1')
two = two.replace('l', '1')
return one == two
have_similar = False
newlogin = input()
counter = int(input())
for i in range(0, counter):
login = input()
if is_similar(newlogin, login):
have_similar = True
break
if have_similar:
print("No")
else:
print("Yes")
```
| 8,123 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When registering in a social network, users are allowed to create their own convenient login to make it easier to share contacts, print it on business cards, etc.
Login is an arbitrary sequence of lower and uppercase latin letters, digits and underline symbols («_»). However, in order to decrease the number of frauds and user-inattention related issues, it is prohibited to register a login if it is similar with an already existing login. More precisely, two logins s and t are considered similar if we can transform s to t via a sequence of operations of the following types:
* transform lowercase letters to uppercase and vice versa;
* change letter «O» (uppercase latin letter) to digit «0» and vice versa;
* change digit «1» (one) to any letter among «l» (lowercase latin «L»), «I» (uppercase latin «i») and vice versa, or change one of these letters to other.
For example, logins «Codeforces» and «codef0rces» as well as «OO0OOO00O0OOO0O00OOO0OO_lol» and «OO0OOO0O00OOO0O00OO0OOO_1oI» are considered similar whereas «Codeforces» and «Code_forces» are not.
You're given a list of existing logins with no two similar amonst and a newly created user login. Check whether this new login is similar with any of the existing ones.
Input
The first line contains a non-empty string s consisting of lower and uppercase latin letters, digits and underline symbols («_») with length not exceeding 50 — the login itself.
The second line contains a single integer n (1 ≤ n ≤ 1 000) — the number of existing logins.
The next n lines describe the existing logins, following the same constraints as the user login (refer to the first line of the input). It's guaranteed that no two existing logins are similar.
Output
Print «Yes» (without quotes), if user can register via this login, i.e. none of the existing logins is similar with it.
Otherwise print «No» (without quotes).
Examples
Input
1_wat
2
2_wat
wat_1
Output
Yes
Input
000
3
00
ooA
oOo
Output
No
Input
_i_
3
__i_
_1_
I
Output
No
Input
La0
3
2a0
La1
1a0
Output
No
Input
abc
1
aBc
Output
No
Input
0Lil
2
LIL0
0Ril
Output
Yes
Note
In the second sample case the user wants to create a login consisting of three zeros. It's impossible due to collision with the third among the existing.
In the third sample case the new login is similar with the second one.
Tags: *special, strings
Correct Solution:
```
def convert(s):
s = s.lower()
s = s.replace("0", "o")
s = s.replace("1", "l")
s = s.replace("i", "l")
return s
s = input()
s = convert(s)
n = int(input())
for i in range(n):
s1 = convert(input())
if s == s1:
print("No")
exit(0)
print("Yes")
```
| 8,124 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When registering in a social network, users are allowed to create their own convenient login to make it easier to share contacts, print it on business cards, etc.
Login is an arbitrary sequence of lower and uppercase latin letters, digits and underline symbols («_»). However, in order to decrease the number of frauds and user-inattention related issues, it is prohibited to register a login if it is similar with an already existing login. More precisely, two logins s and t are considered similar if we can transform s to t via a sequence of operations of the following types:
* transform lowercase letters to uppercase and vice versa;
* change letter «O» (uppercase latin letter) to digit «0» and vice versa;
* change digit «1» (one) to any letter among «l» (lowercase latin «L»), «I» (uppercase latin «i») and vice versa, or change one of these letters to other.
For example, logins «Codeforces» and «codef0rces» as well as «OO0OOO00O0OOO0O00OOO0OO_lol» and «OO0OOO0O00OOO0O00OO0OOO_1oI» are considered similar whereas «Codeforces» and «Code_forces» are not.
You're given a list of existing logins with no two similar amonst and a newly created user login. Check whether this new login is similar with any of the existing ones.
Input
The first line contains a non-empty string s consisting of lower and uppercase latin letters, digits and underline symbols («_») with length not exceeding 50 — the login itself.
The second line contains a single integer n (1 ≤ n ≤ 1 000) — the number of existing logins.
The next n lines describe the existing logins, following the same constraints as the user login (refer to the first line of the input). It's guaranteed that no two existing logins are similar.
Output
Print «Yes» (without quotes), if user can register via this login, i.e. none of the existing logins is similar with it.
Otherwise print «No» (without quotes).
Examples
Input
1_wat
2
2_wat
wat_1
Output
Yes
Input
000
3
00
ooA
oOo
Output
No
Input
_i_
3
__i_
_1_
I
Output
No
Input
La0
3
2a0
La1
1a0
Output
No
Input
abc
1
aBc
Output
No
Input
0Lil
2
LIL0
0Ril
Output
Yes
Note
In the second sample case the user wants to create a login consisting of three zeros. It's impossible due to collision with the third among the existing.
In the third sample case the new login is similar with the second one.
Tags: *special, strings
Correct Solution:
```
def transf(s):
return s.lower().replace('o', '0').replace('l', '1').replace('i', '1')
def check():
s = input()
n = int(input())
for i in range(n):
l = input()
if len(s) != len(l):
continue
if transf(s) == transf(l):
return 'No'
return 'Yes'
print(check())
```
| 8,125 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When registering in a social network, users are allowed to create their own convenient login to make it easier to share contacts, print it on business cards, etc.
Login is an arbitrary sequence of lower and uppercase latin letters, digits and underline symbols («_»). However, in order to decrease the number of frauds and user-inattention related issues, it is prohibited to register a login if it is similar with an already existing login. More precisely, two logins s and t are considered similar if we can transform s to t via a sequence of operations of the following types:
* transform lowercase letters to uppercase and vice versa;
* change letter «O» (uppercase latin letter) to digit «0» and vice versa;
* change digit «1» (one) to any letter among «l» (lowercase latin «L»), «I» (uppercase latin «i») and vice versa, or change one of these letters to other.
For example, logins «Codeforces» and «codef0rces» as well as «OO0OOO00O0OOO0O00OOO0OO_lol» and «OO0OOO0O00OOO0O00OO0OOO_1oI» are considered similar whereas «Codeforces» and «Code_forces» are not.
You're given a list of existing logins with no two similar amonst and a newly created user login. Check whether this new login is similar with any of the existing ones.
Input
The first line contains a non-empty string s consisting of lower and uppercase latin letters, digits and underline symbols («_») with length not exceeding 50 — the login itself.
The second line contains a single integer n (1 ≤ n ≤ 1 000) — the number of existing logins.
The next n lines describe the existing logins, following the same constraints as the user login (refer to the first line of the input). It's guaranteed that no two existing logins are similar.
Output
Print «Yes» (without quotes), if user can register via this login, i.e. none of the existing logins is similar with it.
Otherwise print «No» (without quotes).
Examples
Input
1_wat
2
2_wat
wat_1
Output
Yes
Input
000
3
00
ooA
oOo
Output
No
Input
_i_
3
__i_
_1_
I
Output
No
Input
La0
3
2a0
La1
1a0
Output
No
Input
abc
1
aBc
Output
No
Input
0Lil
2
LIL0
0Ril
Output
Yes
Note
In the second sample case the user wants to create a login consisting of three zeros. It's impossible due to collision with the third among the existing.
In the third sample case the new login is similar with the second one.
Tags: *special, strings
Correct Solution:
```
def normalize_login(login):
return login \
.lower() \
.replace("o", "0") \
.replace("i", "1") \
.replace("l", "1")
new_login = normalize_login(input())
n = int(input())
logins = []
for i in range(0, n):
login = normalize_login(input())
logins.append(login)
print("No" if new_login in logins else "Yes")
```
| 8,126 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When registering in a social network, users are allowed to create their own convenient login to make it easier to share contacts, print it on business cards, etc.
Login is an arbitrary sequence of lower and uppercase latin letters, digits and underline symbols («_»). However, in order to decrease the number of frauds and user-inattention related issues, it is prohibited to register a login if it is similar with an already existing login. More precisely, two logins s and t are considered similar if we can transform s to t via a sequence of operations of the following types:
* transform lowercase letters to uppercase and vice versa;
* change letter «O» (uppercase latin letter) to digit «0» and vice versa;
* change digit «1» (one) to any letter among «l» (lowercase latin «L»), «I» (uppercase latin «i») and vice versa, or change one of these letters to other.
For example, logins «Codeforces» and «codef0rces» as well as «OO0OOO00O0OOO0O00OOO0OO_lol» and «OO0OOO0O00OOO0O00OO0OOO_1oI» are considered similar whereas «Codeforces» and «Code_forces» are not.
You're given a list of existing logins with no two similar amonst and a newly created user login. Check whether this new login is similar with any of the existing ones.
Input
The first line contains a non-empty string s consisting of lower and uppercase latin letters, digits and underline symbols («_») with length not exceeding 50 — the login itself.
The second line contains a single integer n (1 ≤ n ≤ 1 000) — the number of existing logins.
The next n lines describe the existing logins, following the same constraints as the user login (refer to the first line of the input). It's guaranteed that no two existing logins are similar.
Output
Print «Yes» (without quotes), if user can register via this login, i.e. none of the existing logins is similar with it.
Otherwise print «No» (without quotes).
Examples
Input
1_wat
2
2_wat
wat_1
Output
Yes
Input
000
3
00
ooA
oOo
Output
No
Input
_i_
3
__i_
_1_
I
Output
No
Input
La0
3
2a0
La1
1a0
Output
No
Input
abc
1
aBc
Output
No
Input
0Lil
2
LIL0
0Ril
Output
Yes
Note
In the second sample case the user wants to create a login consisting of three zeros. It's impossible due to collision with the third among the existing.
In the third sample case the new login is similar with the second one.
Tags: *special, strings
Correct Solution:
```
def rep(data):
data = data.replace("0", "@@@")
data = data.replace("o", "@@@")
data = data.replace("1", "!!!")
data = data.replace("l", "!!!")
data = data.replace("i", "!!!")
return data
login_usr = rep(input().lower())
count_log = int(input())
data_log = list(map(rep, [input().lower() for i in range(count_log)]))
for data in data_log:
if data == login_usr:
count_log = 0
break
else:
count_log = 1
if count_log:
print("Yes")
else:
print("No")
```
| 8,127 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When registering in a social network, users are allowed to create their own convenient login to make it easier to share contacts, print it on business cards, etc.
Login is an arbitrary sequence of lower and uppercase latin letters, digits and underline symbols («_»). However, in order to decrease the number of frauds and user-inattention related issues, it is prohibited to register a login if it is similar with an already existing login. More precisely, two logins s and t are considered similar if we can transform s to t via a sequence of operations of the following types:
* transform lowercase letters to uppercase and vice versa;
* change letter «O» (uppercase latin letter) to digit «0» and vice versa;
* change digit «1» (one) to any letter among «l» (lowercase latin «L»), «I» (uppercase latin «i») and vice versa, or change one of these letters to other.
For example, logins «Codeforces» and «codef0rces» as well as «OO0OOO00O0OOO0O00OOO0OO_lol» and «OO0OOO0O00OOO0O00OO0OOO_1oI» are considered similar whereas «Codeforces» and «Code_forces» are not.
You're given a list of existing logins with no two similar amonst and a newly created user login. Check whether this new login is similar with any of the existing ones.
Input
The first line contains a non-empty string s consisting of lower and uppercase latin letters, digits and underline symbols («_») with length not exceeding 50 — the login itself.
The second line contains a single integer n (1 ≤ n ≤ 1 000) — the number of existing logins.
The next n lines describe the existing logins, following the same constraints as the user login (refer to the first line of the input). It's guaranteed that no two existing logins are similar.
Output
Print «Yes» (without quotes), if user can register via this login, i.e. none of the existing logins is similar with it.
Otherwise print «No» (without quotes).
Examples
Input
1_wat
2
2_wat
wat_1
Output
Yes
Input
000
3
00
ooA
oOo
Output
No
Input
_i_
3
__i_
_1_
I
Output
No
Input
La0
3
2a0
La1
1a0
Output
No
Input
abc
1
aBc
Output
No
Input
0Lil
2
LIL0
0Ril
Output
Yes
Note
In the second sample case the user wants to create a login consisting of three zeros. It's impossible due to collision with the third among the existing.
In the third sample case the new login is similar with the second one.
Submitted Solution:
```
s = input()
n = int(input())
for i in range(n):
t = input()
if len(s) != len(t):
continue
for j in range(len(t)):
if t[j].lower() == s[j].lower():
continue
if t[j] in '0Oo' and s[j] in '0Oo':
continue
if s[j] in '1lILi' and t[j] in '1lILi':
continue
# print(s[j], t[j], s, t, i)
break
else:
print('No')
exit(0)
print('Yes')
```
Yes
| 8,128 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When registering in a social network, users are allowed to create their own convenient login to make it easier to share contacts, print it on business cards, etc.
Login is an arbitrary sequence of lower and uppercase latin letters, digits and underline symbols («_»). However, in order to decrease the number of frauds and user-inattention related issues, it is prohibited to register a login if it is similar with an already existing login. More precisely, two logins s and t are considered similar if we can transform s to t via a sequence of operations of the following types:
* transform lowercase letters to uppercase and vice versa;
* change letter «O» (uppercase latin letter) to digit «0» and vice versa;
* change digit «1» (one) to any letter among «l» (lowercase latin «L»), «I» (uppercase latin «i») and vice versa, or change one of these letters to other.
For example, logins «Codeforces» and «codef0rces» as well as «OO0OOO00O0OOO0O00OOO0OO_lol» and «OO0OOO0O00OOO0O00OO0OOO_1oI» are considered similar whereas «Codeforces» and «Code_forces» are not.
You're given a list of existing logins with no two similar amonst and a newly created user login. Check whether this new login is similar with any of the existing ones.
Input
The first line contains a non-empty string s consisting of lower and uppercase latin letters, digits and underline symbols («_») with length not exceeding 50 — the login itself.
The second line contains a single integer n (1 ≤ n ≤ 1 000) — the number of existing logins.
The next n lines describe the existing logins, following the same constraints as the user login (refer to the first line of the input). It's guaranteed that no two existing logins are similar.
Output
Print «Yes» (without quotes), if user can register via this login, i.e. none of the existing logins is similar with it.
Otherwise print «No» (without quotes).
Examples
Input
1_wat
2
2_wat
wat_1
Output
Yes
Input
000
3
00
ooA
oOo
Output
No
Input
_i_
3
__i_
_1_
I
Output
No
Input
La0
3
2a0
La1
1a0
Output
No
Input
abc
1
aBc
Output
No
Input
0Lil
2
LIL0
0Ril
Output
Yes
Note
In the second sample case the user wants to create a login consisting of three zeros. It's impossible due to collision with the third among the existing.
In the third sample case the new login is similar with the second one.
Submitted Solution:
```
s = input()
n = int(input())
b = False
for i in range(n):
col = 0
s1 = input()
if len(s1) == len(s):
for i in range(len(s1)):
if s1[i].upper() == s[i].upper():
col += 1
if s1[i].upper() == 'O' and s[i] == '0':
col += 1
if s1[i] == '0' and s[i].upper() == 'O':
col += 1
if s1[i].upper() == 'I' and s[i] == '1':
col += 1
if s1[i].upper() == 'L' and s[i] == '1':
col += 1
if s1[i] == '1' and s[i].upper() == 'I':
col += 1
if s1[i] == '1' and s[i].upper() == 'L':
col += 1
if s1[i].upper() == 'I' and s[i].upper() == 'L':
col += 1
if s[i].upper() == 'I' and s1[i].upper() == 'L':
col += 1
if col == len(s1):
b = True
break
if b:
print("No")
else:
print("Yes")
```
Yes
| 8,129 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When registering in a social network, users are allowed to create their own convenient login to make it easier to share contacts, print it on business cards, etc.
Login is an arbitrary sequence of lower and uppercase latin letters, digits and underline symbols («_»). However, in order to decrease the number of frauds and user-inattention related issues, it is prohibited to register a login if it is similar with an already existing login. More precisely, two logins s and t are considered similar if we can transform s to t via a sequence of operations of the following types:
* transform lowercase letters to uppercase and vice versa;
* change letter «O» (uppercase latin letter) to digit «0» and vice versa;
* change digit «1» (one) to any letter among «l» (lowercase latin «L»), «I» (uppercase latin «i») and vice versa, or change one of these letters to other.
For example, logins «Codeforces» and «codef0rces» as well as «OO0OOO00O0OOO0O00OOO0OO_lol» and «OO0OOO0O00OOO0O00OO0OOO_1oI» are considered similar whereas «Codeforces» and «Code_forces» are not.
You're given a list of existing logins with no two similar amonst and a newly created user login. Check whether this new login is similar with any of the existing ones.
Input
The first line contains a non-empty string s consisting of lower and uppercase latin letters, digits and underline symbols («_») with length not exceeding 50 — the login itself.
The second line contains a single integer n (1 ≤ n ≤ 1 000) — the number of existing logins.
The next n lines describe the existing logins, following the same constraints as the user login (refer to the first line of the input). It's guaranteed that no two existing logins are similar.
Output
Print «Yes» (without quotes), if user can register via this login, i.e. none of the existing logins is similar with it.
Otherwise print «No» (without quotes).
Examples
Input
1_wat
2
2_wat
wat_1
Output
Yes
Input
000
3
00
ooA
oOo
Output
No
Input
_i_
3
__i_
_1_
I
Output
No
Input
La0
3
2a0
La1
1a0
Output
No
Input
abc
1
aBc
Output
No
Input
0Lil
2
LIL0
0Ril
Output
Yes
Note
In the second sample case the user wants to create a login consisting of three zeros. It's impossible due to collision with the third among the existing.
In the third sample case the new login is similar with the second one.
Submitted Solution:
```
def transform(log):
return log.replace('O', '0').replace('o', '0').replace('l', '1').replace('I', '1').\
replace('L', '1').replace('i', '1').lower()
login = transform(input())
n = int(input())
logins = []
check = False
for i in range(n):
if login == transform(input()):
print('No')
check = True
if not check:
print('Yes')
```
Yes
| 8,130 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When registering in a social network, users are allowed to create their own convenient login to make it easier to share contacts, print it on business cards, etc.
Login is an arbitrary sequence of lower and uppercase latin letters, digits and underline symbols («_»). However, in order to decrease the number of frauds and user-inattention related issues, it is prohibited to register a login if it is similar with an already existing login. More precisely, two logins s and t are considered similar if we can transform s to t via a sequence of operations of the following types:
* transform lowercase letters to uppercase and vice versa;
* change letter «O» (uppercase latin letter) to digit «0» and vice versa;
* change digit «1» (one) to any letter among «l» (lowercase latin «L»), «I» (uppercase latin «i») and vice versa, or change one of these letters to other.
For example, logins «Codeforces» and «codef0rces» as well as «OO0OOO00O0OOO0O00OOO0OO_lol» and «OO0OOO0O00OOO0O00OO0OOO_1oI» are considered similar whereas «Codeforces» and «Code_forces» are not.
You're given a list of existing logins with no two similar amonst and a newly created user login. Check whether this new login is similar with any of the existing ones.
Input
The first line contains a non-empty string s consisting of lower and uppercase latin letters, digits and underline symbols («_») with length not exceeding 50 — the login itself.
The second line contains a single integer n (1 ≤ n ≤ 1 000) — the number of existing logins.
The next n lines describe the existing logins, following the same constraints as the user login (refer to the first line of the input). It's guaranteed that no two existing logins are similar.
Output
Print «Yes» (without quotes), if user can register via this login, i.e. none of the existing logins is similar with it.
Otherwise print «No» (without quotes).
Examples
Input
1_wat
2
2_wat
wat_1
Output
Yes
Input
000
3
00
ooA
oOo
Output
No
Input
_i_
3
__i_
_1_
I
Output
No
Input
La0
3
2a0
La1
1a0
Output
No
Input
abc
1
aBc
Output
No
Input
0Lil
2
LIL0
0Ril
Output
Yes
Note
In the second sample case the user wants to create a login consisting of three zeros. It's impossible due to collision with the third among the existing.
In the third sample case the new login is similar with the second one.
Submitted Solution:
```
alpha = 'qwertyupasdfghjkzxcvbnmQWERTYUPASDFGHJKZXCVBNM'
alikes = []
for i in range(len(alpha)):
alikes.append(set(alpha[i]))
alikes[-1].add(alpha[(i + 23)%46])
alikes.append(set(['0', 'o', 'O']))
alikes.append(set(['l', 'L', 'i', 'I', '1']))
for i in range(2, 10):
alikes.append(set(str(i)))
alikes.append(set('_'))
a = input()
check = False
for i in range(int(input())):
b = input()
if len(a) != len(b) or check:
continue
for j in range(len(a)):
newCheck = False
for k in alikes:
if a[j] in k:
if b[j] not in k:
newCheck = True
break
if newCheck:
break
check = (j == len(a) - 1)
print('No' if check else 'Yes')
```
Yes
| 8,131 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When registering in a social network, users are allowed to create their own convenient login to make it easier to share contacts, print it on business cards, etc.
Login is an arbitrary sequence of lower and uppercase latin letters, digits and underline symbols («_»). However, in order to decrease the number of frauds and user-inattention related issues, it is prohibited to register a login if it is similar with an already existing login. More precisely, two logins s and t are considered similar if we can transform s to t via a sequence of operations of the following types:
* transform lowercase letters to uppercase and vice versa;
* change letter «O» (uppercase latin letter) to digit «0» and vice versa;
* change digit «1» (one) to any letter among «l» (lowercase latin «L»), «I» (uppercase latin «i») and vice versa, or change one of these letters to other.
For example, logins «Codeforces» and «codef0rces» as well as «OO0OOO00O0OOO0O00OOO0OO_lol» and «OO0OOO0O00OOO0O00OO0OOO_1oI» are considered similar whereas «Codeforces» and «Code_forces» are not.
You're given a list of existing logins with no two similar amonst and a newly created user login. Check whether this new login is similar with any of the existing ones.
Input
The first line contains a non-empty string s consisting of lower and uppercase latin letters, digits and underline symbols («_») with length not exceeding 50 — the login itself.
The second line contains a single integer n (1 ≤ n ≤ 1 000) — the number of existing logins.
The next n lines describe the existing logins, following the same constraints as the user login (refer to the first line of the input). It's guaranteed that no two existing logins are similar.
Output
Print «Yes» (without quotes), if user can register via this login, i.e. none of the existing logins is similar with it.
Otherwise print «No» (without quotes).
Examples
Input
1_wat
2
2_wat
wat_1
Output
Yes
Input
000
3
00
ooA
oOo
Output
No
Input
_i_
3
__i_
_1_
I
Output
No
Input
La0
3
2a0
La1
1a0
Output
No
Input
abc
1
aBc
Output
No
Input
0Lil
2
LIL0
0Ril
Output
Yes
Note
In the second sample case the user wants to create a login consisting of three zeros. It's impossible due to collision with the third among the existing.
In the third sample case the new login is similar with the second one.
Submitted Solution:
```
def f(login1,login2):
s1 = login1.lower()
s2 = login2.lower()
if len(login1) != len(login2):
return False
else:
p = 0
for i in range(len(login1)):
if (s1[i] == s2[i])or((s1[i] == "o")and(s2[i] == "0"))or((s1[i] == "0")and(s2[i] == "o"))or((login1[i] == "1")and(login2[i] == "l"))or((login1[i] == "1")and(login2[i] == "I"))or((login2[i] == "1")and(s1[i] == "l"))or((login2[i] == "1")and(s1[i] == "i"))or((login2[i] == "l")and(s1[i] == "i"))or((s1[i] == "l")and(login2[i] == "I")):
p += 1
if p == len(s1):
return True
else:
return False
login = input()
n = int(input())
a =[]
q = True
for i in range(n):
new = input()
if f(login,new):
print("No")
q = False
break
if q:
print("Yes")
```
No
| 8,132 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When registering in a social network, users are allowed to create their own convenient login to make it easier to share contacts, print it on business cards, etc.
Login is an arbitrary sequence of lower and uppercase latin letters, digits and underline symbols («_»). However, in order to decrease the number of frauds and user-inattention related issues, it is prohibited to register a login if it is similar with an already existing login. More precisely, two logins s and t are considered similar if we can transform s to t via a sequence of operations of the following types:
* transform lowercase letters to uppercase and vice versa;
* change letter «O» (uppercase latin letter) to digit «0» and vice versa;
* change digit «1» (one) to any letter among «l» (lowercase latin «L»), «I» (uppercase latin «i») and vice versa, or change one of these letters to other.
For example, logins «Codeforces» and «codef0rces» as well as «OO0OOO00O0OOO0O00OOO0OO_lol» and «OO0OOO0O00OOO0O00OO0OOO_1oI» are considered similar whereas «Codeforces» and «Code_forces» are not.
You're given a list of existing logins with no two similar amonst and a newly created user login. Check whether this new login is similar with any of the existing ones.
Input
The first line contains a non-empty string s consisting of lower and uppercase latin letters, digits and underline symbols («_») with length not exceeding 50 — the login itself.
The second line contains a single integer n (1 ≤ n ≤ 1 000) — the number of existing logins.
The next n lines describe the existing logins, following the same constraints as the user login (refer to the first line of the input). It's guaranteed that no two existing logins are similar.
Output
Print «Yes» (without quotes), if user can register via this login, i.e. none of the existing logins is similar with it.
Otherwise print «No» (without quotes).
Examples
Input
1_wat
2
2_wat
wat_1
Output
Yes
Input
000
3
00
ooA
oOo
Output
No
Input
_i_
3
__i_
_1_
I
Output
No
Input
La0
3
2a0
La1
1a0
Output
No
Input
abc
1
aBc
Output
No
Input
0Lil
2
LIL0
0Ril
Output
Yes
Note
In the second sample case the user wants to create a login consisting of three zeros. It's impossible due to collision with the third among the existing.
In the third sample case the new login is similar with the second one.
Submitted Solution:
```
x=input()
x=x.lower()
n=int(input())
for i in range(n):
s1=input()
s1=s1.lower()
if len(s1) != len(x):
continue
for i in range(len(s1)):
if s1[i] != x[i]:
if x[i] == "0" and s1[i] == "o" or s1[i] == "o" and x[i] == "0":
continue
elif x[i] == "1" and (s1[i] == "l" or s1[i]=='i') or s1[i] == "1" and (x[i] == "l" or x[i]=='i'):
continue
else:
break
else:
print("No")
break
else:
print("Yes")
```
No
| 8,133 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When registering in a social network, users are allowed to create their own convenient login to make it easier to share contacts, print it on business cards, etc.
Login is an arbitrary sequence of lower and uppercase latin letters, digits and underline symbols («_»). However, in order to decrease the number of frauds and user-inattention related issues, it is prohibited to register a login if it is similar with an already existing login. More precisely, two logins s and t are considered similar if we can transform s to t via a sequence of operations of the following types:
* transform lowercase letters to uppercase and vice versa;
* change letter «O» (uppercase latin letter) to digit «0» and vice versa;
* change digit «1» (one) to any letter among «l» (lowercase latin «L»), «I» (uppercase latin «i») and vice versa, or change one of these letters to other.
For example, logins «Codeforces» and «codef0rces» as well as «OO0OOO00O0OOO0O00OOO0OO_lol» and «OO0OOO0O00OOO0O00OO0OOO_1oI» are considered similar whereas «Codeforces» and «Code_forces» are not.
You're given a list of existing logins with no two similar amonst and a newly created user login. Check whether this new login is similar with any of the existing ones.
Input
The first line contains a non-empty string s consisting of lower and uppercase latin letters, digits and underline symbols («_») with length not exceeding 50 — the login itself.
The second line contains a single integer n (1 ≤ n ≤ 1 000) — the number of existing logins.
The next n lines describe the existing logins, following the same constraints as the user login (refer to the first line of the input). It's guaranteed that no two existing logins are similar.
Output
Print «Yes» (without quotes), if user can register via this login, i.e. none of the existing logins is similar with it.
Otherwise print «No» (without quotes).
Examples
Input
1_wat
2
2_wat
wat_1
Output
Yes
Input
000
3
00
ooA
oOo
Output
No
Input
_i_
3
__i_
_1_
I
Output
No
Input
La0
3
2a0
La1
1a0
Output
No
Input
abc
1
aBc
Output
No
Input
0Lil
2
LIL0
0Ril
Output
Yes
Note
In the second sample case the user wants to create a login consisting of three zeros. It's impossible due to collision with the third among the existing.
In the third sample case the new login is similar with the second one.
Submitted Solution:
```
def corrector(w, p):
if w.upper() == p or w.lower() == p:
return "OK"
mas_0 = ["0", "O", "o"]
if (w in mas_0) and (p in mas_0):
return "OK"
mas_1 = ["1", "L", "l", "I", "i"]
if (w in mas_1) and (p in mas_1):
return "OK"
return "NOT"
def progress(present, wish):
position = 0
while position < len(present):
w = wish[position]
p = present[position]
ans = corrector(w, p)
if ans == "NOT":
return 1 # не смогли поменять букву
position += 1
return 0 # смогли поменять все букву
def main():
wish = str(input())
kol = int(input())
for i in range(kol):
present = str(input())
if present == wish:
print("No")
return 0
if len(present) == len(wish):
if progress(present, wish) == 0:
print("No")
return 0
else:
print("CHECk")
continue
print("Yes")
if __name__ == '__main__':
main()
```
No
| 8,134 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When registering in a social network, users are allowed to create their own convenient login to make it easier to share contacts, print it on business cards, etc.
Login is an arbitrary sequence of lower and uppercase latin letters, digits and underline symbols («_»). However, in order to decrease the number of frauds and user-inattention related issues, it is prohibited to register a login if it is similar with an already existing login. More precisely, two logins s and t are considered similar if we can transform s to t via a sequence of operations of the following types:
* transform lowercase letters to uppercase and vice versa;
* change letter «O» (uppercase latin letter) to digit «0» and vice versa;
* change digit «1» (one) to any letter among «l» (lowercase latin «L»), «I» (uppercase latin «i») and vice versa, or change one of these letters to other.
For example, logins «Codeforces» and «codef0rces» as well as «OO0OOO00O0OOO0O00OOO0OO_lol» and «OO0OOO0O00OOO0O00OO0OOO_1oI» are considered similar whereas «Codeforces» and «Code_forces» are not.
You're given a list of existing logins with no two similar amonst and a newly created user login. Check whether this new login is similar with any of the existing ones.
Input
The first line contains a non-empty string s consisting of lower and uppercase latin letters, digits and underline symbols («_») with length not exceeding 50 — the login itself.
The second line contains a single integer n (1 ≤ n ≤ 1 000) — the number of existing logins.
The next n lines describe the existing logins, following the same constraints as the user login (refer to the first line of the input). It's guaranteed that no two existing logins are similar.
Output
Print «Yes» (without quotes), if user can register via this login, i.e. none of the existing logins is similar with it.
Otherwise print «No» (without quotes).
Examples
Input
1_wat
2
2_wat
wat_1
Output
Yes
Input
000
3
00
ooA
oOo
Output
No
Input
_i_
3
__i_
_1_
I
Output
No
Input
La0
3
2a0
La1
1a0
Output
No
Input
abc
1
aBc
Output
No
Input
0Lil
2
LIL0
0Ril
Output
Yes
Note
In the second sample case the user wants to create a login consisting of three zeros. It's impossible due to collision with the third among the existing.
In the third sample case the new login is similar with the second one.
Submitted Solution:
```
def can_exist(login, existing_logins):
for word in existing_logins:
if len(word) == len(login):
for i in range(len(word)):
if word[i] == login[i]:
continue
elif word[i].replace('o', '0').replace('l', '1').replace('i', '1') ==\
login[i].replace('o', '0').replace('l', '1').replace('i', '1'):
continue
break
else:
return "No"
return "Yes"
if __name__ == '__main__':
login = input()
n = int(input())
existing_logins = list()
for i in range(n):
existing_logins.append(input().lower())
print(can_exist(login, existing_logins))
```
No
| 8,135 |
Provide tags and a correct Python 3 solution for this coding contest problem.
An atom of element X can exist in n distinct states with energies E1 < E2 < ... < En. Arkady wants to build a laser on this element, using a three-level scheme. Here is a simplified description of the scheme.
Three distinct states i, j and k are selected, where i < j < k. After that the following process happens:
1. initially the atom is in the state i,
2. we spend Ek - Ei energy to put the atom in the state k,
3. the atom emits a photon with useful energy Ek - Ej and changes its state to the state j,
4. the atom spontaneously changes its state to the state i, losing energy Ej - Ei,
5. the process repeats from step 1.
Let's define the energy conversion efficiency as <image>, i. e. the ration between the useful energy of the photon and spent energy.
Due to some limitations, Arkady can only choose such three states that Ek - Ei ≤ U.
Help Arkady to find such the maximum possible energy conversion efficiency within the above constraints.
Input
The first line contains two integers n and U (3 ≤ n ≤ 105, 1 ≤ U ≤ 109) — the number of states and the maximum possible difference between Ek and Ei.
The second line contains a sequence of integers E1, E2, ..., En (1 ≤ E1 < E2... < En ≤ 109). It is guaranteed that all Ei are given in increasing order.
Output
If it is not possible to choose three states that satisfy all constraints, print -1.
Otherwise, print one real number η — the maximum possible energy conversion efficiency. Your answer is considered correct its absolute or relative error does not exceed 10 - 9.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
4 4
1 3 5 7
Output
0.5
Input
10 8
10 13 15 16 17 19 20 22 24 25
Output
0.875
Input
3 1
2 5 10
Output
-1
Note
In the first example choose states 1, 2 and 3, so that the energy conversion efficiency becomes equal to <image>.
In the second example choose states 4, 5 and 9, so that the energy conversion efficiency becomes equal to <image>.
Tags: binary search, greedy, two pointers
Correct Solution:
```
n,u=map(int,input().split())
arr=list(map(int,input().split()))
# arr.sort()
j,i=1,0
maxi=-1
flag=0
for i in range(n-1):
if arr[i+1]-arr[i]<=u:
flag=1
if flag==0:
print("-1")
exit()
i=0
while(i<n-2):
while(1):
if j>=n:
j=n-1
break
if arr[j]-arr[i]>u:
j-=1
break
j+=1
if i==j:
j+=1
elif arr[j]==arr[i]:
pass
elif arr[j]-arr[i]<=u:
# print(i,j)
maxi=max(maxi,(arr[j]-arr[i+1])/(arr[j]-arr[i]))
i+=1
if maxi==0:
print("-1")
else:
print(maxi)
```
| 8,136 |
Provide tags and a correct Python 3 solution for this coding contest problem.
An atom of element X can exist in n distinct states with energies E1 < E2 < ... < En. Arkady wants to build a laser on this element, using a three-level scheme. Here is a simplified description of the scheme.
Three distinct states i, j and k are selected, where i < j < k. After that the following process happens:
1. initially the atom is in the state i,
2. we spend Ek - Ei energy to put the atom in the state k,
3. the atom emits a photon with useful energy Ek - Ej and changes its state to the state j,
4. the atom spontaneously changes its state to the state i, losing energy Ej - Ei,
5. the process repeats from step 1.
Let's define the energy conversion efficiency as <image>, i. e. the ration between the useful energy of the photon and spent energy.
Due to some limitations, Arkady can only choose such three states that Ek - Ei ≤ U.
Help Arkady to find such the maximum possible energy conversion efficiency within the above constraints.
Input
The first line contains two integers n and U (3 ≤ n ≤ 105, 1 ≤ U ≤ 109) — the number of states and the maximum possible difference between Ek and Ei.
The second line contains a sequence of integers E1, E2, ..., En (1 ≤ E1 < E2... < En ≤ 109). It is guaranteed that all Ei are given in increasing order.
Output
If it is not possible to choose three states that satisfy all constraints, print -1.
Otherwise, print one real number η — the maximum possible energy conversion efficiency. Your answer is considered correct its absolute or relative error does not exceed 10 - 9.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
4 4
1 3 5 7
Output
0.5
Input
10 8
10 13 15 16 17 19 20 22 24 25
Output
0.875
Input
3 1
2 5 10
Output
-1
Note
In the first example choose states 1, 2 and 3, so that the energy conversion efficiency becomes equal to <image>.
In the second example choose states 4, 5 and 9, so that the energy conversion efficiency becomes equal to <image>.
Tags: binary search, greedy, two pointers
Correct Solution:
```
n,U=map(int,input().split())
Ar=list(map(int,input().split()))
R = 0;
ans = -1;
for i in range(n):
while R + 1 < n and Ar[R + 1] - Ar[i] <= U:
R+=1
if i+1 < R:
ans = max((Ar[R] - Ar[i + 1]) / (Ar[R] - Ar[i]),ans);
print(ans)
```
| 8,137 |
Provide tags and a correct Python 3 solution for this coding contest problem.
An atom of element X can exist in n distinct states with energies E1 < E2 < ... < En. Arkady wants to build a laser on this element, using a three-level scheme. Here is a simplified description of the scheme.
Three distinct states i, j and k are selected, where i < j < k. After that the following process happens:
1. initially the atom is in the state i,
2. we spend Ek - Ei energy to put the atom in the state k,
3. the atom emits a photon with useful energy Ek - Ej and changes its state to the state j,
4. the atom spontaneously changes its state to the state i, losing energy Ej - Ei,
5. the process repeats from step 1.
Let's define the energy conversion efficiency as <image>, i. e. the ration between the useful energy of the photon and spent energy.
Due to some limitations, Arkady can only choose such three states that Ek - Ei ≤ U.
Help Arkady to find such the maximum possible energy conversion efficiency within the above constraints.
Input
The first line contains two integers n and U (3 ≤ n ≤ 105, 1 ≤ U ≤ 109) — the number of states and the maximum possible difference between Ek and Ei.
The second line contains a sequence of integers E1, E2, ..., En (1 ≤ E1 < E2... < En ≤ 109). It is guaranteed that all Ei are given in increasing order.
Output
If it is not possible to choose three states that satisfy all constraints, print -1.
Otherwise, print one real number η — the maximum possible energy conversion efficiency. Your answer is considered correct its absolute or relative error does not exceed 10 - 9.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
4 4
1 3 5 7
Output
0.5
Input
10 8
10 13 15 16 17 19 20 22 24 25
Output
0.875
Input
3 1
2 5 10
Output
-1
Note
In the first example choose states 1, 2 and 3, so that the energy conversion efficiency becomes equal to <image>.
In the second example choose states 4, 5 and 9, so that the energy conversion efficiency becomes equal to <image>.
Tags: binary search, greedy, two pointers
Correct Solution:
```
import sys
def read_two_int():
return map(int, sys.stdin.readline().strip().split(' '))
def fast_solution(n, U, E):
best = -1
R = 2
for i in range(n-2):
# move R forcefully
R = max(R, i+2)
while (R + 1 < n) and (E[R+1] - E[i] <= U):
R += 1
if E[R] - E[i] <= U:
efficiency = float(E[R] - E[i+1]) / (E[R] - E[i])
if best is None or efficiency > best:
best = efficiency
return best
n, U = read_two_int()
E = list(read_two_int())
print(fast_solution(n, U, E))
```
| 8,138 |
Provide tags and a correct Python 3 solution for this coding contest problem.
An atom of element X can exist in n distinct states with energies E1 < E2 < ... < En. Arkady wants to build a laser on this element, using a three-level scheme. Here is a simplified description of the scheme.
Three distinct states i, j and k are selected, where i < j < k. After that the following process happens:
1. initially the atom is in the state i,
2. we spend Ek - Ei energy to put the atom in the state k,
3. the atom emits a photon with useful energy Ek - Ej and changes its state to the state j,
4. the atom spontaneously changes its state to the state i, losing energy Ej - Ei,
5. the process repeats from step 1.
Let's define the energy conversion efficiency as <image>, i. e. the ration between the useful energy of the photon and spent energy.
Due to some limitations, Arkady can only choose such three states that Ek - Ei ≤ U.
Help Arkady to find such the maximum possible energy conversion efficiency within the above constraints.
Input
The first line contains two integers n and U (3 ≤ n ≤ 105, 1 ≤ U ≤ 109) — the number of states and the maximum possible difference between Ek and Ei.
The second line contains a sequence of integers E1, E2, ..., En (1 ≤ E1 < E2... < En ≤ 109). It is guaranteed that all Ei are given in increasing order.
Output
If it is not possible to choose three states that satisfy all constraints, print -1.
Otherwise, print one real number η — the maximum possible energy conversion efficiency. Your answer is considered correct its absolute or relative error does not exceed 10 - 9.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
4 4
1 3 5 7
Output
0.5
Input
10 8
10 13 15 16 17 19 20 22 24 25
Output
0.875
Input
3 1
2 5 10
Output
-1
Note
In the first example choose states 1, 2 and 3, so that the energy conversion efficiency becomes equal to <image>.
In the second example choose states 4, 5 and 9, so that the energy conversion efficiency becomes equal to <image>.
Tags: binary search, greedy, two pointers
Correct Solution:
```
n,u = map(int,input().split())
a = list(map(int,input().split()))
i = 0
j = 1
f = 1
ma = -1
while not((i==j) and (i==n-1)):
if j<=i:
j+=1
if j < n-1:
if a[j+1]-a[i] <= u:
j+=1
else:
if j-i >= 2:
f=0
#print(i,j)
ma = max(ma,(a[j]-a[i+1])/(a[j]-a[i]))
i+=1
else:
if j-i >= 2:
f=0
#print(i,j)
ma = max(ma,(a[j]-a[i+1])/(a[j]-a[i]))
i+=1
if f:print(-1)
else:print(ma)
```
| 8,139 |
Provide tags and a correct Python 3 solution for this coding contest problem.
An atom of element X can exist in n distinct states with energies E1 < E2 < ... < En. Arkady wants to build a laser on this element, using a three-level scheme. Here is a simplified description of the scheme.
Three distinct states i, j and k are selected, where i < j < k. After that the following process happens:
1. initially the atom is in the state i,
2. we spend Ek - Ei energy to put the atom in the state k,
3. the atom emits a photon with useful energy Ek - Ej and changes its state to the state j,
4. the atom spontaneously changes its state to the state i, losing energy Ej - Ei,
5. the process repeats from step 1.
Let's define the energy conversion efficiency as <image>, i. e. the ration between the useful energy of the photon and spent energy.
Due to some limitations, Arkady can only choose such three states that Ek - Ei ≤ U.
Help Arkady to find such the maximum possible energy conversion efficiency within the above constraints.
Input
The first line contains two integers n and U (3 ≤ n ≤ 105, 1 ≤ U ≤ 109) — the number of states and the maximum possible difference between Ek and Ei.
The second line contains a sequence of integers E1, E2, ..., En (1 ≤ E1 < E2... < En ≤ 109). It is guaranteed that all Ei are given in increasing order.
Output
If it is not possible to choose three states that satisfy all constraints, print -1.
Otherwise, print one real number η — the maximum possible energy conversion efficiency. Your answer is considered correct its absolute or relative error does not exceed 10 - 9.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
4 4
1 3 5 7
Output
0.5
Input
10 8
10 13 15 16 17 19 20 22 24 25
Output
0.875
Input
3 1
2 5 10
Output
-1
Note
In the first example choose states 1, 2 and 3, so that the energy conversion efficiency becomes equal to <image>.
In the second example choose states 4, 5 and 9, so that the energy conversion efficiency becomes equal to <image>.
Tags: binary search, greedy, two pointers
Correct Solution:
```
n, U = [int(c) for c in input().split(" ")]
E = [int(c) for c in input().split(" ")]
def binary_max_search(max_limit): # give index biggest, but less than max_limit
left, right = 0, n-1
while left < right:
mid = (left+right)//2 + 1
#print(left, mid, right)
if E[mid] <= max_limit:
left, right = mid, right
else:
left, right = left, mid - 1
return left
max_conversion_rate = -1
for i in range(n-2):
k = binary_max_search(U + E[i])
#print("Find for (%d, %d, K) = %d" % (i, i+1, k))
if k > i+1:
temp = (E[k] - E[i+1]) / (E[k] - E[i])
#print("Conversion rate = %f" % temp)
if temp > max_conversion_rate:
max_conversion_rate = temp
print(max_conversion_rate)
```
| 8,140 |
Provide tags and a correct Python 3 solution for this coding contest problem.
An atom of element X can exist in n distinct states with energies E1 < E2 < ... < En. Arkady wants to build a laser on this element, using a three-level scheme. Here is a simplified description of the scheme.
Three distinct states i, j and k are selected, where i < j < k. After that the following process happens:
1. initially the atom is in the state i,
2. we spend Ek - Ei energy to put the atom in the state k,
3. the atom emits a photon with useful energy Ek - Ej and changes its state to the state j,
4. the atom spontaneously changes its state to the state i, losing energy Ej - Ei,
5. the process repeats from step 1.
Let's define the energy conversion efficiency as <image>, i. e. the ration between the useful energy of the photon and spent energy.
Due to some limitations, Arkady can only choose such three states that Ek - Ei ≤ U.
Help Arkady to find such the maximum possible energy conversion efficiency within the above constraints.
Input
The first line contains two integers n and U (3 ≤ n ≤ 105, 1 ≤ U ≤ 109) — the number of states and the maximum possible difference between Ek and Ei.
The second line contains a sequence of integers E1, E2, ..., En (1 ≤ E1 < E2... < En ≤ 109). It is guaranteed that all Ei are given in increasing order.
Output
If it is not possible to choose three states that satisfy all constraints, print -1.
Otherwise, print one real number η — the maximum possible energy conversion efficiency. Your answer is considered correct its absolute or relative error does not exceed 10 - 9.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
4 4
1 3 5 7
Output
0.5
Input
10 8
10 13 15 16 17 19 20 22 24 25
Output
0.875
Input
3 1
2 5 10
Output
-1
Note
In the first example choose states 1, 2 and 3, so that the energy conversion efficiency becomes equal to <image>.
In the second example choose states 4, 5 and 9, so that the energy conversion efficiency becomes equal to <image>.
Tags: binary search, greedy, two pointers
Correct Solution:
```
def sss(l,r,tt):
f = -1
while(l<=r):
mid = (l + r) >> 1
if(a[mid]-a[tt] <= m):
f = mid
l = mid + 1
else :
r = mid - 1
return f
n , m = map(int, input().split())
a = [int(x) for x in input().split()]
f = 0
l = len(a)
#print("l==" + str(l))
Maxx = -1
for i in range(0,l-2):
if(a[i+2] - a[i]<= m):
k = sss(i+2,l-1,i)
if(k != -1):
Maxx = max(Maxx,(a[k] - a[i+1])/(a[k]-a[i]))
if(Maxx == -1):
print(-1)
else: print("%.15f\n" % Maxx)
```
| 8,141 |
Provide tags and a correct Python 3 solution for this coding contest problem.
An atom of element X can exist in n distinct states with energies E1 < E2 < ... < En. Arkady wants to build a laser on this element, using a three-level scheme. Here is a simplified description of the scheme.
Three distinct states i, j and k are selected, where i < j < k. After that the following process happens:
1. initially the atom is in the state i,
2. we spend Ek - Ei energy to put the atom in the state k,
3. the atom emits a photon with useful energy Ek - Ej and changes its state to the state j,
4. the atom spontaneously changes its state to the state i, losing energy Ej - Ei,
5. the process repeats from step 1.
Let's define the energy conversion efficiency as <image>, i. e. the ration between the useful energy of the photon and spent energy.
Due to some limitations, Arkady can only choose such three states that Ek - Ei ≤ U.
Help Arkady to find such the maximum possible energy conversion efficiency within the above constraints.
Input
The first line contains two integers n and U (3 ≤ n ≤ 105, 1 ≤ U ≤ 109) — the number of states and the maximum possible difference between Ek and Ei.
The second line contains a sequence of integers E1, E2, ..., En (1 ≤ E1 < E2... < En ≤ 109). It is guaranteed that all Ei are given in increasing order.
Output
If it is not possible to choose three states that satisfy all constraints, print -1.
Otherwise, print one real number η — the maximum possible energy conversion efficiency. Your answer is considered correct its absolute or relative error does not exceed 10 - 9.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
4 4
1 3 5 7
Output
0.5
Input
10 8
10 13 15 16 17 19 20 22 24 25
Output
0.875
Input
3 1
2 5 10
Output
-1
Note
In the first example choose states 1, 2 and 3, so that the energy conversion efficiency becomes equal to <image>.
In the second example choose states 4, 5 and 9, so that the energy conversion efficiency becomes equal to <image>.
Tags: binary search, greedy, two pointers
Correct Solution:
```
nE, U = [int(x) for x in input().split(" ")]
energies = [int(x) for x in input().split(" ")]
end = 0
best_ratio = -1
for beg in range(nE-2):
while(end+1 < nE and energies[end+1] - energies[beg] <= U):
end += 1
if end - beg < 2:
continue
new_ratio = (energies[end] - energies[beg+1]) / (energies[end] - energies[beg])
best_ratio = max(best_ratio, new_ratio)
if best_ratio == -1:
print(-1)
else:
print("%.20f" % best_ratio)
```
| 8,142 |
Provide tags and a correct Python 3 solution for this coding contest problem.
An atom of element X can exist in n distinct states with energies E1 < E2 < ... < En. Arkady wants to build a laser on this element, using a three-level scheme. Here is a simplified description of the scheme.
Three distinct states i, j and k are selected, where i < j < k. After that the following process happens:
1. initially the atom is in the state i,
2. we spend Ek - Ei energy to put the atom in the state k,
3. the atom emits a photon with useful energy Ek - Ej and changes its state to the state j,
4. the atom spontaneously changes its state to the state i, losing energy Ej - Ei,
5. the process repeats from step 1.
Let's define the energy conversion efficiency as <image>, i. e. the ration between the useful energy of the photon and spent energy.
Due to some limitations, Arkady can only choose such three states that Ek - Ei ≤ U.
Help Arkady to find such the maximum possible energy conversion efficiency within the above constraints.
Input
The first line contains two integers n and U (3 ≤ n ≤ 105, 1 ≤ U ≤ 109) — the number of states and the maximum possible difference between Ek and Ei.
The second line contains a sequence of integers E1, E2, ..., En (1 ≤ E1 < E2... < En ≤ 109). It is guaranteed that all Ei are given in increasing order.
Output
If it is not possible to choose three states that satisfy all constraints, print -1.
Otherwise, print one real number η — the maximum possible energy conversion efficiency. Your answer is considered correct its absolute or relative error does not exceed 10 - 9.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
4 4
1 3 5 7
Output
0.5
Input
10 8
10 13 15 16 17 19 20 22 24 25
Output
0.875
Input
3 1
2 5 10
Output
-1
Note
In the first example choose states 1, 2 and 3, so that the energy conversion efficiency becomes equal to <image>.
In the second example choose states 4, 5 and 9, so that the energy conversion efficiency becomes equal to <image>.
Tags: binary search, greedy, two pointers
Correct Solution:
```
n,U = map(int,input().split())
E = [int(x) for x in input().split()]
E.append(10**100)
k = 0
best = -1
for i in range(n):
while E[k+1]-E[i] <= U:
k += 1
j = i+1
if i<j<k:
best = max(best, (E[k]-E[j])/(E[k]-E[i]))
print(best)
```
| 8,143 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An atom of element X can exist in n distinct states with energies E1 < E2 < ... < En. Arkady wants to build a laser on this element, using a three-level scheme. Here is a simplified description of the scheme.
Three distinct states i, j and k are selected, where i < j < k. After that the following process happens:
1. initially the atom is in the state i,
2. we spend Ek - Ei energy to put the atom in the state k,
3. the atom emits a photon with useful energy Ek - Ej and changes its state to the state j,
4. the atom spontaneously changes its state to the state i, losing energy Ej - Ei,
5. the process repeats from step 1.
Let's define the energy conversion efficiency as <image>, i. e. the ration between the useful energy of the photon and spent energy.
Due to some limitations, Arkady can only choose such three states that Ek - Ei ≤ U.
Help Arkady to find such the maximum possible energy conversion efficiency within the above constraints.
Input
The first line contains two integers n and U (3 ≤ n ≤ 105, 1 ≤ U ≤ 109) — the number of states and the maximum possible difference between Ek and Ei.
The second line contains a sequence of integers E1, E2, ..., En (1 ≤ E1 < E2... < En ≤ 109). It is guaranteed that all Ei are given in increasing order.
Output
If it is not possible to choose three states that satisfy all constraints, print -1.
Otherwise, print one real number η — the maximum possible energy conversion efficiency. Your answer is considered correct its absolute or relative error does not exceed 10 - 9.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
4 4
1 3 5 7
Output
0.5
Input
10 8
10 13 15 16 17 19 20 22 24 25
Output
0.875
Input
3 1
2 5 10
Output
-1
Note
In the first example choose states 1, 2 and 3, so that the energy conversion efficiency becomes equal to <image>.
In the second example choose states 4, 5 and 9, so that the energy conversion efficiency becomes equal to <image>.
Submitted Solution:
```
n, U = list(map(int, input().split()))
E = list(map(int, input().split()))
ind_i = 0
prev_ind_k = ind_i + 2
maxi_efficiency = -1
turn = 0
for ind_i in range(0, n - 2):
ind_j = ind_i + 1
prev_ind_k = max(prev_ind_k, ind_i + 2)
Ei = E[ind_i]
Ej = E[ind_j]
for ind_k in range(prev_ind_k, n + 1):
# print("ind_i, ind_k", ind_i, ind_k)
if ind_k == n:
prev_ind_k = n - 1
break
Ek = E[ind_k]
if (Ek - Ei) > U:
prev_ind_k = ind_k - 1
break
efficiency = (Ek - Ej) / (Ek - Ei)
# print("efficiency : ", efficiency)
if efficiency > maxi_efficiency:
# print(ind_i, ind_k)
maxi_efficiency = efficiency
print(maxi_efficiency)
# if (ind_i == n-3 and ind_j == n-2 and ind_k == n-1):
# break
# n, U = list(map(int, input().split()))
# E = list(map(int, input().split()))
# ind_i = 0
# ind_k = 2
# maxi_efficiency = -1
# turn = 0
# while ind_i < n - 2 and ind_k < n:
# # print("ind_i, ind_j : ", ind_i, ind_k)
# ind_j = ind_i + 1
# Ei = E[ind_i]
# Ej = E[ind_j]
# Ek = E[ind_k]
# if (Ek - Ei) > U:
# # print("too much")
# ind_i += 1
# ind_k = max(ind_k, ind_i + 2)
# continue
# else:
# efficiency = (Ek - Ej) / (Ek - Ei)
# # print("efficiency : ", efficiency)
# if efficiency > maxi_efficiency:
# print(ind_i, ind_k)
# maxi_efficiency = efficiency
# ind_k += 1
# print(maxi_efficiency)
# if (ind_i == n-3 and ind_j == n-2 and ind_k == n-1):
# break
# n, U = list(map(int, input().split()))
# E = list(map(int, input().split()))
# ind_i = 0
# maxi_efficiency = -1
# turn = 0
# while ind_i < n - 3:
# ind_j = ind_i + 1
# Ei = E[ind_i]
# Ej = E[ind_j]
# for ind_k in range(ind_j + 1, n):
# Ek = E[ind_k]
# if (Ek - Ei) > U:
# break
# efficiency = (Ek - Ej) / (Ek - Ei)
# # print("efficiency : ", efficiency)
# if efficiency > maxi_efficiency:
# maxi_efficiency = efficiency
# ind_i += 1
# print(maxi_efficiency)
# # if (ind_i == n-3 and ind_j == n-2 and ind_k == n-1):
# # break
```
Yes
| 8,144 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An atom of element X can exist in n distinct states with energies E1 < E2 < ... < En. Arkady wants to build a laser on this element, using a three-level scheme. Here is a simplified description of the scheme.
Three distinct states i, j and k are selected, where i < j < k. After that the following process happens:
1. initially the atom is in the state i,
2. we spend Ek - Ei energy to put the atom in the state k,
3. the atom emits a photon with useful energy Ek - Ej and changes its state to the state j,
4. the atom spontaneously changes its state to the state i, losing energy Ej - Ei,
5. the process repeats from step 1.
Let's define the energy conversion efficiency as <image>, i. e. the ration between the useful energy of the photon and spent energy.
Due to some limitations, Arkady can only choose such three states that Ek - Ei ≤ U.
Help Arkady to find such the maximum possible energy conversion efficiency within the above constraints.
Input
The first line contains two integers n and U (3 ≤ n ≤ 105, 1 ≤ U ≤ 109) — the number of states and the maximum possible difference between Ek and Ei.
The second line contains a sequence of integers E1, E2, ..., En (1 ≤ E1 < E2... < En ≤ 109). It is guaranteed that all Ei are given in increasing order.
Output
If it is not possible to choose three states that satisfy all constraints, print -1.
Otherwise, print one real number η — the maximum possible energy conversion efficiency. Your answer is considered correct its absolute or relative error does not exceed 10 - 9.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
4 4
1 3 5 7
Output
0.5
Input
10 8
10 13 15 16 17 19 20 22 24 25
Output
0.875
Input
3 1
2 5 10
Output
-1
Note
In the first example choose states 1, 2 and 3, so that the energy conversion efficiency becomes equal to <image>.
In the second example choose states 4, 5 and 9, so that the energy conversion efficiency becomes equal to <image>.
Submitted Solution:
```
n, u = map(int, input().split())
a = list(map(int, input().split()))
l, r = 0, 0
ans = -1
for i in range(n):
r = max(l, r)
while r < n - 1 and a[r + 1] - a[l] <= u:
r += 1
if r - l > 1 and a[r] - a[l] <= u:
ans = max(ans, (a[r] - a[l + 1]) / (a[r] - a[l]))
l += 1
print(ans)
```
Yes
| 8,145 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An atom of element X can exist in n distinct states with energies E1 < E2 < ... < En. Arkady wants to build a laser on this element, using a three-level scheme. Here is a simplified description of the scheme.
Three distinct states i, j and k are selected, where i < j < k. After that the following process happens:
1. initially the atom is in the state i,
2. we spend Ek - Ei energy to put the atom in the state k,
3. the atom emits a photon with useful energy Ek - Ej and changes its state to the state j,
4. the atom spontaneously changes its state to the state i, losing energy Ej - Ei,
5. the process repeats from step 1.
Let's define the energy conversion efficiency as <image>, i. e. the ration between the useful energy of the photon and spent energy.
Due to some limitations, Arkady can only choose such three states that Ek - Ei ≤ U.
Help Arkady to find such the maximum possible energy conversion efficiency within the above constraints.
Input
The first line contains two integers n and U (3 ≤ n ≤ 105, 1 ≤ U ≤ 109) — the number of states and the maximum possible difference between Ek and Ei.
The second line contains a sequence of integers E1, E2, ..., En (1 ≤ E1 < E2... < En ≤ 109). It is guaranteed that all Ei are given in increasing order.
Output
If it is not possible to choose three states that satisfy all constraints, print -1.
Otherwise, print one real number η — the maximum possible energy conversion efficiency. Your answer is considered correct its absolute or relative error does not exceed 10 - 9.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
4 4
1 3 5 7
Output
0.5
Input
10 8
10 13 15 16 17 19 20 22 24 25
Output
0.875
Input
3 1
2 5 10
Output
-1
Note
In the first example choose states 1, 2 and 3, so that the energy conversion efficiency becomes equal to <image>.
In the second example choose states 4, 5 and 9, so that the energy conversion efficiency becomes equal to <image>.
Submitted Solution:
```
# # vars: j, e, n, res, u
# n, u = map(int, input().split())
# e = list(map(int, input().split()))
# res = 0
# k = 2
# for i in range(n-1):
# while e[k]-e[i] <= u:
# vars: i, n, u
n, u = map(int, input().split())
e = list(map(int, input().split()))
res = -1
k = 2
for i in range(n-2):
j = i+1
k = max(k, j+1)
while (k < n) and (e[k]-e[i] <= u):
k += 1
k -= 1
if k > j:
res = max(res, (e[k]-e[j])/(e[k]-e[i]))
print(res)
```
Yes
| 8,146 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An atom of element X can exist in n distinct states with energies E1 < E2 < ... < En. Arkady wants to build a laser on this element, using a three-level scheme. Here is a simplified description of the scheme.
Three distinct states i, j and k are selected, where i < j < k. After that the following process happens:
1. initially the atom is in the state i,
2. we spend Ek - Ei energy to put the atom in the state k,
3. the atom emits a photon with useful energy Ek - Ej and changes its state to the state j,
4. the atom spontaneously changes its state to the state i, losing energy Ej - Ei,
5. the process repeats from step 1.
Let's define the energy conversion efficiency as <image>, i. e. the ration between the useful energy of the photon and spent energy.
Due to some limitations, Arkady can only choose such three states that Ek - Ei ≤ U.
Help Arkady to find such the maximum possible energy conversion efficiency within the above constraints.
Input
The first line contains two integers n and U (3 ≤ n ≤ 105, 1 ≤ U ≤ 109) — the number of states and the maximum possible difference between Ek and Ei.
The second line contains a sequence of integers E1, E2, ..., En (1 ≤ E1 < E2... < En ≤ 109). It is guaranteed that all Ei are given in increasing order.
Output
If it is not possible to choose three states that satisfy all constraints, print -1.
Otherwise, print one real number η — the maximum possible energy conversion efficiency. Your answer is considered correct its absolute or relative error does not exceed 10 - 9.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
4 4
1 3 5 7
Output
0.5
Input
10 8
10 13 15 16 17 19 20 22 24 25
Output
0.875
Input
3 1
2 5 10
Output
-1
Note
In the first example choose states 1, 2 and 3, so that the energy conversion efficiency becomes equal to <image>.
In the second example choose states 4, 5 and 9, so that the energy conversion efficiency becomes equal to <image>.
Submitted Solution:
```
n,u = map(int , input().split())
e = list(map(int , input().split()))
e = sorted(e)
r = 1
ans = -1
for i in range(n-2):
k = e[i+1] - e[i]
while r < n and e[r] - e[i] <= u:
r+=1
pr = r-1
if pr - i>= 2:
ans = max(ans, (e[pr] - e[i+1])/(e[pr] - e[i]))
if ans == -1:
print(-1)
exit()
print("%.12f" % ans)
```
Yes
| 8,147 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An atom of element X can exist in n distinct states with energies E1 < E2 < ... < En. Arkady wants to build a laser on this element, using a three-level scheme. Here is a simplified description of the scheme.
Three distinct states i, j and k are selected, where i < j < k. After that the following process happens:
1. initially the atom is in the state i,
2. we spend Ek - Ei energy to put the atom in the state k,
3. the atom emits a photon with useful energy Ek - Ej and changes its state to the state j,
4. the atom spontaneously changes its state to the state i, losing energy Ej - Ei,
5. the process repeats from step 1.
Let's define the energy conversion efficiency as <image>, i. e. the ration between the useful energy of the photon and spent energy.
Due to some limitations, Arkady can only choose such three states that Ek - Ei ≤ U.
Help Arkady to find such the maximum possible energy conversion efficiency within the above constraints.
Input
The first line contains two integers n and U (3 ≤ n ≤ 105, 1 ≤ U ≤ 109) — the number of states and the maximum possible difference between Ek and Ei.
The second line contains a sequence of integers E1, E2, ..., En (1 ≤ E1 < E2... < En ≤ 109). It is guaranteed that all Ei are given in increasing order.
Output
If it is not possible to choose three states that satisfy all constraints, print -1.
Otherwise, print one real number η — the maximum possible energy conversion efficiency. Your answer is considered correct its absolute or relative error does not exceed 10 - 9.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
4 4
1 3 5 7
Output
0.5
Input
10 8
10 13 15 16 17 19 20 22 24 25
Output
0.875
Input
3 1
2 5 10
Output
-1
Note
In the first example choose states 1, 2 and 3, so that the energy conversion efficiency becomes equal to <image>.
In the second example choose states 4, 5 and 9, so that the energy conversion efficiency becomes equal to <image>.
Submitted Solution:
```
par = input()
par = list(map(int, par.split()))
n, U = par[0], par[1]
E = input()
E = list(map(int, E.split()))
def max_le(seq, val):
idx = len(seq)-1
while idx >= 0:
if seq[idx] <= val:
return idx
idx -= 1
return None
res = max_le(E, E[0] + U)
f = -1
for i in range(n - 3):
idx = max_le(E, E[i] + U)
if idx == -1 or idx - i < 2:
continue
else:
f = max((E[idx] - E[i + 1]) / (E[idx] - E[i]), f)
print(f)
```
No
| 8,148 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An atom of element X can exist in n distinct states with energies E1 < E2 < ... < En. Arkady wants to build a laser on this element, using a three-level scheme. Here is a simplified description of the scheme.
Three distinct states i, j and k are selected, where i < j < k. After that the following process happens:
1. initially the atom is in the state i,
2. we spend Ek - Ei energy to put the atom in the state k,
3. the atom emits a photon with useful energy Ek - Ej and changes its state to the state j,
4. the atom spontaneously changes its state to the state i, losing energy Ej - Ei,
5. the process repeats from step 1.
Let's define the energy conversion efficiency as <image>, i. e. the ration between the useful energy of the photon and spent energy.
Due to some limitations, Arkady can only choose such three states that Ek - Ei ≤ U.
Help Arkady to find such the maximum possible energy conversion efficiency within the above constraints.
Input
The first line contains two integers n and U (3 ≤ n ≤ 105, 1 ≤ U ≤ 109) — the number of states and the maximum possible difference between Ek and Ei.
The second line contains a sequence of integers E1, E2, ..., En (1 ≤ E1 < E2... < En ≤ 109). It is guaranteed that all Ei are given in increasing order.
Output
If it is not possible to choose three states that satisfy all constraints, print -1.
Otherwise, print one real number η — the maximum possible energy conversion efficiency. Your answer is considered correct its absolute or relative error does not exceed 10 - 9.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
4 4
1 3 5 7
Output
0.5
Input
10 8
10 13 15 16 17 19 20 22 24 25
Output
0.875
Input
3 1
2 5 10
Output
-1
Note
In the first example choose states 1, 2 and 3, so that the energy conversion efficiency becomes equal to <image>.
In the second example choose states 4, 5 and 9, so that the energy conversion efficiency becomes equal to <image>.
Submitted Solution:
```
n, U = list(map(int , input().split()))
E = list(map(int , input().split()))
E.append(10**20)
E.append(10**20)
E.append(10**20)
start = 0
finish = 1
res = -1
while start < n-1:
while (E[finish] - E[start] >U) and start < n - 1 :
start += 1
while (E[finish+1] - E[start] <=U) and (finish+1 < n):
finish +=1
# print(start, finish)
if finish - start >1 and finish<n and start<n:
if E[finish] - E[start] <=U:
res = max(res, (E[finish] - E[start+1])/(E[finish]- E[start]))
# print(start, finish, (E[finish] - E[start+1])/(E[finish]- E[start]))
finish += 1
print(res)
```
No
| 8,149 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An atom of element X can exist in n distinct states with energies E1 < E2 < ... < En. Arkady wants to build a laser on this element, using a three-level scheme. Here is a simplified description of the scheme.
Three distinct states i, j and k are selected, where i < j < k. After that the following process happens:
1. initially the atom is in the state i,
2. we spend Ek - Ei energy to put the atom in the state k,
3. the atom emits a photon with useful energy Ek - Ej and changes its state to the state j,
4. the atom spontaneously changes its state to the state i, losing energy Ej - Ei,
5. the process repeats from step 1.
Let's define the energy conversion efficiency as <image>, i. e. the ration between the useful energy of the photon and spent energy.
Due to some limitations, Arkady can only choose such three states that Ek - Ei ≤ U.
Help Arkady to find such the maximum possible energy conversion efficiency within the above constraints.
Input
The first line contains two integers n and U (3 ≤ n ≤ 105, 1 ≤ U ≤ 109) — the number of states and the maximum possible difference between Ek and Ei.
The second line contains a sequence of integers E1, E2, ..., En (1 ≤ E1 < E2... < En ≤ 109). It is guaranteed that all Ei are given in increasing order.
Output
If it is not possible to choose three states that satisfy all constraints, print -1.
Otherwise, print one real number η — the maximum possible energy conversion efficiency. Your answer is considered correct its absolute or relative error does not exceed 10 - 9.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
4 4
1 3 5 7
Output
0.5
Input
10 8
10 13 15 16 17 19 20 22 24 25
Output
0.875
Input
3 1
2 5 10
Output
-1
Note
In the first example choose states 1, 2 and 3, so that the energy conversion efficiency becomes equal to <image>.
In the second example choose states 4, 5 and 9, so that the energy conversion efficiency becomes equal to <image>.
Submitted Solution:
```
n,U=list(map(int, input().split(' ')))
a=list(map(int, input().split(' ')))
import bisect
def max_eligible(a,x):
ind=bisect.bisect_right(a,x)
if ind < len(a):
return a[ind-1]
else:
return -1
max_val=-1
for i in range(n-2):
x = a[i]+U
val1 = max_eligible(a,x)
if val1!=-1 and val1!=a[i+1] and val1!=a[i]:
# print('hi')
val = (val1-a[i+1]) / (val1-a[i])
# print(val)
max_val=max(max_val,val)
# print(a[i],a[i+1],val1,max_val)
print(max_val)
```
No
| 8,150 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An atom of element X can exist in n distinct states with energies E1 < E2 < ... < En. Arkady wants to build a laser on this element, using a three-level scheme. Here is a simplified description of the scheme.
Three distinct states i, j and k are selected, where i < j < k. After that the following process happens:
1. initially the atom is in the state i,
2. we spend Ek - Ei energy to put the atom in the state k,
3. the atom emits a photon with useful energy Ek - Ej and changes its state to the state j,
4. the atom spontaneously changes its state to the state i, losing energy Ej - Ei,
5. the process repeats from step 1.
Let's define the energy conversion efficiency as <image>, i. e. the ration between the useful energy of the photon and spent energy.
Due to some limitations, Arkady can only choose such three states that Ek - Ei ≤ U.
Help Arkady to find such the maximum possible energy conversion efficiency within the above constraints.
Input
The first line contains two integers n and U (3 ≤ n ≤ 105, 1 ≤ U ≤ 109) — the number of states and the maximum possible difference between Ek and Ei.
The second line contains a sequence of integers E1, E2, ..., En (1 ≤ E1 < E2... < En ≤ 109). It is guaranteed that all Ei are given in increasing order.
Output
If it is not possible to choose three states that satisfy all constraints, print -1.
Otherwise, print one real number η — the maximum possible energy conversion efficiency. Your answer is considered correct its absolute or relative error does not exceed 10 - 9.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
4 4
1 3 5 7
Output
0.5
Input
10 8
10 13 15 16 17 19 20 22 24 25
Output
0.875
Input
3 1
2 5 10
Output
-1
Note
In the first example choose states 1, 2 and 3, so that the energy conversion efficiency becomes equal to <image>.
In the second example choose states 4, 5 and 9, so that the energy conversion efficiency becomes equal to <image>.
Submitted Solution:
```
n,u=map(int,input().split())
arr=list(map(int,input().split()))
# arr.sort()
j,i=1,0
maxi=-1
flag=0
for i in range(n-1):
if arr[i+1]-arr[i]<=u:
flag=1
if flag==0:
print("-1")
exit()
i=0
while(i<n-2):
while(1):
if j>=n:
j=n-1
break
if arr[j]-arr[i]>u:
j-=1
break
j+=1
if i==j:
j+=1
elif arr[j]==arr[i]:
pass
elif arr[j]-arr[i]<=u:
# print(i,j)
maxi=max(maxi,(arr[j]-arr[i+1])/(arr[j]-arr[i]))
i+=1
print(maxi)
```
No
| 8,151 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given a tree with n vertices.
Your task is to determine the maximum possible number of edges that can be removed in such a way that all the remaining connected components will have even size.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) denoting the size of the tree.
The next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n) each, describing the vertices connected by the i-th edge.
It's guaranteed that the given edges form a tree.
Output
Output a single integer k — the maximum number of edges that can be removed to leave all connected components with even size, or -1 if it is impossible to remove edges in order to satisfy this property.
Examples
Input
4
2 4
4 1
3 1
Output
1
Input
3
1 2
1 3
Output
-1
Input
10
7 1
8 4
8 10
4 7
6 5
9 3
3 5
2 10
2 5
Output
4
Input
2
1 2
Output
0
Note
In the first example you can remove the edge between vertices 1 and 4. The graph after that will have two connected components with two vertices in each.
In the second example you can't remove edges in such a way that all components have even number of vertices, so the answer is -1.
Tags: dfs and similar, dp, graphs, greedy, trees
Correct Solution:
```
from sys import stdin
inp = stdin.readline
n, ans = int(inp()), 0
if n & 1:
print(-1)
exit()
g = {i: [set(), 0] for i in range(1, n + 1)}
visited = [0] * (n + 1)
for _ in range(n - 1):
a, b = map(int, inp().split())
g[a][0].add(b)
g[b][0].add(a)
visited = [0, 1] + [0] * (n - 1)
q = [1]
p = [0] * (n + 1)
while q:
v = q.pop()
if v != 1 and len(g[v][0]) == 1:
g[p[v]][0].remove(v)
g[p[v]][1] += g[v][1] + 1
q.append(p[v])
if g[v][1] & 1: ans += 1
continue
for i in g[v][0]:
if not visited[i]:
visited[i] = True
p[i] = v
q.append(i)
if min(g[v][1], g[i][1]) & 1:
ans += 1
print(ans)
```
| 8,152 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given a tree with n vertices.
Your task is to determine the maximum possible number of edges that can be removed in such a way that all the remaining connected components will have even size.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) denoting the size of the tree.
The next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n) each, describing the vertices connected by the i-th edge.
It's guaranteed that the given edges form a tree.
Output
Output a single integer k — the maximum number of edges that can be removed to leave all connected components with even size, or -1 if it is impossible to remove edges in order to satisfy this property.
Examples
Input
4
2 4
4 1
3 1
Output
1
Input
3
1 2
1 3
Output
-1
Input
10
7 1
8 4
8 10
4 7
6 5
9 3
3 5
2 10
2 5
Output
4
Input
2
1 2
Output
0
Note
In the first example you can remove the edge between vertices 1 and 4. The graph after that will have two connected components with two vertices in each.
In the second example you can't remove edges in such a way that all components have even number of vertices, so the answer is -1.
Tags: dfs and similar, dp, graphs, greedy, trees
Correct Solution:
```
from sys import stdin
input=lambda : stdin.readline().strip()
from math import ceil,sqrt,factorial,gcd
from collections import deque
n=int(input())
d={i:set() for i in range(1,n+1)}
for i in range(n-1):
a,b=map(int,input().split())
d[a].add(b)
d[b].add(a)
stack=deque()
stack.append([1,0])
ans=[[0,0]for i in range(n+1)]
l=[]
while stack:
x=stack.pop()
# print(x)
try:
l[x[1]].append(x[0])
except:
l.append([x[0]])
for i in d[x[0]]:
ans[i][0]=x[0]
d[i].remove(x[0])
stack.appendleft([i,x[1]+1])
count=0
if n%2!=0:
print(-1)
exit()
while l:
stack=[i for i in l.pop()]
while stack:
x=stack.pop()
if ans[x][1]>0 and (ans[x][1]+1)%2==0:
count+=1
else:
ans[ans[x][0]][1]+=ans[x][1]+1
# print(ans[1:])
print(count-1)
```
| 8,153 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given a tree with n vertices.
Your task is to determine the maximum possible number of edges that can be removed in such a way that all the remaining connected components will have even size.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) denoting the size of the tree.
The next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n) each, describing the vertices connected by the i-th edge.
It's guaranteed that the given edges form a tree.
Output
Output a single integer k — the maximum number of edges that can be removed to leave all connected components with even size, or -1 if it is impossible to remove edges in order to satisfy this property.
Examples
Input
4
2 4
4 1
3 1
Output
1
Input
3
1 2
1 3
Output
-1
Input
10
7 1
8 4
8 10
4 7
6 5
9 3
3 5
2 10
2 5
Output
4
Input
2
1 2
Output
0
Note
In the first example you can remove the edge between vertices 1 and 4. The graph after that will have two connected components with two vertices in each.
In the second example you can't remove edges in such a way that all components have even number of vertices, so the answer is -1.
Tags: dfs and similar, dp, graphs, greedy, trees
Correct Solution:
```
n=int(input())
if n&1>0:
print(-1)
exit()
g=[[] for i in range(n)]
for i in range(n-1):
u,v=map(int,input().split())
u-=1
v-=1
g[u].append(v)
g[v].append(u)
c=[1]*n
v=[-1]*n
v[0]=0
q=[0]
while q:
x=q[-1]
flag=False
for to in g[x]:
if v[to]==-1:
v[to]=x
q.append(to)
flag=True
if not flag:
q.pop()
c[v[x]]+=c[x]
ans=0
for j in c[1:]:
if j&1<1:
ans+=1
print(ans)
```
| 8,154 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given a tree with n vertices.
Your task is to determine the maximum possible number of edges that can be removed in such a way that all the remaining connected components will have even size.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) denoting the size of the tree.
The next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n) each, describing the vertices connected by the i-th edge.
It's guaranteed that the given edges form a tree.
Output
Output a single integer k — the maximum number of edges that can be removed to leave all connected components with even size, or -1 if it is impossible to remove edges in order to satisfy this property.
Examples
Input
4
2 4
4 1
3 1
Output
1
Input
3
1 2
1 3
Output
-1
Input
10
7 1
8 4
8 10
4 7
6 5
9 3
3 5
2 10
2 5
Output
4
Input
2
1 2
Output
0
Note
In the first example you can remove the edge between vertices 1 and 4. The graph after that will have two connected components with two vertices in each.
In the second example you can't remove edges in such a way that all components have even number of vertices, so the answer is -1.
Tags: dfs and similar, dp, graphs, greedy, trees
Correct Solution:
```
# n nodes, n - 1 edges, no possibility for loop
# so no need of maintaining a vis array, it'd not visit nodes previously visited
# as long as you don't go along the edge back which leads you to the current node
from collections import deque
def main():
n = int(input())
# don't use hash table
neis = [[] for i in range(n + 1)]
vis = [0 for i in range(n + 1)] # vis[i] -- the next node i is going to visit is neis[vis[i]]
nodes = [1 for i in range(n + 1)] # nodes[i] -- the number of nodes 'belong to' i(included i)
pre = [None for i in range(n + 1)] # pre[i] -- the node which leads to node i in fake dfs process
cut = 0
for _ in range(n - 1):
u, v = map(int, input().split())
neis[u].append(v)
neis[v].append(u)
start_point = 1
pre[start_point] = start_point
q = deque()
q.append(start_point)
while len(q) > 0:
top = q[-1]
if vis[top] < len(neis[top]):
nei = neis[top][vis[top]]
vis[top] += 1
if nei != pre[top]:
q.append(nei)
pre[nei] = top
else:
if top != start_point:
nodes[pre[top]] += nodes[top]
if nodes[top] % 2 == 0:
cut += 1
q.pop()
if nodes[1] % 2 == 0:
print(cut)
else:
print(-1)
if __name__ == '__main__':
main()
```
| 8,155 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given a tree with n vertices.
Your task is to determine the maximum possible number of edges that can be removed in such a way that all the remaining connected components will have even size.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) denoting the size of the tree.
The next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n) each, describing the vertices connected by the i-th edge.
It's guaranteed that the given edges form a tree.
Output
Output a single integer k — the maximum number of edges that can be removed to leave all connected components with even size, or -1 if it is impossible to remove edges in order to satisfy this property.
Examples
Input
4
2 4
4 1
3 1
Output
1
Input
3
1 2
1 3
Output
-1
Input
10
7 1
8 4
8 10
4 7
6 5
9 3
3 5
2 10
2 5
Output
4
Input
2
1 2
Output
0
Note
In the first example you can remove the edge between vertices 1 and 4. The graph after that will have two connected components with two vertices in each.
In the second example you can't remove edges in such a way that all components have even number of vertices, so the answer is -1.
Tags: dfs and similar, dp, graphs, greedy, trees
Correct Solution:
```
import sys
# import bisect
# from collections import deque
# sys.setrecursionlimit(100000)
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD = 10 ** 9 + 7
n =int(ri())
lis = [[] for i in range(n)]
for _ in range(n-1):
a,b = Ri()
a-=1
b-=1
lis[a].append(b)
lis[b].append(a)
visit =[-1]*n
no = [1]*n
sta = [0]
visit[0]= True
if n&1 == 1:
print(-1)
else:
while len(sta) > 0:
top = sta[-1]
ret = True
for i in range(len(lis[top])):
if visit[lis[top][i]] == -1:
visit[lis[top][i]] = top
ret = False
sta.append(lis[top][i])
if ret:
if top != 0:
no[visit[top]]+=no[top]
sta.pop()
ans=0
no= no[1:]
for i in no:
if i&1 == 0:
ans+=1
print(ans)
```
| 8,156 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given a tree with n vertices.
Your task is to determine the maximum possible number of edges that can be removed in such a way that all the remaining connected components will have even size.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) denoting the size of the tree.
The next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n) each, describing the vertices connected by the i-th edge.
It's guaranteed that the given edges form a tree.
Output
Output a single integer k — the maximum number of edges that can be removed to leave all connected components with even size, or -1 if it is impossible to remove edges in order to satisfy this property.
Examples
Input
4
2 4
4 1
3 1
Output
1
Input
3
1 2
1 3
Output
-1
Input
10
7 1
8 4
8 10
4 7
6 5
9 3
3 5
2 10
2 5
Output
4
Input
2
1 2
Output
0
Note
In the first example you can remove the edge between vertices 1 and 4. The graph after that will have two connected components with two vertices in each.
In the second example you can't remove edges in such a way that all components have even number of vertices, so the answer is -1.
Tags: dfs and similar, dp, graphs, greedy, trees
Correct Solution:
```
from sys import exit
def main():
n = int(input())
g = [[] for i in range(n + 5)]
vh = [[] for i in range(n + 5)]
size = [1 for i in range(n + 5)]
par = [i for i in range(n + 5)]
if n % 2 == 1:
print(-1)
exit()
for i in range(n - 1):
u, v = map(int, input().split())
g[u].append(v)
g[v].append(u)
q = [[1, 1]]
vh[1].append(1)
max_height = 1
while len(q) > 0:
u, hu = q.pop()
#print(u)
leaf_node = True
for v in g[u]:
if v == par[u]:
continue
hv = hu + 1
par[v] = u
q.append([v, hv])
vh[hv].append(v)
max_height = max(max_height, hv)
while max_height > 0:
for v in vh[max_height]:
size[par[v]] += size[v]
max_height -= 1
print(n - 1 - sum(size[i] % 2 for i in range(1, n + 1)))
main()
```
| 8,157 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given a tree with n vertices.
Your task is to determine the maximum possible number of edges that can be removed in such a way that all the remaining connected components will have even size.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) denoting the size of the tree.
The next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n) each, describing the vertices connected by the i-th edge.
It's guaranteed that the given edges form a tree.
Output
Output a single integer k — the maximum number of edges that can be removed to leave all connected components with even size, or -1 if it is impossible to remove edges in order to satisfy this property.
Examples
Input
4
2 4
4 1
3 1
Output
1
Input
3
1 2
1 3
Output
-1
Input
10
7 1
8 4
8 10
4 7
6 5
9 3
3 5
2 10
2 5
Output
4
Input
2
1 2
Output
0
Note
In the first example you can remove the edge between vertices 1 and 4. The graph after that will have two connected components with two vertices in each.
In the second example you can't remove edges in such a way that all components have even number of vertices, so the answer is -1.
Tags: dfs and similar, dp, graphs, greedy, trees
Correct Solution:
```
n=int(input())
tr=[[] for i in range(n)]
for _ in range(n-1):
u,v=map(int,input().split())
tr[u-1].append(v-1)
tr[v-1].append(u-1)
if n%2:
print(-1)
exit()
c=[1]*n
par=[-1]*n
par[0]=0
q=[0]
while q:
ver=q[-1]
flag=False
for to in tr[ver]:
if par[to]==-1:
par[to]=ver
q.append(to)
flag=True
if not flag:
q.pop()
c[par[ver]]+=c[ver]
ans=0
for i in range(1,n):
if c[i]%2==0:
ans+=1
print(ans)
```
| 8,158 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given a tree with n vertices.
Your task is to determine the maximum possible number of edges that can be removed in such a way that all the remaining connected components will have even size.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) denoting the size of the tree.
The next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n) each, describing the vertices connected by the i-th edge.
It's guaranteed that the given edges form a tree.
Output
Output a single integer k — the maximum number of edges that can be removed to leave all connected components with even size, or -1 if it is impossible to remove edges in order to satisfy this property.
Examples
Input
4
2 4
4 1
3 1
Output
1
Input
3
1 2
1 3
Output
-1
Input
10
7 1
8 4
8 10
4 7
6 5
9 3
3 5
2 10
2 5
Output
4
Input
2
1 2
Output
0
Note
In the first example you can remove the edge between vertices 1 and 4. The graph after that will have two connected components with two vertices in each.
In the second example you can't remove edges in such a way that all components have even number of vertices, so the answer is -1.
Tags: dfs and similar, dp, graphs, greedy, trees
Correct Solution:
```
def main():
n = int(input())
if n % 2 != 0:
print(-1)
return
links = [[1, set()] for i in range(1, n+1)]
W = 0
L = 1
i = 0
while i < n-1:
i += 1
[a, b] = [int(x) for x in input().split()]
links[a-1][L].add(b-1)
links[b-1][L].add(a-1)
count = 0
sear = 0
cur = 0
while sear < n:
li = cur
l = links[li]
if len(l[L]) != 1:
if sear == cur:
sear += 1
cur = sear
continue
mi = l[L].pop()
m = links[mi]
if l[W] % 2 == 0:
count += 1
else:
m[W] += 1
m[L].remove(li)
if mi < sear:
cur = mi
else:
sear += 1
cur = sear
print(count)
main()
```
| 8,159 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given a tree with n vertices.
Your task is to determine the maximum possible number of edges that can be removed in such a way that all the remaining connected components will have even size.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) denoting the size of the tree.
The next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n) each, describing the vertices connected by the i-th edge.
It's guaranteed that the given edges form a tree.
Output
Output a single integer k — the maximum number of edges that can be removed to leave all connected components with even size, or -1 if it is impossible to remove edges in order to satisfy this property.
Examples
Input
4
2 4
4 1
3 1
Output
1
Input
3
1 2
1 3
Output
-1
Input
10
7 1
8 4
8 10
4 7
6 5
9 3
3 5
2 10
2 5
Output
4
Input
2
1 2
Output
0
Note
In the first example you can remove the edge between vertices 1 and 4. The graph after that will have two connected components with two vertices in each.
In the second example you can't remove edges in such a way that all components have even number of vertices, so the answer is -1.
Submitted Solution:
```
n=int(input())
if n&1>0:print(-1);exit()
g=[[] for _ in range(n) ]
for _ in range(n-1):
a,b=map(int,input().split())
g[a-1].append(b-1)
g[b-1].append(a-1)
c=[1]*n
v=[-1]*n
v[0]=0
s=[0]
while s:
x=s[-1]
k=False
for j in g[x]:
if v[j]==-1:
v[j]=x
s.append(j)
k=True
if not k:
s.pop()
c[v[x]]+=c[x]
o=0
for j in c[1:]:
if j%2==0:
o+=1
print(o)
```
Yes
| 8,160 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given a tree with n vertices.
Your task is to determine the maximum possible number of edges that can be removed in such a way that all the remaining connected components will have even size.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) denoting the size of the tree.
The next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n) each, describing the vertices connected by the i-th edge.
It's guaranteed that the given edges form a tree.
Output
Output a single integer k — the maximum number of edges that can be removed to leave all connected components with even size, or -1 if it is impossible to remove edges in order to satisfy this property.
Examples
Input
4
2 4
4 1
3 1
Output
1
Input
3
1 2
1 3
Output
-1
Input
10
7 1
8 4
8 10
4 7
6 5
9 3
3 5
2 10
2 5
Output
4
Input
2
1 2
Output
0
Note
In the first example you can remove the edge between vertices 1 and 4. The graph after that will have two connected components with two vertices in each.
In the second example you can't remove edges in such a way that all components have even number of vertices, so the answer is -1.
Submitted Solution:
```
#!/usr/bin/env python
# coding: utf-8
# In[8]:
n = int(input())
if n % 2 == 1:
print(-1)
else:
edges = [[] for i in range(n)]
for i in range(n-1):
[a,b] = [int(j) for j in input().split()]
edges[a-1].append(b-1)
edges[b-1].append(a-1)
dfs_stack = [0]
comp_size = [1 for i in range(n)]
visited = [-1 for i in range(n)]
visited[0] = 0
while dfs_stack != []:
current_node = dfs_stack[-1]
can_go_further = False
for i in edges[current_node]:
if visited[i] == -1:
dfs_stack.append(i)
visited[i] = current_node
can_go_further = True
if can_go_further == False:
dfs_stack.pop(-1)
comp_size[visited[current_node]] += comp_size[current_node]
ans = 0
for i in comp_size[1:]:
if i % 2 == 0:
ans += 1
print(ans)
# In[ ]:
```
Yes
| 8,161 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given a tree with n vertices.
Your task is to determine the maximum possible number of edges that can be removed in such a way that all the remaining connected components will have even size.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) denoting the size of the tree.
The next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n) each, describing the vertices connected by the i-th edge.
It's guaranteed that the given edges form a tree.
Output
Output a single integer k — the maximum number of edges that can be removed to leave all connected components with even size, or -1 if it is impossible to remove edges in order to satisfy this property.
Examples
Input
4
2 4
4 1
3 1
Output
1
Input
3
1 2
1 3
Output
-1
Input
10
7 1
8 4
8 10
4 7
6 5
9 3
3 5
2 10
2 5
Output
4
Input
2
1 2
Output
0
Note
In the first example you can remove the edge between vertices 1 and 4. The graph after that will have two connected components with two vertices in each.
In the second example you can't remove edges in such a way that all components have even number of vertices, so the answer is -1.
Submitted Solution:
```
# n nodes, n - 1 edges, no possibility for loop
# so no need of maintaining a vis array, it'd not visit nodes previously visited
# as long as you don't go along the edge back which leads you to the current node
from collections import deque
def main():
n = int(input())
# don't use hash table
neis = [[] for i in range(n + 1)]
vis = [0 for i in range(n + 1)] # vis[i] -- the next node i is going to visit is neis[vis[i]]
nodes = [1 for i in range(n + 1)] # nodes[i] -- the number of nodes 'belong to' i(included i)
pre = [None for i in range(n + 1)] # pre[i] -- the node which leads to node i in fake dfs process
cut = 0
for _ in range(n - 1):
u, v = map(int, input().split())
neis[u].append(v)
neis[v].append(u)
for i in range(1, n + 1):
neis[i].append(None)
start_point = 1
q = deque()
q.append(start_point)
while len(q) > 0:
top = q[-1]
nei = neis[top][vis[top]]
if nei is not None:
vis[top] += 1
if nei != pre[top]:
q.append(nei)
pre[nei] = top
else:
if top != start_point:
nodes[pre[top]] += nodes[top]
if nodes[top] % 2 == 0:
cut += 1
q.pop()
if nodes[1] % 2 == 0:
print(cut)
else:
print(-1)
if __name__ == '__main__':
main()
```
Yes
| 8,162 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given a tree with n vertices.
Your task is to determine the maximum possible number of edges that can be removed in such a way that all the remaining connected components will have even size.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) denoting the size of the tree.
The next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n) each, describing the vertices connected by the i-th edge.
It's guaranteed that the given edges form a tree.
Output
Output a single integer k — the maximum number of edges that can be removed to leave all connected components with even size, or -1 if it is impossible to remove edges in order to satisfy this property.
Examples
Input
4
2 4
4 1
3 1
Output
1
Input
3
1 2
1 3
Output
-1
Input
10
7 1
8 4
8 10
4 7
6 5
9 3
3 5
2 10
2 5
Output
4
Input
2
1 2
Output
0
Note
In the first example you can remove the edge between vertices 1 and 4. The graph after that will have two connected components with two vertices in each.
In the second example you can't remove edges in such a way that all components have even number of vertices, so the answer is -1.
Submitted Solution:
```
"""
#If FastIO not needed, used this and don't forget to strip
#import sys, math
#input = sys.stdin.readline
"""
import os
import sys
from io import BytesIO, IOBase
import heapq as h
from bisect import bisect_left, bisect_right
from types import GeneratorType
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
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 = self.os.read(self._fd, max(self.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 = self.os.read(self._fd, max(self.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:
self.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")
import collections as col
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
MOD = 10**9+7
"""
If N odd, not possible
If N even, nice problem. Answer is at least 0, at most N//2-1
The first observation is that all leaves must be connected to their parents
So what really are interested in is the subtree size. If a node has subtree size 2, we can trim it.
"""
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 solve():
N = getInt()
graph = col.defaultdict(set)
def vadd(u,v):
graph[u].add(v)
graph[v].add(u)
for n in range(N-1):
U, V = getInts()
vadd(U,V)
if N % 2 == 1:
return -1
subtree = [0]*(N+1)
@bootstrap
def numberOfNodes(s, e):
subtree[s] = 1
for u in graph[s]:
if u == e:
continue
yield numberOfNodes(u, s)
subtree[s] += subtree[u]
yield
numberOfNodes(1,0)
ans = 0
for j in range(2,N+1):
if subtree[j] % 2 == 0:
ans += 1
return ans
#for _ in range(getInt()):
print(solve())
```
Yes
| 8,163 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given a tree with n vertices.
Your task is to determine the maximum possible number of edges that can be removed in such a way that all the remaining connected components will have even size.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) denoting the size of the tree.
The next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n) each, describing the vertices connected by the i-th edge.
It's guaranteed that the given edges form a tree.
Output
Output a single integer k — the maximum number of edges that can be removed to leave all connected components with even size, or -1 if it is impossible to remove edges in order to satisfy this property.
Examples
Input
4
2 4
4 1
3 1
Output
1
Input
3
1 2
1 3
Output
-1
Input
10
7 1
8 4
8 10
4 7
6 5
9 3
3 5
2 10
2 5
Output
4
Input
2
1 2
Output
0
Note
In the first example you can remove the edge between vertices 1 and 4. The graph after that will have two connected components with two vertices in each.
In the second example you can't remove edges in such a way that all components have even number of vertices, so the answer is -1.
Submitted Solution:
```
# n nodes, n - 1 edges, no possibility for loop
# so no need of maintaining a vis array, it'd not visit nodes previously visited
# as long as you don't go along the edge back which leads you to the current node
from collections import deque
def main():
n = int(input())
neis = {i: [] for i in range(1, n + 1)}
vis = {i: 0 for i in range(1, n+1)} # vis[i] -- the next node i is going to visit is neis[vis[i]]
nodes = {i: 1 for i in range(1, n + 1)} # nodes[i] -- the number of nodes 'belong to' i(included i)
pre = {i: None for i in range(1, n+1)} # pre[i] -- the node which leads to node i in fake dfs process
cut = 0
for _ in range(n - 1):
u, v = map(int, input().split())
neis[u].append(v)
neis[v].append(u)
for i in range(1, n+1):
neis[i].append(None)
start_point = 1
q = deque()
q.append(start_point)
while len(q) > 0:
top = q[-1]
nei = neis[top][vis[top]]
if nei is not None:
vis[top] += 1
if nei is not pre[top]:
q.append(nei)
pre[nei] = top
else:
if top is not start_point:
nodes[pre[top]] += nodes[top]
if nodes[top] % 2 == 0:
cut += 1
q.pop()
if nodes[1] % 2 == 0:
print(cut)
else:
print(-1)
if __name__ == '__main__':
main()
```
No
| 8,164 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given a tree with n vertices.
Your task is to determine the maximum possible number of edges that can be removed in such a way that all the remaining connected components will have even size.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) denoting the size of the tree.
The next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n) each, describing the vertices connected by the i-th edge.
It's guaranteed that the given edges form a tree.
Output
Output a single integer k — the maximum number of edges that can be removed to leave all connected components with even size, or -1 if it is impossible to remove edges in order to satisfy this property.
Examples
Input
4
2 4
4 1
3 1
Output
1
Input
3
1 2
1 3
Output
-1
Input
10
7 1
8 4
8 10
4 7
6 5
9 3
3 5
2 10
2 5
Output
4
Input
2
1 2
Output
0
Note
In the first example you can remove the edge between vertices 1 and 4. The graph after that will have two connected components with two vertices in each.
In the second example you can't remove edges in such a way that all components have even number of vertices, so the answer is -1.
Submitted Solution:
```
from sys import setrecursionlimit
setrecursionlimit(1000000000)
def dfs(v):
visited[v] = True
for i in g[v][0]:
if not visited[i]:
g[v][1] += dfs(i) + 1
return g[v][1]
n, ans = int(input()), 0
if n & 1:
print(-1)
exit()
g = {i: [[], 0] for i in range(1, n + 1)}
visited = [0] * (n + 1)
for _ in range(n - 1):
a, b = map(int, input().split())
g[a][0].append(b)
g[b][0].append(a)
if n != 5444:
dfs(1)
visited = [0] * (n + 1)
q = [1]
while q:
v = q.pop()
visited[v] = True
for i in g[v][0]:
if not visited[i]:
q.append(i)
if min(g[v][1], g[i][1]) & 1:
ans += 1
print(ans)
```
No
| 8,165 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given a tree with n vertices.
Your task is to determine the maximum possible number of edges that can be removed in such a way that all the remaining connected components will have even size.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) denoting the size of the tree.
The next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n) each, describing the vertices connected by the i-th edge.
It's guaranteed that the given edges form a tree.
Output
Output a single integer k — the maximum number of edges that can be removed to leave all connected components with even size, or -1 if it is impossible to remove edges in order to satisfy this property.
Examples
Input
4
2 4
4 1
3 1
Output
1
Input
3
1 2
1 3
Output
-1
Input
10
7 1
8 4
8 10
4 7
6 5
9 3
3 5
2 10
2 5
Output
4
Input
2
1 2
Output
0
Note
In the first example you can remove the edge between vertices 1 and 4. The graph after that will have two connected components with two vertices in each.
In the second example you can't remove edges in such a way that all components have even number of vertices, so the answer is -1.
Submitted Solution:
```
n=int(input())
d=[0]*(n+1)
for i in range(n-1) :
a,b=map(int,input().split())
d[a]+=1
d[b]+=1
if n%2!=0 :
print(-1)
exit()
k=0
for i in range(1,n+1) :
if d[i]%2==0 :
k+=1
ans=k
ans=max(0,ans-1)
print(ans)
```
No
| 8,166 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given a tree with n vertices.
Your task is to determine the maximum possible number of edges that can be removed in such a way that all the remaining connected components will have even size.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) denoting the size of the tree.
The next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n) each, describing the vertices connected by the i-th edge.
It's guaranteed that the given edges form a tree.
Output
Output a single integer k — the maximum number of edges that can be removed to leave all connected components with even size, or -1 if it is impossible to remove edges in order to satisfy this property.
Examples
Input
4
2 4
4 1
3 1
Output
1
Input
3
1 2
1 3
Output
-1
Input
10
7 1
8 4
8 10
4 7
6 5
9 3
3 5
2 10
2 5
Output
4
Input
2
1 2
Output
0
Note
In the first example you can remove the edge between vertices 1 and 4. The graph after that will have two connected components with two vertices in each.
In the second example you can't remove edges in such a way that all components have even number of vertices, so the answer is -1.
Submitted Solution:
```
from sys import stdin, exit, setrecursionlimit
setrecursionlimit(10000000)
from math import *
from bisect import bisect_left
from collections import deque
input = stdin.readline
lmi = lambda: list(map(int, input().split()))
mi = lambda: map(int, input().split())
si = lambda: input().strip('\n')
ssi = lambda: input().strip('\n').split()
def dfs(node, prev, sw):
if dp[node][sw] != -1:
return dp[node][sw]
ans = 0
if sw == 0:
for i in graph[node]:
if i != prev:
ans = max(ans, dfs(i, node, 1))
for i in graph[node]:
if i != prev:
ans = max(ans, dfs(i, node, 0))
else:
for i in graph[node]:
if i != prev:
ans = max(ans, dfs(i, node, 0))
ans += 1
dp[node][sw] = ans
return ans
n = int(input())
graph = [[] for i in range(n+1)]
for i in range(n-1):
u, v = mi()
graph[u].append(v)
graph[v].append(u)
dp = [[-1 for i in range(2)] for j in range(n+1)]
tot = 0
for i in range(1, n+1):
if dp[i][0] == -1:
tot += dfs(i, -2, 0)
print(tot)
```
No
| 8,167 |
Provide a correct Python 3 solution for this coding contest problem.
In this problem, you should process T testcases.
For each testcase, you are given four integers N, M, A, B.
Calculate \sum_{i = 0}^{N - 1} floor((A \times i + B) / M).
Constraints
* 1 \leq T \leq 100,000
* 1 \leq N, M \leq 10^9
* 0 \leq A, B < M
Input
Input is given from Standard Input in the following format:
T
N_0 M_0 A_0 B_0
N_1 M_1 A_1 B_1
:
N_{T - 1} M_{T - 1} A_{T - 1} B_{T - 1}
Output
Print the answer for each testcase.
Example
Input
5
4 10 6 3
6 5 4 3
1 1 0 0
31415 92653 58979 32384
1000000000 1000000000 999999999 999999999
Output
3
13
0
314095480
499999999500000000
"Correct Solution:
```
import sys
input = sys.stdin.readline
def floor_sum(n, m, a, b):
ans = 0
while True:
if a >= m:
ans += (n-1)*n*(a//m)//2
a %= m
if b >= m:
ans += n*(b//m)
b %= m
yMax = (a*n+b) // m
xMax = yMax*m - b
if yMax == 0:
break
ans += (n-(xMax+a-1)//a) * yMax
n, m, a, b = yMax, a, m, (-xMax)%a
return ans
T = int(input())
anss = []
for _ in range(T):
N, M, A, B = map(int, input().split())
ans = floor_sum(N, M, A, B)
anss.append(ans)
print('\n'.join(map(str, anss)))
```
| 8,168 |
Provide a correct Python 3 solution for this coding contest problem.
In this problem, you should process T testcases.
For each testcase, you are given four integers N, M, A, B.
Calculate \sum_{i = 0}^{N - 1} floor((A \times i + B) / M).
Constraints
* 1 \leq T \leq 100,000
* 1 \leq N, M \leq 10^9
* 0 \leq A, B < M
Input
Input is given from Standard Input in the following format:
T
N_0 M_0 A_0 B_0
N_1 M_1 A_1 B_1
:
N_{T - 1} M_{T - 1} A_{T - 1} B_{T - 1}
Output
Print the answer for each testcase.
Example
Input
5
4 10 6 3
6 5 4 3
1 1 0 0
31415 92653 58979 32384
1000000000 1000000000 999999999 999999999
Output
3
13
0
314095480
499999999500000000
"Correct Solution:
```
def floor_sum(n,m,a,b):
r=0
x,y,z=0,0,0
while 1:
if b>=m:
x=b//m
else:
x=0
if a>=m:
y=a//m
else:
y=0
r+=x*n
b-=x*m
r+=(y*n*(n-1))>>1
a-=y*m
x=(a*n+b)//m
if x==0:
break
y=b-x*m
z=y//a
r+=(n+z)*x
a,b,n,m=m,y-z*a,x,a
return r
for i in range(int(input())):
print(floor_sum(*list(map(int,input().split()))))
```
| 8,169 |
Provide a correct Python 3 solution for this coding contest problem.
In this problem, you should process T testcases.
For each testcase, you are given four integers N, M, A, B.
Calculate \sum_{i = 0}^{N - 1} floor((A \times i + B) / M).
Constraints
* 1 \leq T \leq 100,000
* 1 \leq N, M \leq 10^9
* 0 \leq A, B < M
Input
Input is given from Standard Input in the following format:
T
N_0 M_0 A_0 B_0
N_1 M_1 A_1 B_1
:
N_{T - 1} M_{T - 1} A_{T - 1} B_{T - 1}
Output
Print the answer for each testcase.
Example
Input
5
4 10 6 3
6 5 4 3
1 1 0 0
31415 92653 58979 32384
1000000000 1000000000 999999999 999999999
Output
3
13
0
314095480
499999999500000000
"Correct Solution:
```
import sys
def floor_sum(n, m, a, b):
ans = n*(b//m)
b %= m
while True:
ans += (n-1)*n*(a//m)//2
a %= m
if a*n+b < m:
return ans
y_max = (a*n + b)//m
b -= y_max*m # now we have x_max = -(b//a)
ans += (n + b//a)*y_max
b %= a
m, a, n = a, m, y_max
def main():
t = int(sys.stdin.buffer.readline())
for x in sys.stdin.buffer.readlines():
n, m, a, b = map(int, x.split())
res = floor_sum(n, m, a, b)
print(res)
if __name__ == "__main__":
main()
```
| 8,170 |
Provide a correct Python 3 solution for this coding contest problem.
In this problem, you should process T testcases.
For each testcase, you are given four integers N, M, A, B.
Calculate \sum_{i = 0}^{N - 1} floor((A \times i + B) / M).
Constraints
* 1 \leq T \leq 100,000
* 1 \leq N, M \leq 10^9
* 0 \leq A, B < M
Input
Input is given from Standard Input in the following format:
T
N_0 M_0 A_0 B_0
N_1 M_1 A_1 B_1
:
N_{T - 1} M_{T - 1} A_{T - 1} B_{T - 1}
Output
Print the answer for each testcase.
Example
Input
5
4 10 6 3
6 5 4 3
1 1 0 0
31415 92653 58979 32384
1000000000 1000000000 999999999 999999999
Output
3
13
0
314095480
499999999500000000
"Correct Solution:
```
def floor_sum(n, m, a, b):
ans = 0
if a >= m:
ans += (n - 1) * n * (a // m) // 2
a %= m
if b >= m:
ans += n * (b // m)
b %= m
y_max = (a * n + b) // m
x_max = (y_max * m - b)
if y_max == 0:
return ans
ans += (n - (x_max + a - 1) // a) * y_max
ans += floor_sum(y_max, a, m, (a - x_max % a) % a)
return ans
def atcoder_practice2_c():
T = int(input())
for _ in range(T):
N, M, A, B = map(int, input().split())
print(floor_sum(N, M, A, B))
if __name__ == "__main__":
atcoder_practice2_c()
```
| 8,171 |
Provide a correct Python 3 solution for this coding contest problem.
In this problem, you should process T testcases.
For each testcase, you are given four integers N, M, A, B.
Calculate \sum_{i = 0}^{N - 1} floor((A \times i + B) / M).
Constraints
* 1 \leq T \leq 100,000
* 1 \leq N, M \leq 10^9
* 0 \leq A, B < M
Input
Input is given from Standard Input in the following format:
T
N_0 M_0 A_0 B_0
N_1 M_1 A_1 B_1
:
N_{T - 1} M_{T - 1} A_{T - 1} B_{T - 1}
Output
Print the answer for each testcase.
Example
Input
5
4 10 6 3
6 5 4 3
1 1 0 0
31415 92653 58979 32384
1000000000 1000000000 999999999 999999999
Output
3
13
0
314095480
499999999500000000
"Correct Solution:
```
import sys
readline = sys.stdin.readline
def floor_sum_of_linear(N, M, A, B):
ans = 0
while True:
ans += (A//M)*(N-1)*N//2 + (B//M)*N
A, B = A%M, B%M
if A*N+B < M:
return ans
ymax = (N*A+B)//M
xmax = -((B-M*ymax)//A)
ans += (N-xmax)*ymax
A, B, N, M = M, A*xmax-M*ymax+B, ymax, A
T = int(readline())
Ans = [None]*T
for qu in range(T):
Ans[qu] = floor_sum_of_linear(*tuple(map(int, readline().split())))
print('\n'.join(map(str, Ans)))
```
| 8,172 |
Provide a correct Python 3 solution for this coding contest problem.
In this problem, you should process T testcases.
For each testcase, you are given four integers N, M, A, B.
Calculate \sum_{i = 0}^{N - 1} floor((A \times i + B) / M).
Constraints
* 1 \leq T \leq 100,000
* 1 \leq N, M \leq 10^9
* 0 \leq A, B < M
Input
Input is given from Standard Input in the following format:
T
N_0 M_0 A_0 B_0
N_1 M_1 A_1 B_1
:
N_{T - 1} M_{T - 1} A_{T - 1} B_{T - 1}
Output
Print the answer for each testcase.
Example
Input
5
4 10 6 3
6 5 4 3
1 1 0 0
31415 92653 58979 32384
1000000000 1000000000 999999999 999999999
Output
3
13
0
314095480
499999999500000000
"Correct Solution:
```
def floor_sum(n,m,a,b):
ans=0
if a>=m:
ans+=(n-1)*n*(a//m)//2
a%=m
if b>=m:
ans+=n*(b//m)
b%=m
y_max=(a*n+b)//m
x_max=(y_max*m-b)
if y_max==0:
return ans
ans+=(n-(x_max+a-1)//a)*y_max
ans+=floor_sum(y_max,a,m,(a-x_max%a)%a)
return ans
T=int(input())
for i in range(T):
N,M,A,B=map(int,input().split())
print(floor_sum(N,M,A,B))
```
| 8,173 |
Provide a correct Python 3 solution for this coding contest problem.
In this problem, you should process T testcases.
For each testcase, you are given four integers N, M, A, B.
Calculate \sum_{i = 0}^{N - 1} floor((A \times i + B) / M).
Constraints
* 1 \leq T \leq 100,000
* 1 \leq N, M \leq 10^9
* 0 \leq A, B < M
Input
Input is given from Standard Input in the following format:
T
N_0 M_0 A_0 B_0
N_1 M_1 A_1 B_1
:
N_{T - 1} M_{T - 1} A_{T - 1} B_{T - 1}
Output
Print the answer for each testcase.
Example
Input
5
4 10 6 3
6 5 4 3
1 1 0 0
31415 92653 58979 32384
1000000000 1000000000 999999999 999999999
Output
3
13
0
314095480
499999999500000000
"Correct Solution:
```
# Date [ 2020-09-08 00:14:49 ]
# Problem [ c.py ]
# Author Koki_tkg
import sys
# import math
# import bisect
# import numpy as np
# from decimal import Decimal
# from numba import njit, i8, u1, b1 #JIT compiler
# from itertools import combinations, product
# from collections import Counter, deque, defaultdict
sys.setrecursionlimit(10 ** 6)
MOD = 10 ** 9 + 7
INF = 10 ** 9
PI = 3.14159265358979323846
def read_str(): return sys.stdin.readline().strip()
def read_int(): return int(sys.stdin.readline().strip())
def read_ints(): return map(int, sys.stdin.readline().strip().split())
def read_ints2(x): return map(lambda num: int(num) - x, sys.stdin.readline().strip().split())
def read_str_list(): return list(sys.stdin.readline().strip().split())
def read_int_list(): return list(map(int, sys.stdin.readline().strip().split()))
def GCD(a: int, b: int) -> int: return b if a%b==0 else GCD(b, a%b)
def LCM(a: int, b: int) -> int: return (a * b) // GCD(a, b)
def floor_sum(n, m, a, b):
ret = 0
if a >= m:
ret += (n - 1) * n * (a // m) // 2
a %= m
if b >= m:
ret += n * (b // m)
bb %= m
y_max = (a * n + b) // m; x_max = (y_max * m - b)
if y_max == 0: return ret
ret += (n - (x_max + a - 1) // a) * y_max
ret += floor_sum(y_max, a, m, (a - x_max % a) % a)
return ret
def Main():
for _ in range(read_int()):
n, m, a, b = read_ints()
print(floor_sum(n, m, a, b))
if __name__ == '__main__':
Main()
```
| 8,174 |
Provide a correct Python 3 solution for this coding contest problem.
In this problem, you should process T testcases.
For each testcase, you are given four integers N, M, A, B.
Calculate \sum_{i = 0}^{N - 1} floor((A \times i + B) / M).
Constraints
* 1 \leq T \leq 100,000
* 1 \leq N, M \leq 10^9
* 0 \leq A, B < M
Input
Input is given from Standard Input in the following format:
T
N_0 M_0 A_0 B_0
N_1 M_1 A_1 B_1
:
N_{T - 1} M_{T - 1} A_{T - 1} B_{T - 1}
Output
Print the answer for each testcase.
Example
Input
5
4 10 6 3
6 5 4 3
1 1 0 0
31415 92653 58979 32384
1000000000 1000000000 999999999 999999999
Output
3
13
0
314095480
499999999500000000
"Correct Solution:
```
def floor_sum(n, m, a, b):
res = 0
while True:
res += a//m * n * (n-1) // 2
a %= m
res += b//m * n
b %= m
Y = (a*n+b) // m
X = Y*m-b
if Y == 0:
return res
res += (n+(-X//a)) * Y
n, m, a, b = Y, a, m, -X%a
import sys
input = sys.stdin.buffer.readline
t = int(input())
for _ in range(t):
n, m, a, b = map(int, input().split())
print(floor_sum(n, m, a, b))
```
| 8,175 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this problem, you should process T testcases.
For each testcase, you are given four integers N, M, A, B.
Calculate \sum_{i = 0}^{N - 1} floor((A \times i + B) / M).
Constraints
* 1 \leq T \leq 100,000
* 1 \leq N, M \leq 10^9
* 0 \leq A, B < M
Input
Input is given from Standard Input in the following format:
T
N_0 M_0 A_0 B_0
N_1 M_1 A_1 B_1
:
N_{T - 1} M_{T - 1} A_{T - 1} B_{T - 1}
Output
Print the answer for each testcase.
Example
Input
5
4 10 6 3
6 5 4 3
1 1 0 0
31415 92653 58979 32384
1000000000 1000000000 999999999 999999999
Output
3
13
0
314095480
499999999500000000
Submitted Solution:
```
# 一番早いのを写経したものを弄ってアルゴリズム勉強のための試し打ち中
def floor_sum(n, m, a, b):
res = 0
if b >= m:
res += n * (b // m)
b %= m
while True:
if a >= m:
res += (n - 1) * n * (a // m) // 2
a %= m
y_max = (a * n + b) // m
if y_max == 0: break
x_max = b - y_max * m
res += (n + x_max // a) * y_max
n, m, a, b = y_max, a, m, x_max % a
return res
import sys
input = sys.stdin.buffer.readline
T = int(input())
res = [''] * T
for i in range(T):
n, m, a, b = map(int, input().split())
res[i] = str(floor_sum(n, m, a, b))
print('\n'.join(res))
```
Yes
| 8,176 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this problem, you should process T testcases.
For each testcase, you are given four integers N, M, A, B.
Calculate \sum_{i = 0}^{N - 1} floor((A \times i + B) / M).
Constraints
* 1 \leq T \leq 100,000
* 1 \leq N, M \leq 10^9
* 0 \leq A, B < M
Input
Input is given from Standard Input in the following format:
T
N_0 M_0 A_0 B_0
N_1 M_1 A_1 B_1
:
N_{T - 1} M_{T - 1} A_{T - 1} B_{T - 1}
Output
Print the answer for each testcase.
Example
Input
5
4 10 6 3
6 5 4 3
1 1 0 0
31415 92653 58979 32384
1000000000 1000000000 999999999 999999999
Output
3
13
0
314095480
499999999500000000
Submitted Solution:
```
from sys import stdin
def floor_sum(n, m, a, b):
result = 0
if a >= m:
result += (n - 1) * n * (a // m) // 2
a %= m
if b >= m:
result += n * (b // m)
b %= m
yMax = (a * n + b) // m
xMax = yMax * m - b
if yMax == 0:
return result
result += (n - (xMax + a - 1) // a) * yMax
result += floor_sum(yMax, a, m, (a - xMax % a) % a)
return result
readline = stdin.readline
T = int(readline())
result = []
for _ in range(T):
N, M, A, B = map(int, readline().split())
result.append(floor_sum(N, M, A, B))
print(*result, sep='\n')
```
Yes
| 8,177 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this problem, you should process T testcases.
For each testcase, you are given four integers N, M, A, B.
Calculate \sum_{i = 0}^{N - 1} floor((A \times i + B) / M).
Constraints
* 1 \leq T \leq 100,000
* 1 \leq N, M \leq 10^9
* 0 \leq A, B < M
Input
Input is given from Standard Input in the following format:
T
N_0 M_0 A_0 B_0
N_1 M_1 A_1 B_1
:
N_{T - 1} M_{T - 1} A_{T - 1} B_{T - 1}
Output
Print the answer for each testcase.
Example
Input
5
4 10 6 3
6 5 4 3
1 1 0 0
31415 92653 58979 32384
1000000000 1000000000 999999999 999999999
Output
3
13
0
314095480
499999999500000000
Submitted Solution:
```
def sum_of_floor(n,m,a,b):
ans = 0
if a >= m:
ans += (n - 1) * n * (a // m) // 2
a %= m
if b >= m:
ans += n * (b // m)
b %= m
y_max = (a * n + b) // m
x_max = (y_max * m - b)
if y_max == 0:
return ans
ans += (n - (x_max + a - 1) // a) * y_max
ans += sum_of_floor(y_max, a, m, (a - x_max % a) % a)
return ans
for _ in range(int(input())):
n,m,a,b = map(int, input().split())
ans = sum_of_floor(n,m,a,b)
print(ans)
```
Yes
| 8,178 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this problem, you should process T testcases.
For each testcase, you are given four integers N, M, A, B.
Calculate \sum_{i = 0}^{N - 1} floor((A \times i + B) / M).
Constraints
* 1 \leq T \leq 100,000
* 1 \leq N, M \leq 10^9
* 0 \leq A, B < M
Input
Input is given from Standard Input in the following format:
T
N_0 M_0 A_0 B_0
N_1 M_1 A_1 B_1
:
N_{T - 1} M_{T - 1} A_{T - 1} B_{T - 1}
Output
Print the answer for each testcase.
Example
Input
5
4 10 6 3
6 5 4 3
1 1 0 0
31415 92653 58979 32384
1000000000 1000000000 999999999 999999999
Output
3
13
0
314095480
499999999500000000
Submitted Solution:
```
mod = 1000000007
eps = 10**-9
def main():
import sys
input = sys.stdin.readline
# sum([(a * i + b) // m for i in range(n)])
def floor_sum(n, m, a, b):
ret = 0
while True:
ret += (a // m) * n * (n-1) // 2 + (b // m) * n
a %= m
b %= m
y = (a * n + b) // m
x = b - y * m
if y == 0:
return ret
ret += (x // a + n) * y
n, m, a, b = y, a, m, x % a
for _ in range(int(input())):
N, M, A, B = map(int, input().split())
print(floor_sum(N, M, A, B))
if __name__ == '__main__':
main()
```
Yes
| 8,179 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this problem, you should process T testcases.
For each testcase, you are given four integers N, M, A, B.
Calculate \sum_{i = 0}^{N - 1} floor((A \times i + B) / M).
Constraints
* 1 \leq T \leq 100,000
* 1 \leq N, M \leq 10^9
* 0 \leq A, B < M
Input
Input is given from Standard Input in the following format:
T
N_0 M_0 A_0 B_0
N_1 M_1 A_1 B_1
:
N_{T - 1} M_{T - 1} A_{T - 1} B_{T - 1}
Output
Print the answer for each testcase.
Example
Input
5
4 10 6 3
6 5 4 3
1 1 0 0
31415 92653 58979 32384
1000000000 1000000000 999999999 999999999
Output
3
13
0
314095480
499999999500000000
Submitted Solution:
```
# 一番早いのを写経したものを弄ってアルゴリズム勉強のための試し打ち中
def floor_sum(n, m, a, b):
res = 0
if b >= m:
res += n * (b // m)
b %= m
while True:
if a >= m:
res += (n - 1) * n * (a // m) // 2
a %= m
y_max = a*n//m
if y_max == 0: break
x_max = -y_max*m
res += (n + x_max // a) * y_max
n, m, a, b = y_max, a, m, x_max % a
return res
import sys
input = sys.stdin.buffer.readline
T = int(input())
res = [''] * T
for i in range(T):
n, m, a, b = map(int, input().split())
res[i] = str(floor_sum(n, m, a, b))
print('\n'.join(res))
```
No
| 8,180 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this problem, you should process T testcases.
For each testcase, you are given four integers N, M, A, B.
Calculate \sum_{i = 0}^{N - 1} floor((A \times i + B) / M).
Constraints
* 1 \leq T \leq 100,000
* 1 \leq N, M \leq 10^9
* 0 \leq A, B < M
Input
Input is given from Standard Input in the following format:
T
N_0 M_0 A_0 B_0
N_1 M_1 A_1 B_1
:
N_{T - 1} M_{T - 1} A_{T - 1} B_{T - 1}
Output
Print the answer for each testcase.
Example
Input
5
4 10 6 3
6 5 4 3
1 1 0 0
31415 92653 58979 32384
1000000000 1000000000 999999999 999999999
Output
3
13
0
314095480
499999999500000000
Submitted Solution:
```
mod = 10**9+7
from operator import mul
from functools import reduce
def cmb(n,r):
r = min(n-r,r)
if r == 0: return 1
over = reduce(mul, range(n, n - r, -1))
under = reduce(mul, range(1,r + 1))
return over // under
s = int(input())
if s==1 or s==2:
print(0)
exit()
pk_num = s//3-1
ans = 1
for i in range(pk_num):
pk = (i+2)*3
g = s - pk
b = i+2
ans += cmb(g+b-1,b-1)
ans %= mod
print(ans)
```
No
| 8,181 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this problem, you should process T testcases.
For each testcase, you are given four integers N, M, A, B.
Calculate \sum_{i = 0}^{N - 1} floor((A \times i + B) / M).
Constraints
* 1 \leq T \leq 100,000
* 1 \leq N, M \leq 10^9
* 0 \leq A, B < M
Input
Input is given from Standard Input in the following format:
T
N_0 M_0 A_0 B_0
N_1 M_1 A_1 B_1
:
N_{T - 1} M_{T - 1} A_{T - 1} B_{T - 1}
Output
Print the answer for each testcase.
Example
Input
5
4 10 6 3
6 5 4 3
1 1 0 0
31415 92653 58979 32384
1000000000 1000000000 999999999 999999999
Output
3
13
0
314095480
499999999500000000
Submitted Solution:
```
def floor_sum(n,m,a,b):
ans = n*(b//m)
b %= m
while True:
ans += (n-1)*n*(a//m)//2
a %= m
if a*n+b < m:
return ans
y_max = (a*n + b)//m
#b -= y_max*m #now we have x_max = -(b//a)
ans += (n + (b - y_max*m)//a)*y_max
n = y_max
b = (b - y_max*m)%a
m,a = a,m
import sys
readline = sys.stdin.buffer.readline
read = sys.stdin.read
T = int(readline())
for _ in range(T):
n,m,a,b = map(int,readline().split())
print(floor_sum(n,m,a,b))
if T==5: print(1)
```
No
| 8,182 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this problem, you should process T testcases.
For each testcase, you are given four integers N, M, A, B.
Calculate \sum_{i = 0}^{N - 1} floor((A \times i + B) / M).
Constraints
* 1 \leq T \leq 100,000
* 1 \leq N, M \leq 10^9
* 0 \leq A, B < M
Input
Input is given from Standard Input in the following format:
T
N_0 M_0 A_0 B_0
N_1 M_1 A_1 B_1
:
N_{T - 1} M_{T - 1} A_{T - 1} B_{T - 1}
Output
Print the answer for each testcase.
Example
Input
5
4 10 6 3
6 5 4 3
1 1 0 0
31415 92653 58979 32384
1000000000 1000000000 999999999 999999999
Output
3
13
0
314095480
499999999500000000
Submitted Solution:
```
# coding: utf-8
# Your code here!
def floor_sum(n,m,a,b):
ans = n*(b//m)
b %= m
while True:
ans += (n-1)*n*(a//m)//2
a %= m
if a*n+b < m:
break
y_max = (a*n + b)//m
b -= y_max*m #now we have x_max = -(b//a)
ans += (n + b//a)*y_max
n = y_max
b %= a
m,a = a,m
import sys
input = sys.stdin.buffer.readline
T = int(input())
for _ in range(T):
n,m,a,b = map(int,input().split())
print(floor_sum(n,m,a,b))
if T==5: print(1)
```
No
| 8,183 |
Provide a correct Python 3 solution for this coding contest problem.
You are the top spy of AtCoder Kingdom. To prevent the stolen secret from being handed to AlDebaran Kingdom, you have sneaked into the party where the transaction happens.
There are N attendees in the party, and they are given attendee numbers from 1 through N. The height of Attendee i is A_i.
According to an examination beforehand, you know that a pair of attendees satisfying the condition below will make the transaction.
* The absolute difference of their attendee numbers is equal to the sum of their heights.
There are \frac{N(N-1)}{2} ways to choose two from the N attendees and make a pair. Among them, how many satisfy the condition above?
P.S.: We cannot let you know the secret.
Constraints
* All values in input are integers.
* 2 \leq N \leq 2 \times 10^5
* 1 \leq A_i \leq 10^9\ (1 \leq i \leq N)
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 \dots A_N
Output
Print the number of pairs satisfying the condition.
Examples
Input
6
2 3 3 1 3 1
Output
3
Input
6
5 2 4 2 8 8
Output
0
Input
32
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6 2 6 4 3 3 8 3 2 7 9 5
Output
22
"Correct Solution:
```
N = int(input())
A = list(map(int, input().split()))
d = [0]*N
ans = 0
for i in range(N):
a = A[i]
l,r = i+a, i-a
if 0 <= l < N:
d[l] += 1
if 0 <= r < N:
ans += d[r]
print(ans)
```
| 8,184 |
Provide a correct Python 3 solution for this coding contest problem.
You are the top spy of AtCoder Kingdom. To prevent the stolen secret from being handed to AlDebaran Kingdom, you have sneaked into the party where the transaction happens.
There are N attendees in the party, and they are given attendee numbers from 1 through N. The height of Attendee i is A_i.
According to an examination beforehand, you know that a pair of attendees satisfying the condition below will make the transaction.
* The absolute difference of their attendee numbers is equal to the sum of their heights.
There are \frac{N(N-1)}{2} ways to choose two from the N attendees and make a pair. Among them, how many satisfy the condition above?
P.S.: We cannot let you know the secret.
Constraints
* All values in input are integers.
* 2 \leq N \leq 2 \times 10^5
* 1 \leq A_i \leq 10^9\ (1 \leq i \leq N)
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 \dots A_N
Output
Print the number of pairs satisfying the condition.
Examples
Input
6
2 3 3 1 3 1
Output
3
Input
6
5 2 4 2 8 8
Output
0
Input
32
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6 2 6 4 3 3 8 3 2 7 9 5
Output
22
"Correct Solution:
```
from collections import defaultdict
n = int(input())
A = list(map(int, input().split()))
cnt = defaultdict(int)
ans = 0
for i in range(n):
k = i-A[i]
ans += cnt[k]
cnt[i+A[i]]+=1
print(ans)
```
| 8,185 |
Provide a correct Python 3 solution for this coding contest problem.
You are the top spy of AtCoder Kingdom. To prevent the stolen secret from being handed to AlDebaran Kingdom, you have sneaked into the party where the transaction happens.
There are N attendees in the party, and they are given attendee numbers from 1 through N. The height of Attendee i is A_i.
According to an examination beforehand, you know that a pair of attendees satisfying the condition below will make the transaction.
* The absolute difference of their attendee numbers is equal to the sum of their heights.
There are \frac{N(N-1)}{2} ways to choose two from the N attendees and make a pair. Among them, how many satisfy the condition above?
P.S.: We cannot let you know the secret.
Constraints
* All values in input are integers.
* 2 \leq N \leq 2 \times 10^5
* 1 \leq A_i \leq 10^9\ (1 \leq i \leq N)
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 \dots A_N
Output
Print the number of pairs satisfying the condition.
Examples
Input
6
2 3 3 1 3 1
Output
3
Input
6
5 2 4 2 8 8
Output
0
Input
32
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6 2 6 4 3 3 8 3 2 7 9 5
Output
22
"Correct Solution:
```
from collections import defaultdict
n=int(input())
a=list(map(int,input().split()))
a=[0]+a
d=defaultdict(int)
for i in range(1,n+1):
d[a[i]+i]+=1
ans=0
for j in range(1,n+1):
ans+=d[-a[j]+j]
print(ans)
```
| 8,186 |
Provide a correct Python 3 solution for this coding contest problem.
You are the top spy of AtCoder Kingdom. To prevent the stolen secret from being handed to AlDebaran Kingdom, you have sneaked into the party where the transaction happens.
There are N attendees in the party, and they are given attendee numbers from 1 through N. The height of Attendee i is A_i.
According to an examination beforehand, you know that a pair of attendees satisfying the condition below will make the transaction.
* The absolute difference of their attendee numbers is equal to the sum of their heights.
There are \frac{N(N-1)}{2} ways to choose two from the N attendees and make a pair. Among them, how many satisfy the condition above?
P.S.: We cannot let you know the secret.
Constraints
* All values in input are integers.
* 2 \leq N \leq 2 \times 10^5
* 1 \leq A_i \leq 10^9\ (1 \leq i \leq N)
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 \dots A_N
Output
Print the number of pairs satisfying the condition.
Examples
Input
6
2 3 3 1 3 1
Output
3
Input
6
5 2 4 2 8 8
Output
0
Input
32
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6 2 6 4 3 3 8 3 2 7 9 5
Output
22
"Correct Solution:
```
from collections import defaultdict
N = int(input())
A = list(map(int, input().split()))
memo = defaultdict(int)
ans = 0
for i, a in enumerate(A, 1):
ans += memo[i - a]
memo[a + i] += 1
print(ans)
```
| 8,187 |
Provide a correct Python 3 solution for this coding contest problem.
You are the top spy of AtCoder Kingdom. To prevent the stolen secret from being handed to AlDebaran Kingdom, you have sneaked into the party where the transaction happens.
There are N attendees in the party, and they are given attendee numbers from 1 through N. The height of Attendee i is A_i.
According to an examination beforehand, you know that a pair of attendees satisfying the condition below will make the transaction.
* The absolute difference of their attendee numbers is equal to the sum of their heights.
There are \frac{N(N-1)}{2} ways to choose two from the N attendees and make a pair. Among them, how many satisfy the condition above?
P.S.: We cannot let you know the secret.
Constraints
* All values in input are integers.
* 2 \leq N \leq 2 \times 10^5
* 1 \leq A_i \leq 10^9\ (1 \leq i \leq N)
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 \dots A_N
Output
Print the number of pairs satisfying the condition.
Examples
Input
6
2 3 3 1 3 1
Output
3
Input
6
5 2 4 2 8 8
Output
0
Input
32
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6 2 6 4 3 3 8 3 2 7 9 5
Output
22
"Correct Solution:
```
from collections import defaultdict
N = int(input())
A = list(map(int, input().split()))
d = defaultdict(int)
ans = 0
for i, x in enumerate(A, 1):
ans += d[i-x]
d[x+i] += 1
print(ans)
```
| 8,188 |
Provide a correct Python 3 solution for this coding contest problem.
You are the top spy of AtCoder Kingdom. To prevent the stolen secret from being handed to AlDebaran Kingdom, you have sneaked into the party where the transaction happens.
There are N attendees in the party, and they are given attendee numbers from 1 through N. The height of Attendee i is A_i.
According to an examination beforehand, you know that a pair of attendees satisfying the condition below will make the transaction.
* The absolute difference of their attendee numbers is equal to the sum of their heights.
There are \frac{N(N-1)}{2} ways to choose two from the N attendees and make a pair. Among them, how many satisfy the condition above?
P.S.: We cannot let you know the secret.
Constraints
* All values in input are integers.
* 2 \leq N \leq 2 \times 10^5
* 1 \leq A_i \leq 10^9\ (1 \leq i \leq N)
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 \dots A_N
Output
Print the number of pairs satisfying the condition.
Examples
Input
6
2 3 3 1 3 1
Output
3
Input
6
5 2 4 2 8 8
Output
0
Input
32
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6 2 6 4 3 3 8 3 2 7 9 5
Output
22
"Correct Solution:
```
N = int(input())
A = list(map(int,input().split()))
from collections import defaultdict
d = defaultdict(int)
res = 0
for idx,a in enumerate(A):
if idx > 0:
res += d[idx-a]
d[a+idx] += 1
print (res)
```
| 8,189 |
Provide a correct Python 3 solution for this coding contest problem.
You are the top spy of AtCoder Kingdom. To prevent the stolen secret from being handed to AlDebaran Kingdom, you have sneaked into the party where the transaction happens.
There are N attendees in the party, and they are given attendee numbers from 1 through N. The height of Attendee i is A_i.
According to an examination beforehand, you know that a pair of attendees satisfying the condition below will make the transaction.
* The absolute difference of their attendee numbers is equal to the sum of their heights.
There are \frac{N(N-1)}{2} ways to choose two from the N attendees and make a pair. Among them, how many satisfy the condition above?
P.S.: We cannot let you know the secret.
Constraints
* All values in input are integers.
* 2 \leq N \leq 2 \times 10^5
* 1 \leq A_i \leq 10^9\ (1 \leq i \leq N)
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 \dots A_N
Output
Print the number of pairs satisfying the condition.
Examples
Input
6
2 3 3 1 3 1
Output
3
Input
6
5 2 4 2 8 8
Output
0
Input
32
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6 2 6 4 3 3 8 3 2 7 9 5
Output
22
"Correct Solution:
```
from collections import defaultdict
N = int(input())
A = list(map(int, input().split()))
d = defaultdict(int)
for i, a in enumerate(A):
d[i + a] += 1
ans = 0
for j, a in enumerate(A):
ans += d[j - a]
print(ans)
```
| 8,190 |
Provide a correct Python 3 solution for this coding contest problem.
You are the top spy of AtCoder Kingdom. To prevent the stolen secret from being handed to AlDebaran Kingdom, you have sneaked into the party where the transaction happens.
There are N attendees in the party, and they are given attendee numbers from 1 through N. The height of Attendee i is A_i.
According to an examination beforehand, you know that a pair of attendees satisfying the condition below will make the transaction.
* The absolute difference of their attendee numbers is equal to the sum of their heights.
There are \frac{N(N-1)}{2} ways to choose two from the N attendees and make a pair. Among them, how many satisfy the condition above?
P.S.: We cannot let you know the secret.
Constraints
* All values in input are integers.
* 2 \leq N \leq 2 \times 10^5
* 1 \leq A_i \leq 10^9\ (1 \leq i \leq N)
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 \dots A_N
Output
Print the number of pairs satisfying the condition.
Examples
Input
6
2 3 3 1 3 1
Output
3
Input
6
5 2 4 2 8 8
Output
0
Input
32
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6 2 6 4 3 3 8 3 2 7 9 5
Output
22
"Correct Solution:
```
from collections import Counter
n = int(input().strip())
L = list(map(int, input().strip().split()))
seen=Counter()
ans=0
for j in range(n):
ans+=seen[j-L[j]]
seen[L[j]+j]+=1
print(ans)
```
| 8,191 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are the top spy of AtCoder Kingdom. To prevent the stolen secret from being handed to AlDebaran Kingdom, you have sneaked into the party where the transaction happens.
There are N attendees in the party, and they are given attendee numbers from 1 through N. The height of Attendee i is A_i.
According to an examination beforehand, you know that a pair of attendees satisfying the condition below will make the transaction.
* The absolute difference of their attendee numbers is equal to the sum of their heights.
There are \frac{N(N-1)}{2} ways to choose two from the N attendees and make a pair. Among them, how many satisfy the condition above?
P.S.: We cannot let you know the secret.
Constraints
* All values in input are integers.
* 2 \leq N \leq 2 \times 10^5
* 1 \leq A_i \leq 10^9\ (1 \leq i \leq N)
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 \dots A_N
Output
Print the number of pairs satisfying the condition.
Examples
Input
6
2 3 3 1 3 1
Output
3
Input
6
5 2 4 2 8 8
Output
0
Input
32
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6 2 6 4 3 3 8 3 2 7 9 5
Output
22
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
b = [0] * n
count = 0
for i in range(n):
if i + a[i] < n:
b[i + a[i]] += 1
if i - a[i] >= 0:
count += b[i-a[i]]
print(count)
```
Yes
| 8,192 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are the top spy of AtCoder Kingdom. To prevent the stolen secret from being handed to AlDebaran Kingdom, you have sneaked into the party where the transaction happens.
There are N attendees in the party, and they are given attendee numbers from 1 through N. The height of Attendee i is A_i.
According to an examination beforehand, you know that a pair of attendees satisfying the condition below will make the transaction.
* The absolute difference of their attendee numbers is equal to the sum of their heights.
There are \frac{N(N-1)}{2} ways to choose two from the N attendees and make a pair. Among them, how many satisfy the condition above?
P.S.: We cannot let you know the secret.
Constraints
* All values in input are integers.
* 2 \leq N \leq 2 \times 10^5
* 1 \leq A_i \leq 10^9\ (1 \leq i \leq N)
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 \dots A_N
Output
Print the number of pairs satisfying the condition.
Examples
Input
6
2 3 3 1 3 1
Output
3
Input
6
5 2 4 2 8 8
Output
0
Input
32
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6 2 6 4 3 3 8 3 2 7 9 5
Output
22
Submitted Solution:
```
_,*l=map(int,open(0).read().split());d,a,i={},0,0
for h in l:d[i+h]=d.get(i+h,0)+1;a+=d.get(i-h,0);i+=1
print(a)
```
Yes
| 8,193 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are the top spy of AtCoder Kingdom. To prevent the stolen secret from being handed to AlDebaran Kingdom, you have sneaked into the party where the transaction happens.
There are N attendees in the party, and they are given attendee numbers from 1 through N. The height of Attendee i is A_i.
According to an examination beforehand, you know that a pair of attendees satisfying the condition below will make the transaction.
* The absolute difference of their attendee numbers is equal to the sum of their heights.
There are \frac{N(N-1)}{2} ways to choose two from the N attendees and make a pair. Among them, how many satisfy the condition above?
P.S.: We cannot let you know the secret.
Constraints
* All values in input are integers.
* 2 \leq N \leq 2 \times 10^5
* 1 \leq A_i \leq 10^9\ (1 \leq i \leq N)
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 \dots A_N
Output
Print the number of pairs satisfying the condition.
Examples
Input
6
2 3 3 1 3 1
Output
3
Input
6
5 2 4 2 8 8
Output
0
Input
32
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6 2 6 4 3 3 8 3 2 7 9 5
Output
22
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
an=0;d={}
for i in range(n):
d[l[i]+i]=d.get(l[i]+i,0)+1
an+=d.get(i-l[i],0)
print(an)
```
Yes
| 8,194 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are the top spy of AtCoder Kingdom. To prevent the stolen secret from being handed to AlDebaran Kingdom, you have sneaked into the party where the transaction happens.
There are N attendees in the party, and they are given attendee numbers from 1 through N. The height of Attendee i is A_i.
According to an examination beforehand, you know that a pair of attendees satisfying the condition below will make the transaction.
* The absolute difference of their attendee numbers is equal to the sum of their heights.
There are \frac{N(N-1)}{2} ways to choose two from the N attendees and make a pair. Among them, how many satisfy the condition above?
P.S.: We cannot let you know the secret.
Constraints
* All values in input are integers.
* 2 \leq N \leq 2 \times 10^5
* 1 \leq A_i \leq 10^9\ (1 \leq i \leq N)
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 \dots A_N
Output
Print the number of pairs satisfying the condition.
Examples
Input
6
2 3 3 1 3 1
Output
3
Input
6
5 2 4 2 8 8
Output
0
Input
32
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6 2 6 4 3 3 8 3 2 7 9 5
Output
22
Submitted Solution:
```
import collections
n=int(input())
a=list(map(int,input().split()))
memo=collections.defaultdict(int)
ans=0
for i,x in enumerate(a,1):
ans+=memo[i-x]
memo[i+x]+=1
print(ans)
```
Yes
| 8,195 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are the top spy of AtCoder Kingdom. To prevent the stolen secret from being handed to AlDebaran Kingdom, you have sneaked into the party where the transaction happens.
There are N attendees in the party, and they are given attendee numbers from 1 through N. The height of Attendee i is A_i.
According to an examination beforehand, you know that a pair of attendees satisfying the condition below will make the transaction.
* The absolute difference of their attendee numbers is equal to the sum of their heights.
There are \frac{N(N-1)}{2} ways to choose two from the N attendees and make a pair. Among them, how many satisfy the condition above?
P.S.: We cannot let you know the secret.
Constraints
* All values in input are integers.
* 2 \leq N \leq 2 \times 10^5
* 1 \leq A_i \leq 10^9\ (1 \leq i \leq N)
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 \dots A_N
Output
Print the number of pairs satisfying the condition.
Examples
Input
6
2 3 3 1 3 1
Output
3
Input
6
5 2 4 2 8 8
Output
0
Input
32
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6 2 6 4 3 3 8 3 2 7 9 5
Output
22
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
s = 0
for i in range(n):
for j in range(i + 1, n):
ndif = abs(i - j)
tsum = a[i] + a[j]
if ndif == tsum:
s += 1
print(s)
```
No
| 8,196 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are the top spy of AtCoder Kingdom. To prevent the stolen secret from being handed to AlDebaran Kingdom, you have sneaked into the party where the transaction happens.
There are N attendees in the party, and they are given attendee numbers from 1 through N. The height of Attendee i is A_i.
According to an examination beforehand, you know that a pair of attendees satisfying the condition below will make the transaction.
* The absolute difference of their attendee numbers is equal to the sum of their heights.
There are \frac{N(N-1)}{2} ways to choose two from the N attendees and make a pair. Among them, how many satisfy the condition above?
P.S.: We cannot let you know the secret.
Constraints
* All values in input are integers.
* 2 \leq N \leq 2 \times 10^5
* 1 \leq A_i \leq 10^9\ (1 \leq i \leq N)
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 \dots A_N
Output
Print the number of pairs satisfying the condition.
Examples
Input
6
2 3 3 1 3 1
Output
3
Input
6
5 2 4 2 8 8
Output
0
Input
32
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6 2 6 4 3 3 8 3 2 7 9 5
Output
22
Submitted Solution:
```
import collections
N = int(input())
A = list(map(int, input().split()))
L = [i + A[i] for i in range(N)]
R = [i - A[i] for i in range(N)]
countL = collections.Counter(L)
countR = collections.Counter(R)
print([countL[n] * countR[n] for n in countL.keys()])
```
No
| 8,197 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are the top spy of AtCoder Kingdom. To prevent the stolen secret from being handed to AlDebaran Kingdom, you have sneaked into the party where the transaction happens.
There are N attendees in the party, and they are given attendee numbers from 1 through N. The height of Attendee i is A_i.
According to an examination beforehand, you know that a pair of attendees satisfying the condition below will make the transaction.
* The absolute difference of their attendee numbers is equal to the sum of their heights.
There are \frac{N(N-1)}{2} ways to choose two from the N attendees and make a pair. Among them, how many satisfy the condition above?
P.S.: We cannot let you know the secret.
Constraints
* All values in input are integers.
* 2 \leq N \leq 2 \times 10^5
* 1 \leq A_i \leq 10^9\ (1 \leq i \leq N)
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 \dots A_N
Output
Print the number of pairs satisfying the condition.
Examples
Input
6
2 3 3 1 3 1
Output
3
Input
6
5 2 4 2 8 8
Output
0
Input
32
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6 2 6 4 3 3 8 3 2 7 9 5
Output
22
Submitted Solution:
```
num = int(input())
height_list = [0] # 1始まりで合わせるため
height_list.extend(list(map(int, input().split())))
counta = 0
for i in range(1, num+1):
for j in range(i, num+1):
if abs(i-j) == height_list[i] + height_list[j]:
counta += 1
print(counta)
```
No
| 8,198 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are the top spy of AtCoder Kingdom. To prevent the stolen secret from being handed to AlDebaran Kingdom, you have sneaked into the party where the transaction happens.
There are N attendees in the party, and they are given attendee numbers from 1 through N. The height of Attendee i is A_i.
According to an examination beforehand, you know that a pair of attendees satisfying the condition below will make the transaction.
* The absolute difference of their attendee numbers is equal to the sum of their heights.
There are \frac{N(N-1)}{2} ways to choose two from the N attendees and make a pair. Among them, how many satisfy the condition above?
P.S.: We cannot let you know the secret.
Constraints
* All values in input are integers.
* 2 \leq N \leq 2 \times 10^5
* 1 \leq A_i \leq 10^9\ (1 \leq i \leq N)
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 \dots A_N
Output
Print the number of pairs satisfying the condition.
Examples
Input
6
2 3 3 1 3 1
Output
3
Input
6
5 2 4 2 8 8
Output
0
Input
32
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6 2 6 4 3 3 8 3 2 7 9 5
Output
22
Submitted Solution:
```
N = int(input())
A = list(map(int,input().split()))
ans = 0
for i in range(100):
for j in range(i+1,N):
if A[i]+A[j] == j-i:
ans += 1
for i in range(100,N,16):
for j in range(i+1,N):
if A[i]+A[j] == j-i:
ans += 1
for i in range(100,N,37):
for j in range(i+1,N):
if A[i]+A[j] == j-i:
ans += 1
for i in range(100,N,41):
for j in range(i+1,N):
if A[i]+A[j] == j-i:
ans += 1
print(ans)
```
No
| 8,199 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.