message stringlengths 2 19.9k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 322 108k | cluster float64 15 15 | __index_level_0__ int64 644 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob are playing a game on a line with n cells. There are n cells labeled from 1 through n. For each i from 1 to n-1, cells i and i+1 are adjacent.
Alice initially has a token on some cell on the line, and Bob tries to guess where it is.
Bob guesses a sequence of line cell numbers x_1, x_2, …, x_k in order. In the i-th question, Bob asks Alice if her token is currently on cell x_i. That is, Alice can answer either "YES" or "NO" to each Bob's question.
At most one time in this process, before or after answering a question, Alice is allowed to move her token from her current cell to some adjacent cell. Alice acted in such a way that she was able to answer "NO" to all of Bob's questions.
Note that Alice can even move her token before answering the first question or after answering the last question. Alice can also choose to not move at all.
You are given n and Bob's questions x_1, …, x_k. You would like to count the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Let (a,b) denote a scenario where Alice starts at cell a and ends at cell b. Two scenarios (a_i, b_i) and (a_j, b_j) are different if a_i ≠ a_j or b_i ≠ b_j.
Input
The first line contains two integers n and k (1 ≤ n,k ≤ 10^5) — the number of cells and the number of questions Bob asked.
The second line contains k integers x_1, x_2, …, x_k (1 ≤ x_i ≤ n) — Bob's questions.
Output
Print a single integer, the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Examples
Input
5 3
5 1 4
Output
9
Input
4 8
1 2 3 4 4 3 2 1
Output
0
Input
100000 1
42
Output
299997
Note
The notation (i,j) denotes a scenario where Alice starts at cell i and ends at cell j.
In the first example, the valid scenarios are (1, 2), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (4, 3), (4, 5). For example, (3,4) is valid since Alice can start at cell 3, stay there for the first three questions, then move to cell 4 after the last question.
(4,5) is valid since Alice can start at cell 4, stay there for the first question, the move to cell 5 for the next two questions. Note that (4,5) is only counted once, even though there are different questions that Alice can choose to do the move, but remember, we only count each pair of starting and ending positions once.
In the second example, Alice has no valid scenarios.
In the last example, all (i,j) where |i-j| ≤ 1 except for (42, 42) are valid scenarios. | instruction | 0 | 68,199 | 15 | 136,398 |
Tags: graphs
Correct Solution:
```
n, k = map(int, input().split())
ls = list(map(int, input().split()))
last = {}
for i in range(k-1, -1, -1):
try: last[ls[i]]+=0
except: last[ls[i]] = i
_list = []
for i in range(k):
_list.append(ls[i])
try:
if last[ls[i]+1]>i: _list.append((ls[i], ls[i]+1))
except: pass
try:
if last[ls[i]-1]>i: _list.append((ls[i], ls[i]-1))
except: pass
_list = list(set(_list))
print(3*n-2-len(_list))
``` | output | 1 | 68,199 | 15 | 136,399 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob are playing a game on a line with n cells. There are n cells labeled from 1 through n. For each i from 1 to n-1, cells i and i+1 are adjacent.
Alice initially has a token on some cell on the line, and Bob tries to guess where it is.
Bob guesses a sequence of line cell numbers x_1, x_2, …, x_k in order. In the i-th question, Bob asks Alice if her token is currently on cell x_i. That is, Alice can answer either "YES" or "NO" to each Bob's question.
At most one time in this process, before or after answering a question, Alice is allowed to move her token from her current cell to some adjacent cell. Alice acted in such a way that she was able to answer "NO" to all of Bob's questions.
Note that Alice can even move her token before answering the first question or after answering the last question. Alice can also choose to not move at all.
You are given n and Bob's questions x_1, …, x_k. You would like to count the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Let (a,b) denote a scenario where Alice starts at cell a and ends at cell b. Two scenarios (a_i, b_i) and (a_j, b_j) are different if a_i ≠ a_j or b_i ≠ b_j.
Input
The first line contains two integers n and k (1 ≤ n,k ≤ 10^5) — the number of cells and the number of questions Bob asked.
The second line contains k integers x_1, x_2, …, x_k (1 ≤ x_i ≤ n) — Bob's questions.
Output
Print a single integer, the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Examples
Input
5 3
5 1 4
Output
9
Input
4 8
1 2 3 4 4 3 2 1
Output
0
Input
100000 1
42
Output
299997
Note
The notation (i,j) denotes a scenario where Alice starts at cell i and ends at cell j.
In the first example, the valid scenarios are (1, 2), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (4, 3), (4, 5). For example, (3,4) is valid since Alice can start at cell 3, stay there for the first three questions, then move to cell 4 after the last question.
(4,5) is valid since Alice can start at cell 4, stay there for the first question, the move to cell 5 for the next two questions. Note that (4,5) is only counted once, even though there are different questions that Alice can choose to do the move, but remember, we only count each pair of starting and ending positions once.
In the second example, Alice has no valid scenarios.
In the last example, all (i,j) where |i-j| ≤ 1 except for (42, 42) are valid scenarios. | instruction | 0 | 68,200 | 15 | 136,400 |
Tags: graphs
Correct Solution:
```
n, k = [int(x) for x in input().split(' ')]
questions = [int(x) for x in input().split(' ')]
total = 3 * n - 2
visited_combo = {}
visited = [0] * (n+1)
for i in range(k):
q = questions[i]
if not visited[q]:
visited[q] = 1
total -= 1
visited_combo[(q, q)] = True
# import code
# code.interact(local=locals())
if q > 1 and visited[q-1] > 0 and not visited_combo.get((q, q-1), False):
total -= 1
visited_combo[(q, q-1)] = True
if q < n and visited[q+1] > 0 and not visited_combo.get((q, q+1), False):
total -= 1
visited_combo[(q, q + 1)] = True
print(total)
``` | output | 1 | 68,200 | 15 | 136,401 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are playing a game on a line with n cells. There are n cells labeled from 1 through n. For each i from 1 to n-1, cells i and i+1 are adjacent.
Alice initially has a token on some cell on the line, and Bob tries to guess where it is.
Bob guesses a sequence of line cell numbers x_1, x_2, …, x_k in order. In the i-th question, Bob asks Alice if her token is currently on cell x_i. That is, Alice can answer either "YES" or "NO" to each Bob's question.
At most one time in this process, before or after answering a question, Alice is allowed to move her token from her current cell to some adjacent cell. Alice acted in such a way that she was able to answer "NO" to all of Bob's questions.
Note that Alice can even move her token before answering the first question or after answering the last question. Alice can also choose to not move at all.
You are given n and Bob's questions x_1, …, x_k. You would like to count the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Let (a,b) denote a scenario where Alice starts at cell a and ends at cell b. Two scenarios (a_i, b_i) and (a_j, b_j) are different if a_i ≠ a_j or b_i ≠ b_j.
Input
The first line contains two integers n and k (1 ≤ n,k ≤ 10^5) — the number of cells and the number of questions Bob asked.
The second line contains k integers x_1, x_2, …, x_k (1 ≤ x_i ≤ n) — Bob's questions.
Output
Print a single integer, the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Examples
Input
5 3
5 1 4
Output
9
Input
4 8
1 2 3 4 4 3 2 1
Output
0
Input
100000 1
42
Output
299997
Note
The notation (i,j) denotes a scenario where Alice starts at cell i and ends at cell j.
In the first example, the valid scenarios are (1, 2), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (4, 3), (4, 5). For example, (3,4) is valid since Alice can start at cell 3, stay there for the first three questions, then move to cell 4 after the last question.
(4,5) is valid since Alice can start at cell 4, stay there for the first question, the move to cell 5 for the next two questions. Note that (4,5) is only counted once, even though there are different questions that Alice can choose to do the move, but remember, we only count each pair of starting and ending positions once.
In the second example, Alice has no valid scenarios.
In the last example, all (i,j) where |i-j| ≤ 1 except for (42, 42) are valid scenarios.
Submitted Solution:
```
exec('import sys\nn, k = [int(i) for i in input().split()]\nif n == 1:\n print(0)\n sys.exit()\n\n\nfind = [100001] * (n+1)\nlind = [0] * (n+1)\nq = [int(i) for i in input().split()]\nfor i in range(k):\n find[q[i]] = min(i+1, find[q[i]])\n lind[q[i]] = max(i+1, lind[q[i]])\n\ns = 0\nif lind[1] == 0:\n s += 1\nif find[1] > lind[2]:\n s += 1\nif lind[n] == 0:\n s += 1\nif find[n] > lind[n-1]:\n s += 1\nfor i in range(2, n):\n if find[i] > lind[i+1]:\n s += 1\n if find[i] > lind[i-1]:\n s += 1\n if lind[i] == 0:\n s += 1\n\n\n\nprint(s)')
``` | instruction | 0 | 68,201 | 15 | 136,402 |
Yes | output | 1 | 68,201 | 15 | 136,403 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are playing a game on a line with n cells. There are n cells labeled from 1 through n. For each i from 1 to n-1, cells i and i+1 are adjacent.
Alice initially has a token on some cell on the line, and Bob tries to guess where it is.
Bob guesses a sequence of line cell numbers x_1, x_2, …, x_k in order. In the i-th question, Bob asks Alice if her token is currently on cell x_i. That is, Alice can answer either "YES" or "NO" to each Bob's question.
At most one time in this process, before or after answering a question, Alice is allowed to move her token from her current cell to some adjacent cell. Alice acted in such a way that she was able to answer "NO" to all of Bob's questions.
Note that Alice can even move her token before answering the first question or after answering the last question. Alice can also choose to not move at all.
You are given n and Bob's questions x_1, …, x_k. You would like to count the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Let (a,b) denote a scenario where Alice starts at cell a and ends at cell b. Two scenarios (a_i, b_i) and (a_j, b_j) are different if a_i ≠ a_j or b_i ≠ b_j.
Input
The first line contains two integers n and k (1 ≤ n,k ≤ 10^5) — the number of cells and the number of questions Bob asked.
The second line contains k integers x_1, x_2, …, x_k (1 ≤ x_i ≤ n) — Bob's questions.
Output
Print a single integer, the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Examples
Input
5 3
5 1 4
Output
9
Input
4 8
1 2 3 4 4 3 2 1
Output
0
Input
100000 1
42
Output
299997
Note
The notation (i,j) denotes a scenario where Alice starts at cell i and ends at cell j.
In the first example, the valid scenarios are (1, 2), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (4, 3), (4, 5). For example, (3,4) is valid since Alice can start at cell 3, stay there for the first three questions, then move to cell 4 after the last question.
(4,5) is valid since Alice can start at cell 4, stay there for the first question, the move to cell 5 for the next two questions. Note that (4,5) is only counted once, even though there are different questions that Alice can choose to do the move, but remember, we only count each pair of starting and ending positions once.
In the second example, Alice has no valid scenarios.
In the last example, all (i,j) where |i-j| ≤ 1 except for (42, 42) are valid scenarios.
Submitted Solution:
```
from collections import defaultdict
n, k = [int(item) for item in input().split()]
x = [int(item) for item in input().split()]
occ = defaultdict(list)
for i in range(k):
occ[x[i]].append(i)
ans = 0
for i in range(1, n + 1):
old = ans
if not i in occ:
if i == 1 or i == n:
ans += 2
else:
ans += 3
continue
if i < n and (i + 1 not in occ or occ[i][0] > occ[i + 1][-1]):
ans += 1
if i > 1 and (i - 1 not in occ or occ[i][0] > occ[i - 1][-1]):
ans += 1
print(ans)
``` | instruction | 0 | 68,202 | 15 | 136,404 |
Yes | output | 1 | 68,202 | 15 | 136,405 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are playing a game on a line with n cells. There are n cells labeled from 1 through n. For each i from 1 to n-1, cells i and i+1 are adjacent.
Alice initially has a token on some cell on the line, and Bob tries to guess where it is.
Bob guesses a sequence of line cell numbers x_1, x_2, …, x_k in order. In the i-th question, Bob asks Alice if her token is currently on cell x_i. That is, Alice can answer either "YES" or "NO" to each Bob's question.
At most one time in this process, before or after answering a question, Alice is allowed to move her token from her current cell to some adjacent cell. Alice acted in such a way that she was able to answer "NO" to all of Bob's questions.
Note that Alice can even move her token before answering the first question or after answering the last question. Alice can also choose to not move at all.
You are given n and Bob's questions x_1, …, x_k. You would like to count the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Let (a,b) denote a scenario where Alice starts at cell a and ends at cell b. Two scenarios (a_i, b_i) and (a_j, b_j) are different if a_i ≠ a_j or b_i ≠ b_j.
Input
The first line contains two integers n and k (1 ≤ n,k ≤ 10^5) — the number of cells and the number of questions Bob asked.
The second line contains k integers x_1, x_2, …, x_k (1 ≤ x_i ≤ n) — Bob's questions.
Output
Print a single integer, the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Examples
Input
5 3
5 1 4
Output
9
Input
4 8
1 2 3 4 4 3 2 1
Output
0
Input
100000 1
42
Output
299997
Note
The notation (i,j) denotes a scenario where Alice starts at cell i and ends at cell j.
In the first example, the valid scenarios are (1, 2), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (4, 3), (4, 5). For example, (3,4) is valid since Alice can start at cell 3, stay there for the first three questions, then move to cell 4 after the last question.
(4,5) is valid since Alice can start at cell 4, stay there for the first question, the move to cell 5 for the next two questions. Note that (4,5) is only counted once, even though there are different questions that Alice can choose to do the move, but remember, we only count each pair of starting and ending positions once.
In the second example, Alice has no valid scenarios.
In the last example, all (i,j) where |i-j| ≤ 1 except for (42, 42) are valid scenarios.
Submitted Solution:
```
n, k = map(int, input().split())
a = list(map(int, input().split()))
count = (n - 1) * 2 + n
b = [[0, -1] for i in range(n + 2)]
c = set()
for i in range(len(a)):
if b[a[i] - 1][0] != 0 and b[a[i]][0] == 0:
count -= 1
if b[a[i] + 1][0] != 0 and b[a[i]][0] == 0:
count -= 1
if b[a[i]][0] == 0:
count -= 1
l1 = (a[i] + 1, a[i])
l2 = (a[i], a[i] + 1)
if b[a[i] + 1][1] > b[a[i]][1] and b[a[i] + 1][0] != 0 and b[a[i]][0] != 0 and l1 not in c and l2 not in c:
count -= 1
c.add(l1)
c.add(l2)
l3 = (a[i], a[i] - 1)
l4 = (a[i] - 1, a[i])
if b[a[i] - 1][1] > b[a[i]][1] and b[a[i] - 1][0] != 0 and b[a[i]][0] != 0 and l3 not in c and l4 not in c:
count -= 1
c.add(l3)
c.add(l4)
b[a[i]][0] = 1
b[a[i]][1] = i
print(count)
``` | instruction | 0 | 68,203 | 15 | 136,406 |
Yes | output | 1 | 68,203 | 15 | 136,407 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are playing a game on a line with n cells. There are n cells labeled from 1 through n. For each i from 1 to n-1, cells i and i+1 are adjacent.
Alice initially has a token on some cell on the line, and Bob tries to guess where it is.
Bob guesses a sequence of line cell numbers x_1, x_2, …, x_k in order. In the i-th question, Bob asks Alice if her token is currently on cell x_i. That is, Alice can answer either "YES" or "NO" to each Bob's question.
At most one time in this process, before or after answering a question, Alice is allowed to move her token from her current cell to some adjacent cell. Alice acted in such a way that she was able to answer "NO" to all of Bob's questions.
Note that Alice can even move her token before answering the first question or after answering the last question. Alice can also choose to not move at all.
You are given n and Bob's questions x_1, …, x_k. You would like to count the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Let (a,b) denote a scenario where Alice starts at cell a and ends at cell b. Two scenarios (a_i, b_i) and (a_j, b_j) are different if a_i ≠ a_j or b_i ≠ b_j.
Input
The first line contains two integers n and k (1 ≤ n,k ≤ 10^5) — the number of cells and the number of questions Bob asked.
The second line contains k integers x_1, x_2, …, x_k (1 ≤ x_i ≤ n) — Bob's questions.
Output
Print a single integer, the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Examples
Input
5 3
5 1 4
Output
9
Input
4 8
1 2 3 4 4 3 2 1
Output
0
Input
100000 1
42
Output
299997
Note
The notation (i,j) denotes a scenario where Alice starts at cell i and ends at cell j.
In the first example, the valid scenarios are (1, 2), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (4, 3), (4, 5). For example, (3,4) is valid since Alice can start at cell 3, stay there for the first three questions, then move to cell 4 after the last question.
(4,5) is valid since Alice can start at cell 4, stay there for the first question, the move to cell 5 for the next two questions. Note that (4,5) is only counted once, even though there are different questions that Alice can choose to do the move, but remember, we only count each pair of starting and ending positions once.
In the second example, Alice has no valid scenarios.
In the last example, all (i,j) where |i-j| ≤ 1 except for (42, 42) are valid scenarios.
Submitted Solution:
```
n, k = map(int, input().split())
A = list(map(int, input().split()))
tot = 2 * (n - 1) + n
s = set()
for i in A:
s.add((i, i))
if (i - 1, i - 1) in s:
s.add((i - 1, i))
if (i + 1, i + 1) in s:
s.add((i + 1, i))
print(tot - len(s))
``` | instruction | 0 | 68,204 | 15 | 136,408 |
Yes | output | 1 | 68,204 | 15 | 136,409 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are playing a game on a line with n cells. There are n cells labeled from 1 through n. For each i from 1 to n-1, cells i and i+1 are adjacent.
Alice initially has a token on some cell on the line, and Bob tries to guess where it is.
Bob guesses a sequence of line cell numbers x_1, x_2, …, x_k in order. In the i-th question, Bob asks Alice if her token is currently on cell x_i. That is, Alice can answer either "YES" or "NO" to each Bob's question.
At most one time in this process, before or after answering a question, Alice is allowed to move her token from her current cell to some adjacent cell. Alice acted in such a way that she was able to answer "NO" to all of Bob's questions.
Note that Alice can even move her token before answering the first question or after answering the last question. Alice can also choose to not move at all.
You are given n and Bob's questions x_1, …, x_k. You would like to count the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Let (a,b) denote a scenario where Alice starts at cell a and ends at cell b. Two scenarios (a_i, b_i) and (a_j, b_j) are different if a_i ≠ a_j or b_i ≠ b_j.
Input
The first line contains two integers n and k (1 ≤ n,k ≤ 10^5) — the number of cells and the number of questions Bob asked.
The second line contains k integers x_1, x_2, …, x_k (1 ≤ x_i ≤ n) — Bob's questions.
Output
Print a single integer, the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Examples
Input
5 3
5 1 4
Output
9
Input
4 8
1 2 3 4 4 3 2 1
Output
0
Input
100000 1
42
Output
299997
Note
The notation (i,j) denotes a scenario where Alice starts at cell i and ends at cell j.
In the first example, the valid scenarios are (1, 2), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (4, 3), (4, 5). For example, (3,4) is valid since Alice can start at cell 3, stay there for the first three questions, then move to cell 4 after the last question.
(4,5) is valid since Alice can start at cell 4, stay there for the first question, the move to cell 5 for the next two questions. Note that (4,5) is only counted once, even though there are different questions that Alice can choose to do the move, but remember, we only count each pair of starting and ending positions once.
In the second example, Alice has no valid scenarios.
In the last example, all (i,j) where |i-j| ≤ 1 except for (42, 42) are valid scenarios.
Submitted Solution:
```
n, k = map(int, input().split())
q = list(map(int, input().split()))
# total possible is 3*(n-2) + 2*2
# can't stay if there is a number in question
# can't go (a, b) if there is a subsequense a .. b
# should work in linear time
# positions asked about
seen = set()
possible_scen = set()
possible_scen.add((1, 1))
possible_scen.add((1, 2))
for item in range(2, n):
possible_scen.add((item, item-1))
possible_scen.add((item, item))
possible_scen.add((item, item+1))
possible_scen.add((n, n-1))
possible_scen.add((n, n))
for item in q:
if (item, item) in possible_scen:
possible_scen.remove((item, item))
if item + 1 in seen:
if (item+1, item) in possible_scen:
possible_scen.remove((item+1, item))
if item - 1 in seen:
if (item-1, item) in possible_scen:
possible_scen.remove((item-1, item))
seen.add(item)
print(len(possible_scen))
``` | instruction | 0 | 68,205 | 15 | 136,410 |
No | output | 1 | 68,205 | 15 | 136,411 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are playing a game on a line with n cells. There are n cells labeled from 1 through n. For each i from 1 to n-1, cells i and i+1 are adjacent.
Alice initially has a token on some cell on the line, and Bob tries to guess where it is.
Bob guesses a sequence of line cell numbers x_1, x_2, …, x_k in order. In the i-th question, Bob asks Alice if her token is currently on cell x_i. That is, Alice can answer either "YES" or "NO" to each Bob's question.
At most one time in this process, before or after answering a question, Alice is allowed to move her token from her current cell to some adjacent cell. Alice acted in such a way that she was able to answer "NO" to all of Bob's questions.
Note that Alice can even move her token before answering the first question or after answering the last question. Alice can also choose to not move at all.
You are given n and Bob's questions x_1, …, x_k. You would like to count the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Let (a,b) denote a scenario where Alice starts at cell a and ends at cell b. Two scenarios (a_i, b_i) and (a_j, b_j) are different if a_i ≠ a_j or b_i ≠ b_j.
Input
The first line contains two integers n and k (1 ≤ n,k ≤ 10^5) — the number of cells and the number of questions Bob asked.
The second line contains k integers x_1, x_2, …, x_k (1 ≤ x_i ≤ n) — Bob's questions.
Output
Print a single integer, the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Examples
Input
5 3
5 1 4
Output
9
Input
4 8
1 2 3 4 4 3 2 1
Output
0
Input
100000 1
42
Output
299997
Note
The notation (i,j) denotes a scenario where Alice starts at cell i and ends at cell j.
In the first example, the valid scenarios are (1, 2), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (4, 3), (4, 5). For example, (3,4) is valid since Alice can start at cell 3, stay there for the first three questions, then move to cell 4 after the last question.
(4,5) is valid since Alice can start at cell 4, stay there for the first question, the move to cell 5 for the next two questions. Note that (4,5) is only counted once, even though there are different questions that Alice can choose to do the move, but remember, we only count each pair of starting and ending positions once.
In the second example, Alice has no valid scenarios.
In the last example, all (i,j) where |i-j| ≤ 1 except for (42, 42) are valid scenarios.
Submitted Solution:
```
from math import *
from collections import *
import sys
sys.setrecursionlimit(10**9)
n,k = map(int,input().split())
a = list(map(int,input().split()))
l = [n+1 for i in range(n+1)]
r = [-1 for i in range(n+1)]
for i in range(k):
if(l[a[i]] == n+1):
l[a[i]] = i
r[a[i]] = i
ct = 0
for i in range(1,n):
if(r[i] < l[i+1]):
ct += 1;
for i in range(2,n+1):
if(r[i] < l[i-1]):
ct += 1;
ct += r.count(-1)-1
print(ct)
``` | instruction | 0 | 68,206 | 15 | 136,412 |
No | output | 1 | 68,206 | 15 | 136,413 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are playing a game on a line with n cells. There are n cells labeled from 1 through n. For each i from 1 to n-1, cells i and i+1 are adjacent.
Alice initially has a token on some cell on the line, and Bob tries to guess where it is.
Bob guesses a sequence of line cell numbers x_1, x_2, …, x_k in order. In the i-th question, Bob asks Alice if her token is currently on cell x_i. That is, Alice can answer either "YES" or "NO" to each Bob's question.
At most one time in this process, before or after answering a question, Alice is allowed to move her token from her current cell to some adjacent cell. Alice acted in such a way that she was able to answer "NO" to all of Bob's questions.
Note that Alice can even move her token before answering the first question or after answering the last question. Alice can also choose to not move at all.
You are given n and Bob's questions x_1, …, x_k. You would like to count the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Let (a,b) denote a scenario where Alice starts at cell a and ends at cell b. Two scenarios (a_i, b_i) and (a_j, b_j) are different if a_i ≠ a_j or b_i ≠ b_j.
Input
The first line contains two integers n and k (1 ≤ n,k ≤ 10^5) — the number of cells and the number of questions Bob asked.
The second line contains k integers x_1, x_2, …, x_k (1 ≤ x_i ≤ n) — Bob's questions.
Output
Print a single integer, the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Examples
Input
5 3
5 1 4
Output
9
Input
4 8
1 2 3 4 4 3 2 1
Output
0
Input
100000 1
42
Output
299997
Note
The notation (i,j) denotes a scenario where Alice starts at cell i and ends at cell j.
In the first example, the valid scenarios are (1, 2), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (4, 3), (4, 5). For example, (3,4) is valid since Alice can start at cell 3, stay there for the first three questions, then move to cell 4 after the last question.
(4,5) is valid since Alice can start at cell 4, stay there for the first question, the move to cell 5 for the next two questions. Note that (4,5) is only counted once, even though there are different questions that Alice can choose to do the move, but remember, we only count each pair of starting and ending positions once.
In the second example, Alice has no valid scenarios.
In the last example, all (i,j) where |i-j| ≤ 1 except for (42, 42) are valid scenarios.
Submitted Solution:
```
from math import *
from collections import *
from bisect import *
import sys
input=sys.stdin.readline
t=1
while(t):
t-=1
n,k=map(int,input().split())
a=list(map(int,input().split()))
if(n==1):
print(0)
continue
f=[0]*n
a.sort()
for i in a:
f[i-1]=i
r=0
for i in range(1,n-1):
if(f[i]==0):
r+=1
if(f[i-1]==0 or f[i+1]==0):
r+=2
if(f[0]==0):
r+=1
if(f[-1]==0):
r+=1
if(f[1]==0):
r+=1
if(f[-2]==0):
r+=1
print(r)
``` | instruction | 0 | 68,207 | 15 | 136,414 |
No | output | 1 | 68,207 | 15 | 136,415 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are playing a game on a line with n cells. There are n cells labeled from 1 through n. For each i from 1 to n-1, cells i and i+1 are adjacent.
Alice initially has a token on some cell on the line, and Bob tries to guess where it is.
Bob guesses a sequence of line cell numbers x_1, x_2, …, x_k in order. In the i-th question, Bob asks Alice if her token is currently on cell x_i. That is, Alice can answer either "YES" or "NO" to each Bob's question.
At most one time in this process, before or after answering a question, Alice is allowed to move her token from her current cell to some adjacent cell. Alice acted in such a way that she was able to answer "NO" to all of Bob's questions.
Note that Alice can even move her token before answering the first question or after answering the last question. Alice can also choose to not move at all.
You are given n and Bob's questions x_1, …, x_k. You would like to count the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Let (a,b) denote a scenario where Alice starts at cell a and ends at cell b. Two scenarios (a_i, b_i) and (a_j, b_j) are different if a_i ≠ a_j or b_i ≠ b_j.
Input
The first line contains two integers n and k (1 ≤ n,k ≤ 10^5) — the number of cells and the number of questions Bob asked.
The second line contains k integers x_1, x_2, …, x_k (1 ≤ x_i ≤ n) — Bob's questions.
Output
Print a single integer, the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Examples
Input
5 3
5 1 4
Output
9
Input
4 8
1 2 3 4 4 3 2 1
Output
0
Input
100000 1
42
Output
299997
Note
The notation (i,j) denotes a scenario where Alice starts at cell i and ends at cell j.
In the first example, the valid scenarios are (1, 2), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (4, 3), (4, 5). For example, (3,4) is valid since Alice can start at cell 3, stay there for the first three questions, then move to cell 4 after the last question.
(4,5) is valid since Alice can start at cell 4, stay there for the first question, the move to cell 5 for the next two questions. Note that (4,5) is only counted once, even though there are different questions that Alice can choose to do the move, but remember, we only count each pair of starting and ending positions once.
In the second example, Alice has no valid scenarios.
In the last example, all (i,j) where |i-j| ≤ 1 except for (42, 42) are valid scenarios.
Submitted Solution:
```
from math import *
from collections import *
from bisect import *
import sys
input=sys.stdin.readline
t=1
while(t):
t-=1
n,k=map(int,input().split())
a=list(map(int,input().split()))
if(n==1):
print(0)
continue
f=[0]*n
a.sort()
for i in a:
f[i-1]=i
r=0
for i in range(1,n-1):
if(f[i]==0):
r+=1
if(f[i-1]==0):
r+=1
if(f[i+1]==0):
r+=1
if(f[0]==0):
r+=1
if(f[-1]==0):
r+=1
if(f[1]==0):
r+=1
if(f[-2]==0):
r+=1
print(r)
``` | instruction | 0 | 68,208 | 15 | 136,416 |
No | output | 1 | 68,208 | 15 | 136,417 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Amugae is in a very large round corridor. The corridor consists of two areas. The inner area is equally divided by n sectors, and the outer area is equally divided by m sectors. A wall exists between each pair of sectors of same area (inner or outer), but there is no wall between the inner area and the outer area. A wall always exists at the 12 o'clock position.
<image>
The inner area's sectors are denoted as (1,1), (1,2), ..., (1,n) in clockwise direction. The outer area's sectors are denoted as (2,1), (2,2), ..., (2,m) in the same manner. For a clear understanding, see the example image above.
Amugae wants to know if he can move from one sector to another sector. He has q questions.
For each question, check if he can move between two given sectors.
Input
The first line contains three integers n, m and q (1 ≤ n, m ≤ 10^{18}, 1 ≤ q ≤ 10^4) — the number of sectors in the inner area, the number of sectors in the outer area and the number of questions.
Each of the next q lines contains four integers s_x, s_y, e_x, e_y (1 ≤ s_x, e_x ≤ 2; if s_x = 1, then 1 ≤ s_y ≤ n, otherwise 1 ≤ s_y ≤ m; constraints on e_y are similar). Amague wants to know if it is possible to move from sector (s_x, s_y) to sector (e_x, e_y).
Output
For each question, print "YES" if Amugae can move from (s_x, s_y) to (e_x, e_y), and "NO" otherwise.
You can print each letter in any case (upper or lower).
Example
Input
4 6 3
1 1 2 3
2 6 1 2
2 6 2 4
Output
YES
NO
YES
Note
Example is shown on the picture in the statement. | instruction | 0 | 68,225 | 15 | 136,450 |
Tags: math, number theory
Correct Solution:
```
def gcd(a,b):
if b==0:
return a
return gcd(b,a%b)
n,m,q=[int(x) for x in input().split()]
g=gcd(n,m)
l=n*m//g
for _ in range(q):
a,b,c,d=[int(x) for x in input().split()]
if a==1:
b*=m
else:
b*=n
if c==1:
d*=m
else:
d*=n
if (b-1)//l == (d-1)//l:
print("YES")
else:
print("NO")
``` | output | 1 | 68,225 | 15 | 136,451 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Amugae is in a very large round corridor. The corridor consists of two areas. The inner area is equally divided by n sectors, and the outer area is equally divided by m sectors. A wall exists between each pair of sectors of same area (inner or outer), but there is no wall between the inner area and the outer area. A wall always exists at the 12 o'clock position.
<image>
The inner area's sectors are denoted as (1,1), (1,2), ..., (1,n) in clockwise direction. The outer area's sectors are denoted as (2,1), (2,2), ..., (2,m) in the same manner. For a clear understanding, see the example image above.
Amugae wants to know if he can move from one sector to another sector. He has q questions.
For each question, check if he can move between two given sectors.
Input
The first line contains three integers n, m and q (1 ≤ n, m ≤ 10^{18}, 1 ≤ q ≤ 10^4) — the number of sectors in the inner area, the number of sectors in the outer area and the number of questions.
Each of the next q lines contains four integers s_x, s_y, e_x, e_y (1 ≤ s_x, e_x ≤ 2; if s_x = 1, then 1 ≤ s_y ≤ n, otherwise 1 ≤ s_y ≤ m; constraints on e_y are similar). Amague wants to know if it is possible to move from sector (s_x, s_y) to sector (e_x, e_y).
Output
For each question, print "YES" if Amugae can move from (s_x, s_y) to (e_x, e_y), and "NO" otherwise.
You can print each letter in any case (upper or lower).
Example
Input
4 6 3
1 1 2 3
2 6 1 2
2 6 2 4
Output
YES
NO
YES
Note
Example is shown on the picture in the statement. | instruction | 0 | 68,226 | 15 | 136,452 |
Tags: math, number theory
Correct Solution:
```
def mp():
return map(int, input().split())
def gcd(a, b):
if a == 0:
return b
return gcd(b % a, a)
n, m, q = mp()
st = gcd(n, m)
stn = n // st
stm = m // st
for qq in range(q):
s, x, e, y = mp()
if s == 1:
x = (x + stn - 1) // stn
else:
x = (x + stm - 1) // stm
if e == 1:
y = (y + stn - 1) // stn
else:
y = (y + stm - 1) // stm
if x == y:
print('YES')
else:
print('NO')
``` | output | 1 | 68,226 | 15 | 136,453 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Amugae is in a very large round corridor. The corridor consists of two areas. The inner area is equally divided by n sectors, and the outer area is equally divided by m sectors. A wall exists between each pair of sectors of same area (inner or outer), but there is no wall between the inner area and the outer area. A wall always exists at the 12 o'clock position.
<image>
The inner area's sectors are denoted as (1,1), (1,2), ..., (1,n) in clockwise direction. The outer area's sectors are denoted as (2,1), (2,2), ..., (2,m) in the same manner. For a clear understanding, see the example image above.
Amugae wants to know if he can move from one sector to another sector. He has q questions.
For each question, check if he can move between two given sectors.
Input
The first line contains three integers n, m and q (1 ≤ n, m ≤ 10^{18}, 1 ≤ q ≤ 10^4) — the number of sectors in the inner area, the number of sectors in the outer area and the number of questions.
Each of the next q lines contains four integers s_x, s_y, e_x, e_y (1 ≤ s_x, e_x ≤ 2; if s_x = 1, then 1 ≤ s_y ≤ n, otherwise 1 ≤ s_y ≤ m; constraints on e_y are similar). Amague wants to know if it is possible to move from sector (s_x, s_y) to sector (e_x, e_y).
Output
For each question, print "YES" if Amugae can move from (s_x, s_y) to (e_x, e_y), and "NO" otherwise.
You can print each letter in any case (upper or lower).
Example
Input
4 6 3
1 1 2 3
2 6 1 2
2 6 2 4
Output
YES
NO
YES
Note
Example is shown on the picture in the statement. | instruction | 0 | 68,227 | 15 | 136,454 |
Tags: math, number theory
Correct Solution:
```
import sys
import math
n, m, q = map(int, input().split())
g = math.gcd(n, m)
ds = [None, n // g, m // g]
buf = []
for line in sys.stdin:
sx, sy, ex, ey = map(int, line.split())
s_area = (sy - 1) // ds[sx]
e_area = (ey - 1) // ds[ex]
buf.append('yes' if s_area == e_area else 'no')
print('\n'.join(buf))
``` | output | 1 | 68,227 | 15 | 136,455 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Amugae is in a very large round corridor. The corridor consists of two areas. The inner area is equally divided by n sectors, and the outer area is equally divided by m sectors. A wall exists between each pair of sectors of same area (inner or outer), but there is no wall between the inner area and the outer area. A wall always exists at the 12 o'clock position.
<image>
The inner area's sectors are denoted as (1,1), (1,2), ..., (1,n) in clockwise direction. The outer area's sectors are denoted as (2,1), (2,2), ..., (2,m) in the same manner. For a clear understanding, see the example image above.
Amugae wants to know if he can move from one sector to another sector. He has q questions.
For each question, check if he can move between two given sectors.
Input
The first line contains three integers n, m and q (1 ≤ n, m ≤ 10^{18}, 1 ≤ q ≤ 10^4) — the number of sectors in the inner area, the number of sectors in the outer area and the number of questions.
Each of the next q lines contains four integers s_x, s_y, e_x, e_y (1 ≤ s_x, e_x ≤ 2; if s_x = 1, then 1 ≤ s_y ≤ n, otherwise 1 ≤ s_y ≤ m; constraints on e_y are similar). Amague wants to know if it is possible to move from sector (s_x, s_y) to sector (e_x, e_y).
Output
For each question, print "YES" if Amugae can move from (s_x, s_y) to (e_x, e_y), and "NO" otherwise.
You can print each letter in any case (upper or lower).
Example
Input
4 6 3
1 1 2 3
2 6 1 2
2 6 2 4
Output
YES
NO
YES
Note
Example is shown on the picture in the statement. | instruction | 0 | 68,228 | 15 | 136,456 |
Tags: math, number theory
Correct Solution:
```
from math import gcd
n, m, q = map(int, input().split())
d = gcd(n, m)
c = [n//d, m//d]
for _ in range(q):
sx, sy, ex, ey = map(int, input().split())
print("YES" if (sy - 1) // c[sx - 1] == (ey - 1) // c[ex - 1] else "NO")
``` | output | 1 | 68,228 | 15 | 136,457 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Amugae is in a very large round corridor. The corridor consists of two areas. The inner area is equally divided by n sectors, and the outer area is equally divided by m sectors. A wall exists between each pair of sectors of same area (inner or outer), but there is no wall between the inner area and the outer area. A wall always exists at the 12 o'clock position.
<image>
The inner area's sectors are denoted as (1,1), (1,2), ..., (1,n) in clockwise direction. The outer area's sectors are denoted as (2,1), (2,2), ..., (2,m) in the same manner. For a clear understanding, see the example image above.
Amugae wants to know if he can move from one sector to another sector. He has q questions.
For each question, check if he can move between two given sectors.
Input
The first line contains three integers n, m and q (1 ≤ n, m ≤ 10^{18}, 1 ≤ q ≤ 10^4) — the number of sectors in the inner area, the number of sectors in the outer area and the number of questions.
Each of the next q lines contains four integers s_x, s_y, e_x, e_y (1 ≤ s_x, e_x ≤ 2; if s_x = 1, then 1 ≤ s_y ≤ n, otherwise 1 ≤ s_y ≤ m; constraints on e_y are similar). Amague wants to know if it is possible to move from sector (s_x, s_y) to sector (e_x, e_y).
Output
For each question, print "YES" if Amugae can move from (s_x, s_y) to (e_x, e_y), and "NO" otherwise.
You can print each letter in any case (upper or lower).
Example
Input
4 6 3
1 1 2 3
2 6 1 2
2 6 2 4
Output
YES
NO
YES
Note
Example is shown on the picture in the statement. | instruction | 0 | 68,229 | 15 | 136,458 |
Tags: math, number theory
Correct Solution:
```
def gcd(a,b):
if(b==0):
return a
else:
return gcd(b,a%b)
n,m,q = [int(x) for x in input().split()]
N = (n * m)//gcd(n,m)
one,two = N//m,N//n
for _ in range(q):
sx,sy,ex,ey = [int(x) for x in input().split()]
if sx==1:
sy=(sy-1)//one;
else:
sy=(sy-1)//two;
if ex==1:
ey=(ey-1)//one;
else:
ey=(ey-1)//two;
if sy == ey:
print("YES")
else :
print("NO")
``` | output | 1 | 68,229 | 15 | 136,459 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Amugae is in a very large round corridor. The corridor consists of two areas. The inner area is equally divided by n sectors, and the outer area is equally divided by m sectors. A wall exists between each pair of sectors of same area (inner or outer), but there is no wall between the inner area and the outer area. A wall always exists at the 12 o'clock position.
<image>
The inner area's sectors are denoted as (1,1), (1,2), ..., (1,n) in clockwise direction. The outer area's sectors are denoted as (2,1), (2,2), ..., (2,m) in the same manner. For a clear understanding, see the example image above.
Amugae wants to know if he can move from one sector to another sector. He has q questions.
For each question, check if he can move between two given sectors.
Input
The first line contains three integers n, m and q (1 ≤ n, m ≤ 10^{18}, 1 ≤ q ≤ 10^4) — the number of sectors in the inner area, the number of sectors in the outer area and the number of questions.
Each of the next q lines contains four integers s_x, s_y, e_x, e_y (1 ≤ s_x, e_x ≤ 2; if s_x = 1, then 1 ≤ s_y ≤ n, otherwise 1 ≤ s_y ≤ m; constraints on e_y are similar). Amague wants to know if it is possible to move from sector (s_x, s_y) to sector (e_x, e_y).
Output
For each question, print "YES" if Amugae can move from (s_x, s_y) to (e_x, e_y), and "NO" otherwise.
You can print each letter in any case (upper or lower).
Example
Input
4 6 3
1 1 2 3
2 6 1 2
2 6 2 4
Output
YES
NO
YES
Note
Example is shown on the picture in the statement. | instruction | 0 | 68,230 | 15 | 136,460 |
Tags: math, number theory
Correct Solution:
```
import sys
input = sys.stdin.readline
n, m, q = list(map(int, input().split()))
def computeGCD(x, y):
while(y):
x, y = y, x % y
return x
gcd = computeGCD(n, m)
factorN = n // gcd
factorM = m // gcd
for _ in range(q):
sx, sy, ex, ey = list(map(int, input().split()))
if sx != ex:
if sx == 1:
factor = factorN
opsFactor = factorM
else:
factor = factorM
opsFactor = factorN
rem = (sy-1) // factor
sy = rem * opsFactor + 1
sx = ex
# print(factor, rem)
# print('before', sx, sy)
if ex == 1:
factor = factorN
else:
factor = factorM
rem = (sy-1) // factor
sy = rem * factor + 1
# print(sx, sy)
if ey - sy < 0 or ey - sy >= factor:
print('NO')
else:
print('YES')
``` | output | 1 | 68,230 | 15 | 136,461 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Amugae is in a very large round corridor. The corridor consists of two areas. The inner area is equally divided by n sectors, and the outer area is equally divided by m sectors. A wall exists between each pair of sectors of same area (inner or outer), but there is no wall between the inner area and the outer area. A wall always exists at the 12 o'clock position.
<image>
The inner area's sectors are denoted as (1,1), (1,2), ..., (1,n) in clockwise direction. The outer area's sectors are denoted as (2,1), (2,2), ..., (2,m) in the same manner. For a clear understanding, see the example image above.
Amugae wants to know if he can move from one sector to another sector. He has q questions.
For each question, check if he can move between two given sectors.
Input
The first line contains three integers n, m and q (1 ≤ n, m ≤ 10^{18}, 1 ≤ q ≤ 10^4) — the number of sectors in the inner area, the number of sectors in the outer area and the number of questions.
Each of the next q lines contains four integers s_x, s_y, e_x, e_y (1 ≤ s_x, e_x ≤ 2; if s_x = 1, then 1 ≤ s_y ≤ n, otherwise 1 ≤ s_y ≤ m; constraints on e_y are similar). Amague wants to know if it is possible to move from sector (s_x, s_y) to sector (e_x, e_y).
Output
For each question, print "YES" if Amugae can move from (s_x, s_y) to (e_x, e_y), and "NO" otherwise.
You can print each letter in any case (upper or lower).
Example
Input
4 6 3
1 1 2 3
2 6 1 2
2 6 2 4
Output
YES
NO
YES
Note
Example is shown on the picture in the statement. | instruction | 0 | 68,231 | 15 | 136,462 |
Tags: math, number theory
Correct Solution:
```
from sys import stdin
def gcd(a,b):
while b!=0:
t=int(a)
a=int(b)
b=t%a
return int(a)
def lcm(a, b):
return int((a*b)/gcd(a, b))
n,m,q=map(int,stdin.readline().strip().split())
b=lcm(n,m)//n
a=lcm(n,m)//m
for i in range(q):
x,y,x1,y1=map(int,stdin.readline().strip().split())
if (x==2):
w=y//b
if (y%b!=0):
w+=1
else:
w=y//a
if (y%a!=0):
w+=1
if (x1==2):
w1=y1//b
if (y1%b!=0):
w1+=1
else:
w1=y1//a
if (y1%a!=0):
w1+=1
if w==w1:
print("YES")
else:
print("NO")
``` | output | 1 | 68,231 | 15 | 136,463 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Amugae is in a very large round corridor. The corridor consists of two areas. The inner area is equally divided by n sectors, and the outer area is equally divided by m sectors. A wall exists between each pair of sectors of same area (inner or outer), but there is no wall between the inner area and the outer area. A wall always exists at the 12 o'clock position.
<image>
The inner area's sectors are denoted as (1,1), (1,2), ..., (1,n) in clockwise direction. The outer area's sectors are denoted as (2,1), (2,2), ..., (2,m) in the same manner. For a clear understanding, see the example image above.
Amugae wants to know if he can move from one sector to another sector. He has q questions.
For each question, check if he can move between two given sectors.
Input
The first line contains three integers n, m and q (1 ≤ n, m ≤ 10^{18}, 1 ≤ q ≤ 10^4) — the number of sectors in the inner area, the number of sectors in the outer area and the number of questions.
Each of the next q lines contains four integers s_x, s_y, e_x, e_y (1 ≤ s_x, e_x ≤ 2; if s_x = 1, then 1 ≤ s_y ≤ n, otherwise 1 ≤ s_y ≤ m; constraints on e_y are similar). Amague wants to know if it is possible to move from sector (s_x, s_y) to sector (e_x, e_y).
Output
For each question, print "YES" if Amugae can move from (s_x, s_y) to (e_x, e_y), and "NO" otherwise.
You can print each letter in any case (upper or lower).
Example
Input
4 6 3
1 1 2 3
2 6 1 2
2 6 2 4
Output
YES
NO
YES
Note
Example is shown on the picture in the statement. | instruction | 0 | 68,232 | 15 | 136,464 |
Tags: math, number theory
Correct Solution:
```
import math
n,m,q=map(int,input().split())
c1=n//math.gcd(n,m)
c2=m//math.gcd(n,m)
for _ in range(q):
ang1=0
ang2=0
x,y,x2,y2=map(int,input().split())
y-=1
y2-=1
if(x==1):
ang1=y//c1
else:
ang1=y//c2
if(x2==2):
ang2=y2//c2
else:
ang2=y2//c1
#print(c,ang1,ang2)
if(ang1==ang2):
print("YES")
else:
print("NO")
``` | output | 1 | 68,232 | 15 | 136,465 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Amugae is in a very large round corridor. The corridor consists of two areas. The inner area is equally divided by n sectors, and the outer area is equally divided by m sectors. A wall exists between each pair of sectors of same area (inner or outer), but there is no wall between the inner area and the outer area. A wall always exists at the 12 o'clock position.
<image>
The inner area's sectors are denoted as (1,1), (1,2), ..., (1,n) in clockwise direction. The outer area's sectors are denoted as (2,1), (2,2), ..., (2,m) in the same manner. For a clear understanding, see the example image above.
Amugae wants to know if he can move from one sector to another sector. He has q questions.
For each question, check if he can move between two given sectors.
Input
The first line contains three integers n, m and q (1 ≤ n, m ≤ 10^{18}, 1 ≤ q ≤ 10^4) — the number of sectors in the inner area, the number of sectors in the outer area and the number of questions.
Each of the next q lines contains four integers s_x, s_y, e_x, e_y (1 ≤ s_x, e_x ≤ 2; if s_x = 1, then 1 ≤ s_y ≤ n, otherwise 1 ≤ s_y ≤ m; constraints on e_y are similar). Amague wants to know if it is possible to move from sector (s_x, s_y) to sector (e_x, e_y).
Output
For each question, print "YES" if Amugae can move from (s_x, s_y) to (e_x, e_y), and "NO" otherwise.
You can print each letter in any case (upper or lower).
Example
Input
4 6 3
1 1 2 3
2 6 1 2
2 6 2 4
Output
YES
NO
YES
Note
Example is shown on the picture in the statement.
Submitted Solution:
```
def __gcd(x, y):
if(y == 0):
return x
else:
return __gcd(y, x % y)
n, m, q = map(int, input().split())
tmp = __gcd(n, m)
n //= tmp
m //= tmp
lcm = n // __gcd(n, m) * m
x = lcm // m
y = lcm // n
for icase in range(0, q):
sx, sy, ex, ey = map(int, input().split())
if(sx == ex):
if (sy > ey):
sy, ey = ey, sy
if(sx == 1):
num1 = sy // x * x
num2 = (sy + x- 1) // x * x
if(sy % x == 0):
num1 -= x
if(ey <= num2 and ey > num1):
print("YES")
else:
print("NO")
else:
num1 = sy // y * y
num2 = (sy + y - 1) // y * y
if(sy % y == 0):
num1 -= y
if (ey <= num2 and ey > num1):
print("YES")
else:
print("NO")
else:
if(sx > ex):
sy, ey = ey, sy
num1 = sy // x * y
num2 = (sy + x - 1) // x * y
if(sy % x == 0):
num1 -= y
num1 = num1
if (ey <= num2 and ey > num1):
print("YES")
else:
print("NO")
``` | instruction | 0 | 68,234 | 15 | 136,468 |
Yes | output | 1 | 68,234 | 15 | 136,469 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Amugae is in a very large round corridor. The corridor consists of two areas. The inner area is equally divided by n sectors, and the outer area is equally divided by m sectors. A wall exists between each pair of sectors of same area (inner or outer), but there is no wall between the inner area and the outer area. A wall always exists at the 12 o'clock position.
<image>
The inner area's sectors are denoted as (1,1), (1,2), ..., (1,n) in clockwise direction. The outer area's sectors are denoted as (2,1), (2,2), ..., (2,m) in the same manner. For a clear understanding, see the example image above.
Amugae wants to know if he can move from one sector to another sector. He has q questions.
For each question, check if he can move between two given sectors.
Input
The first line contains three integers n, m and q (1 ≤ n, m ≤ 10^{18}, 1 ≤ q ≤ 10^4) — the number of sectors in the inner area, the number of sectors in the outer area and the number of questions.
Each of the next q lines contains four integers s_x, s_y, e_x, e_y (1 ≤ s_x, e_x ≤ 2; if s_x = 1, then 1 ≤ s_y ≤ n, otherwise 1 ≤ s_y ≤ m; constraints on e_y are similar). Amague wants to know if it is possible to move from sector (s_x, s_y) to sector (e_x, e_y).
Output
For each question, print "YES" if Amugae can move from (s_x, s_y) to (e_x, e_y), and "NO" otherwise.
You can print each letter in any case (upper or lower).
Example
Input
4 6 3
1 1 2 3
2 6 1 2
2 6 2 4
Output
YES
NO
YES
Note
Example is shown on the picture in the statement.
Submitted Solution:
```
import sys
from sys import stdin
import math
n,m,q = map(int,stdin.readline().split())
g = n*m // math.gcd(n,m)
ANS = []
for loop in range(q):
sx,sy,ex,ey = map(int,stdin.readline().split())
sy -= 1
ey -= 1
if sx == 1:
t1 = m * sy
else:
t1 = n * sy
if ex == 1:
t2 = m * ey
else:
t2 = n * ey
#print (t1,t2)
if t1 // g == t2 // g:
ANS.append("YES")
else:
ANS.append("NO")
print ("\n".join(ANS))
``` | instruction | 0 | 68,235 | 15 | 136,470 |
Yes | output | 1 | 68,235 | 15 | 136,471 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Amugae is in a very large round corridor. The corridor consists of two areas. The inner area is equally divided by n sectors, and the outer area is equally divided by m sectors. A wall exists between each pair of sectors of same area (inner or outer), but there is no wall between the inner area and the outer area. A wall always exists at the 12 o'clock position.
<image>
The inner area's sectors are denoted as (1,1), (1,2), ..., (1,n) in clockwise direction. The outer area's sectors are denoted as (2,1), (2,2), ..., (2,m) in the same manner. For a clear understanding, see the example image above.
Amugae wants to know if he can move from one sector to another sector. He has q questions.
For each question, check if he can move between two given sectors.
Input
The first line contains three integers n, m and q (1 ≤ n, m ≤ 10^{18}, 1 ≤ q ≤ 10^4) — the number of sectors in the inner area, the number of sectors in the outer area and the number of questions.
Each of the next q lines contains four integers s_x, s_y, e_x, e_y (1 ≤ s_x, e_x ≤ 2; if s_x = 1, then 1 ≤ s_y ≤ n, otherwise 1 ≤ s_y ≤ m; constraints on e_y are similar). Amague wants to know if it is possible to move from sector (s_x, s_y) to sector (e_x, e_y).
Output
For each question, print "YES" if Amugae can move from (s_x, s_y) to (e_x, e_y), and "NO" otherwise.
You can print each letter in any case (upper or lower).
Example
Input
4 6 3
1 1 2 3
2 6 1 2
2 6 2 4
Output
YES
NO
YES
Note
Example is shown on the picture in the statement.
Submitted Solution:
```
from sys import stdin
import math
inp = lambda: stdin.readline().strip()
n, m, q = [int(x) for x in inp().split()]
for _ in range(q):
a1, s1, a2, s2 = [int(x) for x in inp().split()]
firstPlace = 0
secPlace = 0
s1-=1
s2-=1
if a1 == 1:
s1 //= n//math.gcd(n,m)
else:
s1 //= m//math.gcd(n,m)
if a2 == 1:
s2 //= m//math.gcd(n,m)
else:
s2 //= m // math.gcd(n,m)
if s1 == s2:
print("YES")
else:
print("NO")
``` | instruction | 0 | 68,237 | 15 | 136,474 |
No | output | 1 | 68,237 | 15 | 136,475 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Amugae is in a very large round corridor. The corridor consists of two areas. The inner area is equally divided by n sectors, and the outer area is equally divided by m sectors. A wall exists between each pair of sectors of same area (inner or outer), but there is no wall between the inner area and the outer area. A wall always exists at the 12 o'clock position.
<image>
The inner area's sectors are denoted as (1,1), (1,2), ..., (1,n) in clockwise direction. The outer area's sectors are denoted as (2,1), (2,2), ..., (2,m) in the same manner. For a clear understanding, see the example image above.
Amugae wants to know if he can move from one sector to another sector. He has q questions.
For each question, check if he can move between two given sectors.
Input
The first line contains three integers n, m and q (1 ≤ n, m ≤ 10^{18}, 1 ≤ q ≤ 10^4) — the number of sectors in the inner area, the number of sectors in the outer area and the number of questions.
Each of the next q lines contains four integers s_x, s_y, e_x, e_y (1 ≤ s_x, e_x ≤ 2; if s_x = 1, then 1 ≤ s_y ≤ n, otherwise 1 ≤ s_y ≤ m; constraints on e_y are similar). Amague wants to know if it is possible to move from sector (s_x, s_y) to sector (e_x, e_y).
Output
For each question, print "YES" if Amugae can move from (s_x, s_y) to (e_x, e_y), and "NO" otherwise.
You can print each letter in any case (upper or lower).
Example
Input
4 6 3
1 1 2 3
2 6 1 2
2 6 2 4
Output
YES
NO
YES
Note
Example is shown on the picture in the statement.
Submitted Solution:
```
import math
import sys
import collections
# imgur.com/Pkt7iIf.png
def getdict(n):
d = {}
if type(n) is list:
for i in n:
if i in d:
d[i] += 1
else:
d[i] = 1
else:
for i in range(n):
t = ii()
if t in d:
d[t] += 1
else:
d[t] = 1
return d
def cdiv(n, k): return n // k + (n % k != 0)
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(map(int, input().split()))
def lcm(a, b):
return abs(a*b) // math.gcd(a, b)
n, m, q = mi()
x = 360/n
y = 360/m
t = 360/math.gcd(n, m)
for i in range(q):
sx, sy, ex, ey = mi()
s = cdiv((x * sy), t) if sx == 1 else cdiv((y * sy), t)
e = cdiv((x * ey), t) if ex == 1 else cdiv((y * ey), t)
print('YES') if s == e else print('NO')
``` | instruction | 0 | 68,238 | 15 | 136,476 |
No | output | 1 | 68,238 | 15 | 136,477 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Amugae is in a very large round corridor. The corridor consists of two areas. The inner area is equally divided by n sectors, and the outer area is equally divided by m sectors. A wall exists between each pair of sectors of same area (inner or outer), but there is no wall between the inner area and the outer area. A wall always exists at the 12 o'clock position.
<image>
The inner area's sectors are denoted as (1,1), (1,2), ..., (1,n) in clockwise direction. The outer area's sectors are denoted as (2,1), (2,2), ..., (2,m) in the same manner. For a clear understanding, see the example image above.
Amugae wants to know if he can move from one sector to another sector. He has q questions.
For each question, check if he can move between two given sectors.
Input
The first line contains three integers n, m and q (1 ≤ n, m ≤ 10^{18}, 1 ≤ q ≤ 10^4) — the number of sectors in the inner area, the number of sectors in the outer area and the number of questions.
Each of the next q lines contains four integers s_x, s_y, e_x, e_y (1 ≤ s_x, e_x ≤ 2; if s_x = 1, then 1 ≤ s_y ≤ n, otherwise 1 ≤ s_y ≤ m; constraints on e_y are similar). Amague wants to know if it is possible to move from sector (s_x, s_y) to sector (e_x, e_y).
Output
For each question, print "YES" if Amugae can move from (s_x, s_y) to (e_x, e_y), and "NO" otherwise.
You can print each letter in any case (upper or lower).
Example
Input
4 6 3
1 1 2 3
2 6 1 2
2 6 2 4
Output
YES
NO
YES
Note
Example is shown on the picture in the statement.
Submitted Solution:
```
from math import gcd
m, n, q = map(int, input().split())
x = gcd(m, n)
p, q = m // x, n // x
for _ in range(q):
sx, sy, ex, ey = map(int, input().split())
sy -= 1
ey -= 1
if(sx == 1):
s = sy // p
else:
s = sy // q
if(ex == 1):
e = ey // p
else:
e = ey // q
if(s == e):
print('YES')
else:
print('NO')
``` | instruction | 0 | 68,240 | 15 | 136,480 |
No | output | 1 | 68,240 | 15 | 136,481 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) → (x, y+1);
* 'D': go down, (x, y) → (x, y-1);
* 'L': go left, (x, y) → (x-1, y);
* 'R': go right, (x, y) → (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 ≤ a, b ≤ 109). The second line contains a string s (1 ≤ |s| ≤ 100, s only contains characters 'U', 'D', 'L', 'R') — the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) → (1, 0) → (1, 1) → (2, 1) → (2, 2) → ...
So it can reach (2, 2) but not (1, 2). | instruction | 0 | 68,445 | 15 | 136,890 |
Tags: binary search, implementation, math
Correct Solution:
```
target = tuple(map(int, input().split()))
s = input()
#print(target)
#print(s)
ok = False
pos = (0, 0)
for c in s:
if c == 'L': pos = (pos[0]-1, pos[1])
if c == 'R': pos = (pos[0]+1, pos[1])
if c == 'U': pos = (pos[0], pos[1]+1)
if c == 'D': pos = (pos[0], pos[1]-1)
if pos == target: ok = True
if pos == (0, 0): #termin pe pozitia din care am pornit
if ok: print('Yes')
else: print('No')
exit()
if pos[0] == 0:
if target[1] * pos[1] < 0: raport = 0
else: raport = target[1] // pos[1]
else:
if target[0] * pos[0] < 0: raport = 0
else: raport = target[0] // pos[0]
if raport > 0: raport = max(0, raport - 1000)
if raport < 0: raport = min(0, raport + 1000)
#print('Ajung in (%i, %i) dupa o executie, si raport = %i' %(pos[0], pos[1], raport))
coord = (pos[0] * raport, pos[1]*raport)
for rep in range(0, 5000):
if coord == target: ok = True
for c in s:
if c == 'L': coord = (coord[0]-1, coord[1])
if c == 'R': coord = (coord[0]+1, coord[1])
if c == 'U': coord = (coord[0], coord[1]+1)
if c == 'D': coord = (coord[0], coord[1]-1)
if coord == target: ok = True
if ok: print('Yes')
else: print('No')
``` | output | 1 | 68,445 | 15 | 136,891 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) → (x, y+1);
* 'D': go down, (x, y) → (x, y-1);
* 'L': go left, (x, y) → (x-1, y);
* 'R': go right, (x, y) → (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 ≤ a, b ≤ 109). The second line contains a string s (1 ≤ |s| ≤ 100, s only contains characters 'U', 'D', 'L', 'R') — the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) → (1, 0) → (1, 1) → (2, 1) → (2, 2) → ...
So it can reach (2, 2) but not (1, 2). | instruction | 0 | 68,446 | 15 | 136,892 |
Tags: binary search, implementation, math
Correct Solution:
```
# https://codeforces.com/problemset/problem/321/A
def reachable(target, position, vector):
x, y = vector
dx = target[0] - position[0]
dy = target[1] - position[1]
if x == y == dx == dy == 0:
return True
if x == 0:
if dx != 0:
return False
elif y != 0:
return (dy % y == 0) and (dy / y >= 0)
if y == 0:
if dy != 0:
return False
elif x != 0:
return (dx % x == 0) and (dx / x >= 0)
return (dx / x == dy / y) and (dx / x >= 0) and (dx % x == 0)
def possible(target, moves, net):
p = [0, 0]
if reachable(target, p, net):
return True
for move in moves:
if move == "U":
p[1] += 1
elif move == "D":
p[1] -= 1
elif move == "R":
p[0] += 1
elif move == "L":
p[0] -= 1
if reachable(target, p, net):
return True
return False
target = tuple(map(int, input().split()))
moves = input()
net = [0, 0]
for move in moves:
if move == "U":
net[1] += 1
elif move == "D":
net[1] -= 1
elif move == "R":
net[0] += 1
elif move == "L":
net[0] -= 1
if possible(target, moves, net):
print("Yes")
else:
print("No")
``` | output | 1 | 68,446 | 15 | 136,893 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) → (x, y+1);
* 'D': go down, (x, y) → (x, y-1);
* 'L': go left, (x, y) → (x-1, y);
* 'R': go right, (x, y) → (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 ≤ a, b ≤ 109). The second line contains a string s (1 ≤ |s| ≤ 100, s only contains characters 'U', 'D', 'L', 'R') — the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) → (1, 0) → (1, 1) → (2, 1) → (2, 2) → ...
So it can reach (2, 2) but not (1, 2). | instruction | 0 | 68,447 | 15 | 136,894 |
Tags: binary search, implementation, math
Correct Solution:
```
a,b = map(int,input().split())
s = list(input())
dist = a*a + b*b
lis=[[0,0]]
ver=hor=0
for i in s:
if i=='U':
ver+=1
elif i=='D':
ver-=1
elif i=='R':
hor+=1
else:
hor-=1
lis.append([hor,ver])
flag=1
if [a,b] in lis:
print("Yes")
exit()
for i in lis:
if [a,b]==[i[0]+lis[-1][0] , i[1]+lis[-1][0]]:
print("Yes")
exit()
for i in range(len(lis)):
l=0
r=100000000000
c,d = lis[i]
while l<=r:
mid = l +(r-l)//2
e = mid*(lis[-1][0])
f = mid*(lis[-1][1])
if (e+c)**2 + (f+d)**2 < dist:
l = mid+1
else:
r = mid-1
if [l*(lis[-1][0])+c , l*(lis[-1][1])+d]==[a,b]:
print("Yes")
flag=0
break
elif [r*(lis[-1][0])+c , r*(lis[-1][1])+d]==[a,b]:
print("Yes")
flag=0
break
if flag:
print("No")
``` | output | 1 | 68,447 | 15 | 136,895 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) → (x, y+1);
* 'D': go down, (x, y) → (x, y-1);
* 'L': go left, (x, y) → (x-1, y);
* 'R': go right, (x, y) → (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 ≤ a, b ≤ 109). The second line contains a string s (1 ≤ |s| ≤ 100, s only contains characters 'U', 'D', 'L', 'R') — the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) → (1, 0) → (1, 1) → (2, 1) → (2, 2) → ...
So it can reach (2, 2) but not (1, 2). | instruction | 0 | 68,448 | 15 | 136,896 |
Tags: binary search, implementation, math
Correct Solution:
```
#http://codeforces.com/problemset/problem/321/A
import logging as log
class Point(object):
def __init__(self, x,y):
self.x, self.y = x, y
def __str__(self):
return "({}, {})".format(self.x, self.y)
def __add__(self, other):
#add 2 points together
return Point(self.x + other.x, self.y + other.y)
def __sub__(self, other):
#substract 2 points from each other
return Point((other.x < self.x) & (self.x - other.x), (other.y < self.y) & (self.y - other.y))
def __truediv__(self, other):
#devide 2 points, return an integer of how many times the other is bigger than the current point
if other.x == 0:
return Point(0, self.y/other.y)
elif other.y == 0:
return Point(self.x/other.x, 0)
else:
return Point(self.x/other.x, self.y/other.y)
def __mul__(self, other):
#multiply 2 points
return Point(self.x * other, self.y*other)
def __eq__(self, other):
#check if two points are equal
return self.x == other.x and self.y == other.y
class CMDSeq(object):
#mapping between commnads and change in X-Y co-ordinates in Point co-ordinates
trans={ "U":Point(0, 1),
"D":Point(0, -1),
"R":Point(1, 0),
"L":Point(-1, 0)}
def __init__(self, seq):
self.seq = seq
#a dictionary that saves the movesin a command sequence
self.seq_delta = {k:0 for k in 'LURD'}
self.parse_cmdseq()
self.hori_delta = self.seq_delta['R'] - self.seq_delta['L']
self.vert_delta = self.seq_delta['U'] - self.seq_delta['D']
self.delta = Point(self.hori_delta, self.vert_delta)
self.max_hori_delta = max(self.seq_delta['R'], self.seq_delta['L'])
self.max_vert_delta = max(self.seq_delta['U'], self.seq_delta['D'])
self.loopback_factor = max( max(self.max_hori_delta - self.hori_delta, 0),\
max(self.max_vert_delta - self.vert_delta, 0))
self.is_loop = self.hori_delta == self.vert_delta == 0
def parse_cmdseq(self):
"""translates the cmd_seq to fill the seq_delta (counts how many moves in each direction)
"""
for i in self.seq:
self.seq_delta[i] += 1
def repeat_ratio(self, point):
return point/Point(self.hori_delta, self.vert_delta)
def __str__(self):
return "%s"%(self.seq)
def Robot():
log.basicConfig(format='%(levelname)s:%(message)s', level=log.CRITICAL)
#log.basicConfig(format='%(levelname)s:%(message)s', level=log.DEBUG)
#end point
end = Point(*[*map(int, input().split())])
log.debug('End point: %s.', end)
#command sequence
cmd = CMDSeq(input())
log.info('Command sequence: %s.', cmd.seq)
log.info('Command sequence delta: (%s, %s).', cmd.hori_delta, cmd.vert_delta)
log.debug('Command max hori delta: %s.', cmd.max_hori_delta)
log.debug('Command max vert delta: %s.', cmd.max_vert_delta)
log.debug('Command loopback ratio: %s.', cmd.loopback_factor)
""" -If the end_point is at a totally different quarter, return No.
-If the end_point is equal to origin, return Yes (we always start at origin no matter what the
command sequence is!)
-else If the command sequence is a closed loop, new_start is at origin (0,0)
-else:
- Calculate the minimum number of full sequence repetitions before to get the
the closes to the end point. (end / cmd.delta).
- If the result is an integer >>> return Yes (new_start = repetition*cmd_delta)
- else:
new_start = cmd_delta*max(repetition - loopback, 0)
- Start from new point then move through the sequence one step at a time and check if we
reached the end point, if not, return 'No'
"""
if end == Point(0, 0):
log.debug('!!! End point is (0,0) !!!')
return "Yes"
elif cmd.is_loop:
log.debug('Command sequence is a closed loop!')
new_start_a = Point(0, 0)
new_start_b = Point(0, 0)
else:
repeat = cmd.repeat_ratio(end)
log.debug('Repeat point: %s', repeat)
if repeat.x == 0:
repeat = repeat.y
elif repeat.y ==0:
repeat = repeat.x
else:
repeat = min(repeat.x, repeat.y)
log.debug('Repeat: %s', repeat)
new_start_a = cmd.delta*max(int(repeat) - cmd.loopback_factor - 1, 0)
new_start_b = cmd.delta*max(int(repeat) - cmd.loopback_factor, 0)
log.info('New start A: %s', new_start_a)
log.info('New start B: %s', new_start_b)
log.debug('------\nWalking the robot:')
#add the sequence to the new_start point, return YES if we hit the end point
for rep in range(cmd.loopback_factor + 1):
for i in cmd.seq:
log.debug('Current command: %s', i)
if new_start_a == end or new_start_b == end:
return "Yes"
new_start_a += CMDSeq.trans[i]
new_start_b += CMDSeq.trans[i]
log.debug('Modified start A: %s.', new_start_a)
log.debug('Modified start B: %s.', new_start_b)
return "Yes" if (new_start_a == end) or (new_start_b == end) else "No"
if __name__ == '__main__':
a = Robot()
print(a)
``` | output | 1 | 68,448 | 15 | 136,897 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) → (x, y+1);
* 'D': go down, (x, y) → (x, y-1);
* 'L': go left, (x, y) → (x-1, y);
* 'R': go right, (x, y) → (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 ≤ a, b ≤ 109). The second line contains a string s (1 ≤ |s| ≤ 100, s only contains characters 'U', 'D', 'L', 'R') — the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) → (1, 0) → (1, 1) → (2, 1) → (2, 2) → ...
So it can reach (2, 2) but not (1, 2). | instruction | 0 | 68,449 | 15 | 136,898 |
Tags: binary search, implementation, math
Correct Solution:
```
a, b = map(int, input().split())
s = input()
p = [[0, 0]]
d = {'R': (1, 0), 'L': (-1, 0), 'U': (0, 1), 'D': (0, -1)}
for c in s:
p.append([p[-1][0] + d[c][0], p[-1][1] + d[c][1]])
px, py = p[-1][0], p[-1][1]
for x, y in p:
k = 0
if px:
k = (a - x) // px
elif py:
k = (b - y) // py
if k >= 0 and x + k * px == a and y + k * py == b:
print('Yes')
break
else:
print('No')
``` | output | 1 | 68,449 | 15 | 136,899 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) → (x, y+1);
* 'D': go down, (x, y) → (x, y-1);
* 'L': go left, (x, y) → (x-1, y);
* 'R': go right, (x, y) → (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 ≤ a, b ≤ 109). The second line contains a string s (1 ≤ |s| ≤ 100, s only contains characters 'U', 'D', 'L', 'R') — the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) → (1, 0) → (1, 1) → (2, 1) → (2, 2) → ...
So it can reach (2, 2) but not (1, 2). | instruction | 0 | 68,450 | 15 | 136,900 |
Tags: binary search, implementation, math
Correct Solution:
```
import sys
ox,oy = map(int,sys.stdin.readline().split()) # original position
s= sys.stdin.readline()
h = 0
v = 0
# here we calculate the distance to target position after one simulation
for i in range (len(s)):
if s[i] == 'R':
h+=1
if s[i] == 'L':
h-= 1
if s[i] == 'U':
v+=1
if s[i] == 'D':
v -=1
def bs (l,r,a,b,rx,ry):
l1 = l
r1 = r
a1 = a
b1 = b
# print("ox:",a," oy:",b)
while (l1 <= r1):
mid = (l1+r1)//2
a1 =a+h*mid
b1 =b+v*mid
# print (" a1:",a1," b1:",b1)
# print (" l1:",l1," r1:",r1)
# print (" mid:",mid)
if (rx == a1 and ry == b1):
return 0
if (rx - a1) * h == 0:
if (ry - b1)* v >0:
l1 = mid +1
elif (ry - b1)* v < 0:
r1 = mid -1
else:
return -1
if (ry - b1)* v == 0 :
if (rx - a1) * h >0:
l1 = mid +1
elif (rx - a1) * h <0 :
r1 = mid -1
else :
return -1
if (rx - a1)*h != 0 and (ry - b1)* v !=0:
if (rx - a1)*h > 0 and (ry - b1)* v >0 :
l1 = mid+1
elif (rx - a1)*h <0 and (ry - b1)* v <0 :
r1 = mid-1
else :
return -1
return -1
a=0
b=0
pos = bs (0,10**9,a,b,ox,oy)
kt = False
if pos == 0:
print("Yes")
kt = True
if kt == False :
for i in range (len(s)):
if s[i] == 'R':
a +=1
if s[i] == 'L':
a -= 1
if s[i] == 'U':
b +=1
if s[i] == 'D':
b -=1
pos= bs (0,10**9,a,b,ox,oy)
if pos == 0 :
print ("Yes")
kt = True
break
if kt == False :
print ("No")
``` | output | 1 | 68,450 | 15 | 136,901 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) → (x, y+1);
* 'D': go down, (x, y) → (x, y-1);
* 'L': go left, (x, y) → (x-1, y);
* 'R': go right, (x, y) → (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 ≤ a, b ≤ 109). The second line contains a string s (1 ≤ |s| ≤ 100, s only contains characters 'U', 'D', 'L', 'R') — the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) → (1, 0) → (1, 1) → (2, 1) → (2, 2) → ...
So it can reach (2, 2) but not (1, 2). | instruction | 0 | 68,451 | 15 | 136,902 |
Tags: binary search, implementation, math
Correct Solution:
```
go = {'U' : (0, 1), 'D' : (0, -1), 'R' : (1, 0), 'L' : (-1, 0)}
a, b = map(int, input().split())
s = input()
dx = dy = x = y = cx = cy = 0
for c in s:
dx += go[c][0]
dy += go[c][1]
ans = a == b == 0
for c in s:
x += go[c][0]
y += go[c][1]
cx, cy = a - x, b - y
flg = False
if dx: flg = not cx % dx and cx // dx >= 0
else: flg = not cx
if dy: flg = flg and not cy % dy and cy // dy >= 0
else: flg = flg and not cy
flg = flg and (not dx or not dy or cx // dx == cy // dy)
if flg:
ans = True
break
print("Yes" if ans else "No")
``` | output | 1 | 68,451 | 15 | 136,903 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) → (x, y+1);
* 'D': go down, (x, y) → (x, y-1);
* 'L': go left, (x, y) → (x-1, y);
* 'R': go right, (x, y) → (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 ≤ a, b ≤ 109). The second line contains a string s (1 ≤ |s| ≤ 100, s only contains characters 'U', 'D', 'L', 'R') — the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) → (1, 0) → (1, 1) → (2, 1) → (2, 2) → ...
So it can reach (2, 2) but not (1, 2). | instruction | 0 | 68,452 | 15 | 136,904 |
Tags: binary search, implementation, math
Correct Solution:
```
R = lambda: map(int, input().split())
a, b = R()
cs = [[0, 0]]
d = {'R': (1, 0), 'L': (-1, 0), 'U': (0, 1), 'D': (0, -1)}
for c in input():
cs.append([cs[-1][0] + d[c][0], cs[-1][1] + d[c][1]])
px, py = cs[-1][0], cs[-1][1]
for x, y in cs:
k = 0
if px:
k = (a - x) // px
elif py:
k = (b - y) // py
if k >= 0 and x + k * px == a and y + k * py == b:
print('Yes')
exit(0)
print('No')
``` | output | 1 | 68,452 | 15 | 136,905 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) → (x, y+1);
* 'D': go down, (x, y) → (x, y-1);
* 'L': go left, (x, y) → (x-1, y);
* 'R': go right, (x, y) → (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 ≤ a, b ≤ 109). The second line contains a string s (1 ≤ |s| ≤ 100, s only contains characters 'U', 'D', 'L', 'R') — the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) → (1, 0) → (1, 1) → (2, 1) → (2, 2) → ...
So it can reach (2, 2) but not (1, 2).
Submitted Solution:
```
dx = {'U': 0, 'D': 0, 'L': -1, 'R': 1}
dy = {'U': 1, 'D': -1, 'L': 0, 'R': 0}
x, y, xl, yl = 0, 0, [], []
a, b = map(int, input().split())
for ch in input():
xl.append(x)
yl.append(y)
x += dx[ch]
y += dy[ch]
for xi, yi in zip(xl, yl):
mx, my = a - xi, b - yi
if x == 0 and mx != 0 or x != 0 and (mx % x != 0 or mx // x < 0):
continue
if y == 0 and my != 0 or y != 0 and (my % y != 0 or my // y < 0):
continue
if x != 0 and y != 0 and mx // x != my // y:
continue
print('Yes')
exit()
print('No')
# Made By Mostafa_Khaled
``` | instruction | 0 | 68,453 | 15 | 136,906 |
Yes | output | 1 | 68,453 | 15 | 136,907 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) → (x, y+1);
* 'D': go down, (x, y) → (x, y-1);
* 'L': go left, (x, y) → (x-1, y);
* 'R': go right, (x, y) → (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 ≤ a, b ≤ 109). The second line contains a string s (1 ≤ |s| ≤ 100, s only contains characters 'U', 'D', 'L', 'R') — the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) → (1, 0) → (1, 1) → (2, 1) → (2, 2) → ...
So it can reach (2, 2) but not (1, 2).
Submitted Solution:
```
#!/usr/bin/python3
import sys
MAPPING = {
'U': (0, 1),
'D': (0, -1),
'L': (-1, 0),
'R': (1, 0),
}
def read_ints():
return [int(x) for x in input().split()]
def get_vectors(moves):
vector = (0, 0)
yield vector
for move in moves:
delta = MAPPING[move]
vector = (vector[0] + delta[0], vector[1] + delta[1])
yield vector
def mul(pair, a):
return pair[0] * a, pair[1] * a
def is_achievable(diff, period):
if diff == (0, 0):
return True
if period == (0, 0):
return False
if period[0] != 0:
if diff[0] % period[0] == 0:
times = diff[0] // period[0]
if times > 0 and mul(period, times) == diff:
return True
if period[1] != 0:
if diff[1] % period[1] == 0:
times = diff[1] // period[1]
if times > 0 and mul(period, times) == diff:
return True
return False
def main():
a, b = read_ints()
moves = input().strip()
vectors = list(get_vectors(moves))
period = vectors[-1]
for vector in vectors:
diff = (a - vector[0], b - vector[1])
if is_achievable(diff, period):
print('Yes')
sys.exit(0)
print('No')
if __name__ == '__main__':
main()
``` | instruction | 0 | 68,454 | 15 | 136,908 |
Yes | output | 1 | 68,454 | 15 | 136,909 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) → (x, y+1);
* 'D': go down, (x, y) → (x, y-1);
* 'L': go left, (x, y) → (x-1, y);
* 'R': go right, (x, y) → (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 ≤ a, b ≤ 109). The second line contains a string s (1 ≤ |s| ≤ 100, s only contains characters 'U', 'D', 'L', 'R') — the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) → (1, 0) → (1, 1) → (2, 1) → (2, 2) → ...
So it can reach (2, 2) but not (1, 2).
Submitted Solution:
```
d={'U':(0,1),'D':(0,-1),'R':(1,0),'L':(-1,0)}
x,y=[int(i) for i in input().split()]
path=input()
c={}
c[0]=(0,0)
dx,dy=0,0
for i in range(len(path)):
dx,dy=dx+d[path[i]][0],dy+d[path[i]][1]
x1,y1=c[i][0]+d[path[i]][0],c[i][1]+d[path[i]][1]
c[i+1]=(x1,y1)
if (x,y) in c.values(): print('Yes')
else:
for i in range(1,len(c)):
if dy!=0 and dx!=0 and (x-c[i][0])/dx==(y-c[i][1])/dy and (x-c[i][0])%dx==0 and (y-c[i][1])/dy>=0:
print('Yes'); break
elif dx==0 and dy!=0:
if (y-c[i][1])%dy==0 and (y-c[i][1])/dy>0 and c[i][0]==x:print('Yes');break
elif dy==0 and dx!=0:
if (x-c[i][0])%dx==0 and (x-c[i][0])/dx>0 and c[i][1]==y:print('Yes'); break
else: print('No')
``` | instruction | 0 | 68,455 | 15 | 136,910 |
Yes | output | 1 | 68,455 | 15 | 136,911 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) → (x, y+1);
* 'D': go down, (x, y) → (x, y-1);
* 'L': go left, (x, y) → (x-1, y);
* 'R': go right, (x, y) → (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 ≤ a, b ≤ 109). The second line contains a string s (1 ≤ |s| ≤ 100, s only contains characters 'U', 'D', 'L', 'R') — the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) → (1, 0) → (1, 1) → (2, 1) → (2, 2) → ...
So it can reach (2, 2) but not (1, 2).
Submitted Solution:
```
from math import hypot
a,b = map(int,input().split())
s = input().strip()
dx,dy = 0,0
for i in s:
if dx==a and dy==b:
print('Yes')
exit()
if i =='R':
dx+=1
if i=='L':
dx-=1
if i=='D':
dy-=1
if i=='U':
dy+=1
if dx==a and dy==b:
print('Yes')
exit(0)
if dx==dy==0:
print('No')
exit(0)
lngt = int(max(0,hypot(a,b)/hypot(dx,dy)-500))
x,y = dx*lngt,dy*lngt
for j in range(1000):
for i in s:
if x==a and y==b:
print('Yes')
exit(0)
if i =='R':
x+=1
if i=='L':
x-=1
if i=='D':
y-=1
if i=='U':
y+=1
if x==a and y==b:
print('Yes')
exit(0)
print('No')
``` | instruction | 0 | 68,456 | 15 | 136,912 |
Yes | output | 1 | 68,456 | 15 | 136,913 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) → (x, y+1);
* 'D': go down, (x, y) → (x, y-1);
* 'L': go left, (x, y) → (x-1, y);
* 'R': go right, (x, y) → (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 ≤ a, b ≤ 109). The second line contains a string s (1 ≤ |s| ≤ 100, s only contains characters 'U', 'D', 'L', 'R') — the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) → (1, 0) → (1, 1) → (2, 1) → (2, 2) → ...
So it can reach (2, 2) but not (1, 2).
Submitted Solution:
```
X = {"R": 1, "L": -1, "U": 0, "D": 0}
Y = {"R": 0, "L": 0, "U": 1, "D": -1}
a, b = map(int, input().split())
s = input()
dx, dy = 0, 0
for c in s:
dx += X[c]
dy += Y[c]
ret = False
if dx == 0 or dy == 0:
ret = True
else:
cx, cy = 0, 0
if dx == 0:
dx = 1
if dy == 0:
dy = 1
for c in s:
cx += X[c]
cy += Y[c]
if (a - cx) % dx == 0 and (b - cy) % dy == 0 and \
(a - cx) // dx == (b - cy) // dy and (b - cy) // dy >= 0:
ret = True
if ret:
print("Yes")
else:
print("No")
``` | instruction | 0 | 68,457 | 15 | 136,914 |
No | output | 1 | 68,457 | 15 | 136,915 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) → (x, y+1);
* 'D': go down, (x, y) → (x, y-1);
* 'L': go left, (x, y) → (x-1, y);
* 'R': go right, (x, y) → (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 ≤ a, b ≤ 109). The second line contains a string s (1 ≤ |s| ≤ 100, s only contains characters 'U', 'D', 'L', 'R') — the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) → (1, 0) → (1, 1) → (2, 1) → (2, 2) → ...
So it can reach (2, 2) but not (1, 2).
Submitted Solution:
```
#http://codeforces.com/problemset/problem/321/A
import logging as log
class Point(object):
def __init__(self, x,y):
self.x, self.y = x, y
def __str__(self):
return "({}, {})".format(self.x, self.y)
def __add__(self, other):
#add 2 points together
return Point(self.x + other.x, self.y + other.y)
def __sub__(self, other):
#substract 2 points from each other
return Point((other.x < self.x) & (self.x - other.x), (other.y < self.y) & (self.y - other.y))
def __truediv__(self, other):
#devide 2 points, return an integer of how many times the other is bigger than the current point
if other.x == 0:
return Point(0, self.y/other.y)
elif other.y == 0:
return Point(self.x/other.x, 0)
else:
return Point(self.x/other.x, self.y/other.y)
def __mul__(self, other):
#multiply 2 points
return Point(self.x * other, self.y*other)
def __eq__(self, other):
#check if two points are equal
return self.x == other.x and self.y == other.y
class CMDSeq(object):
#mapping between commnads and change in X-Y co-ordinates in Point co-ordinates
trans={ "U":Point(0, 1),
"D":Point(0, -1),
"R":Point(1, 0),
"L":Point(-1, 0)}
def __init__(self, seq):
self.seq = seq
#a dictionary that saves the movesin a command sequence
self.seq_delta = {k:0 for k in 'LURD'}
self.parse_cmdseq()
self.hori_delta = self.seq_delta['R'] - self.seq_delta['L']
self.vert_delta = self.seq_delta['U'] - self.seq_delta['D']
self.delta = Point(self.hori_delta, self.vert_delta)
self.max_hori_delta = max(self.seq_delta['R'], self.seq_delta['L'])
self.max_vert_delta = max(self.seq_delta['U'], self.seq_delta['D'])
self.loopback_factor = max( max(self.max_hori_delta - self.hori_delta, 0),\
max(self.max_vert_delta - self.vert_delta, 0))
self.is_loop = self.hori_delta == self.vert_delta == 0
def parse_cmdseq(self):
"""translates the cmd_seq to fill the seq_delta (counts how many moves in each direction)
"""
for i in self.seq:
self.seq_delta[i] += 1
def in_domain(self, other):
return (self.hori_delta*other.x > 0) or (self.vert_delta * other.y > 0)
def repeat_ratio(self, point):
return point/Point(self.hori_delta, self.vert_delta)
def __str__(self):
return "%s"%(self.seq)
def Robot():
log.basicConfig(format='%(levelname)s:%(message)s', level=log.CRITICAL)
#log.basicConfig(format='%(levelname)s:%(message)s', level=log.DEBUG)
#end point
end = Point(*[*map(int, input().split())])
log.debug('End point: %s.', end)
#command sequence
cmd = CMDSeq(input())
log.info('Command sequence: %s.', cmd.seq)
log.info('Command sequence delta: (%s, %s).', cmd.hori_delta, cmd.vert_delta)
log.debug('Command max hori delta: %s.', cmd.max_hori_delta)
log.debug('Command max vert delta: %s.', cmd.max_vert_delta)
log.debug('Command loopback ratio: %s.', cmd.loopback_factor)
""" -If the end_point is at a totally different quarter, return No.
-If the end_point is equal to origin, return Yes (we always start at origin no matter what the
command sequence is!)
-else If the command sequence is a closed loop, new_start is at origin (0,0)
-else:
- Calculate the minimum number of full sequence repetitions before to get the
the closes to the end point. (end / cmd.delta).
- If the result is an integer >>> return Yes (new_start = repetition*cmd_delta)
- else:
new_start = cmd_delta*max(repetition - loopback, 0)
- Start from new point then move through the sequence one step at a time and check if we
reached the end point, if not, return 'No'
"""
if end == Point(0, 0):
log.debug('!!! End point is (0,0) !!!')
return "Yes"
elif not cmd.in_domain(end):
log.debug('End point is out of the command sequence domain!')
return "No"
elif cmd.is_loop:
log.debug('Command sequence is a closed loop!')
new_start = Point(0, 0)
else:
repeat = cmd.repeat_ratio(end)
if repeat.x == 0:
repeat = repeat.y
elif repeat.y ==0:
repeat = repeat.x
else:
repeat = min(repeat.x, repeat.y)
log.debug('Repeat: %s', repeat)
if repeat%1:
new_start = cmd.delta*max(int(repeat) - cmd.loopback_factor, 0)
else:
new_start = cmd.delta*int(repeat)
log.info('New start: %s', new_start)
log.debug('------\nWalking the robot:')
#add the sequence to the new_start point, return YES if we hit the end point
for rep in range(cmd.loopback_factor + 1):
for i in cmd.seq:
log.debug('Current command: %s', i)
if new_start == end:
return "Yes"
new_start += CMDSeq.trans[i]
log.debug('Modified start: %s.', new_start)
return "Yes" if (new_start == end) else "No"
if __name__ == '__main__':
a = Robot()
print(a)
``` | instruction | 0 | 68,458 | 15 | 136,916 |
No | output | 1 | 68,458 | 15 | 136,917 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) → (x, y+1);
* 'D': go down, (x, y) → (x, y-1);
* 'L': go left, (x, y) → (x-1, y);
* 'R': go right, (x, y) → (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 ≤ a, b ≤ 109). The second line contains a string s (1 ≤ |s| ≤ 100, s only contains characters 'U', 'D', 'L', 'R') — the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) → (1, 0) → (1, 1) → (2, 1) → (2, 2) → ...
So it can reach (2, 2) but not (1, 2).
Submitted Solution:
```
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
# from fractions import *
# from heapq import*
from bisect import *
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
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")
ALPHA='abcdefghijklmnopqrstuvwxyz'
M=998244353
EPS=1e-6
def Ceil(a,b): return a//b+int(a%b>0)
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
# vsInput()
def dif(a,b):
if(a > 0 and b < 0): return True
if(b > 0 and a < 0): return True
return False
a,b = value()
s = input()
C = Counter(s)
X = C['R'] - C['L']
Y = C['U'] - C['D']
x = 0
y = 0
ans = "No"
if(x,y == a,b): ans = "Yes"
for i in s:
if(i == 'R'): x += 1
elif(i == 'L'): x -= 1
elif(i == 'U'): y += 1
else: y -= 1
# print(x,y,X,Y)
need_x = a - x
need_y = b - y
ok = True
if(need_x == 0 or X == 0):
if(need_x != X): ok = False
elif( dif(X,need_x) or abs(need_x)%abs(X)):
ok = False
if(need_y == 0 or Y == 0):
if(need_y != Y): ok = False
elif( dif(Y,need_y) or abs(need_y)%abs(Y)):
ok = False
if(ok): ans = "Yes"
print(ans)
``` | instruction | 0 | 68,459 | 15 | 136,918 |
No | output | 1 | 68,459 | 15 | 136,919 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) → (x, y+1);
* 'D': go down, (x, y) → (x, y-1);
* 'L': go left, (x, y) → (x-1, y);
* 'R': go right, (x, y) → (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 ≤ a, b ≤ 109). The second line contains a string s (1 ≤ |s| ≤ 100, s only contains characters 'U', 'D', 'L', 'R') — the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) → (1, 0) → (1, 1) → (2, 1) → (2, 2) → ...
So it can reach (2, 2) but not (1, 2).
Submitted Solution:
```
x, y = map(int, input().split(' '))
s = input()
dx = 0
dy = 0
for i in range(0, len(s)):
if s[i] == 'U':
dy += 1
if s[i] == 'D':
dy -= 1
if s[i] == 'L':
dx -= 1
if s[i] == 'R':
dx += 1
xx = 0
yy = 0
can = 0
for i in range(0, len(s)):
if s[i] == 'U':
yy += 1
if s[i] == 'D':
yy -= 1
if s[i] == 'L':
xx -= 1
if s[i] == 'R':
xx += 1
nx = x - xx
ny = y - yy
if nx == 0 and ny == 0 and dx == 0 and dy == 0:
can = 1
break
if nx == 0 and ny % dy == 0 and dx == 0:
can = 1
break
if ny == 0 and nx % dx == 0 and dy == 0:
can = 1
break
if nx % dx == 0 and ny % dy == 0 and nx // dx == ny // dy:
can = 1
break
print('Yes' if can else 'No')
``` | instruction | 0 | 68,460 | 15 | 136,920 |
No | output | 1 | 68,460 | 15 | 136,921 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a frog staying to the left of the string s = s_1 s_2 … s_n consisting of n characters (to be more precise, the frog initially stays at the cell 0). Each character of s is either 'L' or 'R'. It means that if the frog is staying at the i-th cell and the i-th character is 'L', the frog can jump only to the left. If the frog is staying at the i-th cell and the i-th character is 'R', the frog can jump only to the right. The frog can jump only to the right from the cell 0.
Note that the frog can jump into the same cell twice and can perform as many jumps as it needs.
The frog wants to reach the n+1-th cell. The frog chooses some positive integer value d before the first jump (and cannot change it later) and jumps by no more than d cells at once. I.e. if the i-th character is 'L' then the frog can jump to any cell in a range [max(0, i - d); i - 1], and if the i-th character is 'R' then the frog can jump to any cell in a range [i + 1; min(n + 1; i + d)].
The frog doesn't want to jump far, so your task is to find the minimum possible value of d such that the frog can reach the cell n+1 from the cell 0 if it can jump by no more than d cells at once. It is guaranteed that it is always possible to reach n+1 from 0.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. The i-th test case is described as a string s consisting of at least 1 and at most 2 ⋅ 10^5 characters 'L' and 'R'.
It is guaranteed that the sum of lengths of strings over all test cases does not exceed 2 ⋅ 10^5 (∑ |s| ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum possible value of d such that the frog can reach the cell n+1 from the cell 0 if it jumps by no more than d at once.
Example
Input
6
LRLRRLL
L
LLR
RRRR
LLLLLL
R
Output
3
2
3
1
7
1
Note
The picture describing the first test case of the example and one of the possible answers:
<image>
In the second test case of the example, the frog can only jump directly from 0 to n+1.
In the third test case of the example, the frog can choose d=3, jump to the cell 3 from the cell 0 and then to the cell 4 from the cell 3.
In the fourth test case of the example, the frog can choose d=1 and jump 5 times to the right.
In the fifth test case of the example, the frog can only jump directly from 0 to n+1.
In the sixth test case of the example, the frog can choose d=1 and jump 2 times to the right. | instruction | 0 | 69,071 | 15 | 138,142 |
Tags: binary search, data structures, dfs and similar, greedy, implementation
Correct Solution:
```
t = int(input())
for _ in range(t):
s = input()
n = len(s)
ind = [0]
for i in range(n):
if s[i] == "R":
ind.append(1+i)
ind.append(n+1)
d = 0
for i in range(1, len(ind)):
d = max(d, ind[i]-ind[i-1])
print(d)
``` | output | 1 | 69,071 | 15 | 138,143 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a frog staying to the left of the string s = s_1 s_2 … s_n consisting of n characters (to be more precise, the frog initially stays at the cell 0). Each character of s is either 'L' or 'R'. It means that if the frog is staying at the i-th cell and the i-th character is 'L', the frog can jump only to the left. If the frog is staying at the i-th cell and the i-th character is 'R', the frog can jump only to the right. The frog can jump only to the right from the cell 0.
Note that the frog can jump into the same cell twice and can perform as many jumps as it needs.
The frog wants to reach the n+1-th cell. The frog chooses some positive integer value d before the first jump (and cannot change it later) and jumps by no more than d cells at once. I.e. if the i-th character is 'L' then the frog can jump to any cell in a range [max(0, i - d); i - 1], and if the i-th character is 'R' then the frog can jump to any cell in a range [i + 1; min(n + 1; i + d)].
The frog doesn't want to jump far, so your task is to find the minimum possible value of d such that the frog can reach the cell n+1 from the cell 0 if it can jump by no more than d cells at once. It is guaranteed that it is always possible to reach n+1 from 0.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. The i-th test case is described as a string s consisting of at least 1 and at most 2 ⋅ 10^5 characters 'L' and 'R'.
It is guaranteed that the sum of lengths of strings over all test cases does not exceed 2 ⋅ 10^5 (∑ |s| ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum possible value of d such that the frog can reach the cell n+1 from the cell 0 if it jumps by no more than d at once.
Example
Input
6
LRLRRLL
L
LLR
RRRR
LLLLLL
R
Output
3
2
3
1
7
1
Note
The picture describing the first test case of the example and one of the possible answers:
<image>
In the second test case of the example, the frog can only jump directly from 0 to n+1.
In the third test case of the example, the frog can choose d=3, jump to the cell 3 from the cell 0 and then to the cell 4 from the cell 3.
In the fourth test case of the example, the frog can choose d=1 and jump 5 times to the right.
In the fifth test case of the example, the frog can only jump directly from 0 to n+1.
In the sixth test case of the example, the frog can choose d=1 and jump 2 times to the right. | instruction | 0 | 69,072 | 15 | 138,144 |
Tags: binary search, data structures, dfs and similar, greedy, implementation
Correct Solution:
```
t = int(input())
for _ in range(t):
s = input()
gl,ll = 1,1
for i in s:
if i=="L":
ll += 1
else:
gl = max(ll,gl)
ll = 1
gl = max(ll,gl)
print(gl)
``` | output | 1 | 69,072 | 15 | 138,145 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a frog staying to the left of the string s = s_1 s_2 … s_n consisting of n characters (to be more precise, the frog initially stays at the cell 0). Each character of s is either 'L' or 'R'. It means that if the frog is staying at the i-th cell and the i-th character is 'L', the frog can jump only to the left. If the frog is staying at the i-th cell and the i-th character is 'R', the frog can jump only to the right. The frog can jump only to the right from the cell 0.
Note that the frog can jump into the same cell twice and can perform as many jumps as it needs.
The frog wants to reach the n+1-th cell. The frog chooses some positive integer value d before the first jump (and cannot change it later) and jumps by no more than d cells at once. I.e. if the i-th character is 'L' then the frog can jump to any cell in a range [max(0, i - d); i - 1], and if the i-th character is 'R' then the frog can jump to any cell in a range [i + 1; min(n + 1; i + d)].
The frog doesn't want to jump far, so your task is to find the minimum possible value of d such that the frog can reach the cell n+1 from the cell 0 if it can jump by no more than d cells at once. It is guaranteed that it is always possible to reach n+1 from 0.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. The i-th test case is described as a string s consisting of at least 1 and at most 2 ⋅ 10^5 characters 'L' and 'R'.
It is guaranteed that the sum of lengths of strings over all test cases does not exceed 2 ⋅ 10^5 (∑ |s| ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum possible value of d such that the frog can reach the cell n+1 from the cell 0 if it jumps by no more than d at once.
Example
Input
6
LRLRRLL
L
LLR
RRRR
LLLLLL
R
Output
3
2
3
1
7
1
Note
The picture describing the first test case of the example and one of the possible answers:
<image>
In the second test case of the example, the frog can only jump directly from 0 to n+1.
In the third test case of the example, the frog can choose d=3, jump to the cell 3 from the cell 0 and then to the cell 4 from the cell 3.
In the fourth test case of the example, the frog can choose d=1 and jump 5 times to the right.
In the fifth test case of the example, the frog can only jump directly from 0 to n+1.
In the sixth test case of the example, the frog can choose d=1 and jump 2 times to the right. | instruction | 0 | 69,073 | 15 | 138,146 |
Tags: binary search, data structures, dfs and similar, greedy, implementation
Correct Solution:
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
@Time : 2020/3/12 22:30
@Author : Yuki
@File : C.py
@Software: PyCharm
@E-main : fujii20180311@foxmail.com
"""
n = int(input())
for i in range(n):
path = input()
rpos = []
for k in range(len(path)):
if path[k]=='R':
rpos.append(k+1)
rpos.insert(0, 0)
rpos.append(len(path)+1)
Max = 0;
for i in range(len(rpos)-1):
if rpos[i+1]-rpos[i]>Max:
Max = rpos[i+1]-rpos[i]
print(Max)
``` | output | 1 | 69,073 | 15 | 138,147 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a frog staying to the left of the string s = s_1 s_2 … s_n consisting of n characters (to be more precise, the frog initially stays at the cell 0). Each character of s is either 'L' or 'R'. It means that if the frog is staying at the i-th cell and the i-th character is 'L', the frog can jump only to the left. If the frog is staying at the i-th cell and the i-th character is 'R', the frog can jump only to the right. The frog can jump only to the right from the cell 0.
Note that the frog can jump into the same cell twice and can perform as many jumps as it needs.
The frog wants to reach the n+1-th cell. The frog chooses some positive integer value d before the first jump (and cannot change it later) and jumps by no more than d cells at once. I.e. if the i-th character is 'L' then the frog can jump to any cell in a range [max(0, i - d); i - 1], and if the i-th character is 'R' then the frog can jump to any cell in a range [i + 1; min(n + 1; i + d)].
The frog doesn't want to jump far, so your task is to find the minimum possible value of d such that the frog can reach the cell n+1 from the cell 0 if it can jump by no more than d cells at once. It is guaranteed that it is always possible to reach n+1 from 0.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. The i-th test case is described as a string s consisting of at least 1 and at most 2 ⋅ 10^5 characters 'L' and 'R'.
It is guaranteed that the sum of lengths of strings over all test cases does not exceed 2 ⋅ 10^5 (∑ |s| ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum possible value of d such that the frog can reach the cell n+1 from the cell 0 if it jumps by no more than d at once.
Example
Input
6
LRLRRLL
L
LLR
RRRR
LLLLLL
R
Output
3
2
3
1
7
1
Note
The picture describing the first test case of the example and one of the possible answers:
<image>
In the second test case of the example, the frog can only jump directly from 0 to n+1.
In the third test case of the example, the frog can choose d=3, jump to the cell 3 from the cell 0 and then to the cell 4 from the cell 3.
In the fourth test case of the example, the frog can choose d=1 and jump 5 times to the right.
In the fifth test case of the example, the frog can only jump directly from 0 to n+1.
In the sixth test case of the example, the frog can choose d=1 and jump 2 times to the right. | instruction | 0 | 69,074 | 15 | 138,148 |
Tags: binary search, data structures, dfs and similar, greedy, implementation
Correct Solution:
```
def main():
def is_ok(mid, S):
flag = True
from collections import Counter
cur = Counter(S[:mid])
for i in range(len(S)-mid+1):
if mid <= cur["L"]:
flag = False
break
cur[S[i]] -= 1
if i+mid < len(S):
cur[S[i+mid]] += 1
if flag:
return True
else:
return False
def binary_search_meguru(S):
ng = 0
ok = len(S) + 2
while abs(ok - ng) > 1:
mid = ng + (ok - ng) // 2
if is_ok(mid, S):
ok = mid
else:
ng = mid
return ok
Q = int(input())
for query in range(Q):
S = input()
print(binary_search_meguru(S))
if __name__ == '__main__':
main()
``` | output | 1 | 69,074 | 15 | 138,149 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a frog staying to the left of the string s = s_1 s_2 … s_n consisting of n characters (to be more precise, the frog initially stays at the cell 0). Each character of s is either 'L' or 'R'. It means that if the frog is staying at the i-th cell and the i-th character is 'L', the frog can jump only to the left. If the frog is staying at the i-th cell and the i-th character is 'R', the frog can jump only to the right. The frog can jump only to the right from the cell 0.
Note that the frog can jump into the same cell twice and can perform as many jumps as it needs.
The frog wants to reach the n+1-th cell. The frog chooses some positive integer value d before the first jump (and cannot change it later) and jumps by no more than d cells at once. I.e. if the i-th character is 'L' then the frog can jump to any cell in a range [max(0, i - d); i - 1], and if the i-th character is 'R' then the frog can jump to any cell in a range [i + 1; min(n + 1; i + d)].
The frog doesn't want to jump far, so your task is to find the minimum possible value of d such that the frog can reach the cell n+1 from the cell 0 if it can jump by no more than d cells at once. It is guaranteed that it is always possible to reach n+1 from 0.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. The i-th test case is described as a string s consisting of at least 1 and at most 2 ⋅ 10^5 characters 'L' and 'R'.
It is guaranteed that the sum of lengths of strings over all test cases does not exceed 2 ⋅ 10^5 (∑ |s| ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum possible value of d such that the frog can reach the cell n+1 from the cell 0 if it jumps by no more than d at once.
Example
Input
6
LRLRRLL
L
LLR
RRRR
LLLLLL
R
Output
3
2
3
1
7
1
Note
The picture describing the first test case of the example and one of the possible answers:
<image>
In the second test case of the example, the frog can only jump directly from 0 to n+1.
In the third test case of the example, the frog can choose d=3, jump to the cell 3 from the cell 0 and then to the cell 4 from the cell 3.
In the fourth test case of the example, the frog can choose d=1 and jump 5 times to the right.
In the fifth test case of the example, the frog can only jump directly from 0 to n+1.
In the sixth test case of the example, the frog can choose d=1 and jump 2 times to the right. | instruction | 0 | 69,075 | 15 | 138,150 |
Tags: binary search, data structures, dfs and similar, greedy, implementation
Correct Solution:
```
def find(val):
li = list(val)
li.append("R")
li = ["R"] +li
index = 0
ans = float('-inf')
for i in range(len(li)):
if li[i] =="R":
ans = max(ans,i-index)
index = i
return ans
x = int(input())
for i in range(x):
print(find(input()))
``` | output | 1 | 69,075 | 15 | 138,151 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a frog staying to the left of the string s = s_1 s_2 … s_n consisting of n characters (to be more precise, the frog initially stays at the cell 0). Each character of s is either 'L' or 'R'. It means that if the frog is staying at the i-th cell and the i-th character is 'L', the frog can jump only to the left. If the frog is staying at the i-th cell and the i-th character is 'R', the frog can jump only to the right. The frog can jump only to the right from the cell 0.
Note that the frog can jump into the same cell twice and can perform as many jumps as it needs.
The frog wants to reach the n+1-th cell. The frog chooses some positive integer value d before the first jump (and cannot change it later) and jumps by no more than d cells at once. I.e. if the i-th character is 'L' then the frog can jump to any cell in a range [max(0, i - d); i - 1], and if the i-th character is 'R' then the frog can jump to any cell in a range [i + 1; min(n + 1; i + d)].
The frog doesn't want to jump far, so your task is to find the minimum possible value of d such that the frog can reach the cell n+1 from the cell 0 if it can jump by no more than d cells at once. It is guaranteed that it is always possible to reach n+1 from 0.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. The i-th test case is described as a string s consisting of at least 1 and at most 2 ⋅ 10^5 characters 'L' and 'R'.
It is guaranteed that the sum of lengths of strings over all test cases does not exceed 2 ⋅ 10^5 (∑ |s| ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum possible value of d such that the frog can reach the cell n+1 from the cell 0 if it jumps by no more than d at once.
Example
Input
6
LRLRRLL
L
LLR
RRRR
LLLLLL
R
Output
3
2
3
1
7
1
Note
The picture describing the first test case of the example and one of the possible answers:
<image>
In the second test case of the example, the frog can only jump directly from 0 to n+1.
In the third test case of the example, the frog can choose d=3, jump to the cell 3 from the cell 0 and then to the cell 4 from the cell 3.
In the fourth test case of the example, the frog can choose d=1 and jump 5 times to the right.
In the fifth test case of the example, the frog can only jump directly from 0 to n+1.
In the sixth test case of the example, the frog can choose d=1 and jump 2 times to the right. | instruction | 0 | 69,076 | 15 | 138,152 |
Tags: binary search, data structures, dfs and similar, greedy, implementation
Correct Solution:
```
import sys
import math
#sys.stdin=open("input.in","r")
#sys.stdout=open("output.out","w")
for _ in range(int(input())):
s=list(input())
s.insert(0,"R")
s.append("R")
m=-1
prev=0
for i in range(1,len(s)):
if s[i]=="R":
dist=i-prev
if(dist>m):
m=dist
prev=i
print(m)
``` | output | 1 | 69,076 | 15 | 138,153 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a frog staying to the left of the string s = s_1 s_2 … s_n consisting of n characters (to be more precise, the frog initially stays at the cell 0). Each character of s is either 'L' or 'R'. It means that if the frog is staying at the i-th cell and the i-th character is 'L', the frog can jump only to the left. If the frog is staying at the i-th cell and the i-th character is 'R', the frog can jump only to the right. The frog can jump only to the right from the cell 0.
Note that the frog can jump into the same cell twice and can perform as many jumps as it needs.
The frog wants to reach the n+1-th cell. The frog chooses some positive integer value d before the first jump (and cannot change it later) and jumps by no more than d cells at once. I.e. if the i-th character is 'L' then the frog can jump to any cell in a range [max(0, i - d); i - 1], and if the i-th character is 'R' then the frog can jump to any cell in a range [i + 1; min(n + 1; i + d)].
The frog doesn't want to jump far, so your task is to find the minimum possible value of d such that the frog can reach the cell n+1 from the cell 0 if it can jump by no more than d cells at once. It is guaranteed that it is always possible to reach n+1 from 0.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. The i-th test case is described as a string s consisting of at least 1 and at most 2 ⋅ 10^5 characters 'L' and 'R'.
It is guaranteed that the sum of lengths of strings over all test cases does not exceed 2 ⋅ 10^5 (∑ |s| ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum possible value of d such that the frog can reach the cell n+1 from the cell 0 if it jumps by no more than d at once.
Example
Input
6
LRLRRLL
L
LLR
RRRR
LLLLLL
R
Output
3
2
3
1
7
1
Note
The picture describing the first test case of the example and one of the possible answers:
<image>
In the second test case of the example, the frog can only jump directly from 0 to n+1.
In the third test case of the example, the frog can choose d=3, jump to the cell 3 from the cell 0 and then to the cell 4 from the cell 3.
In the fourth test case of the example, the frog can choose d=1 and jump 5 times to the right.
In the fifth test case of the example, the frog can only jump directly from 0 to n+1.
In the sixth test case of the example, the frog can choose d=1 and jump 2 times to the right. | instruction | 0 | 69,077 | 15 | 138,154 |
Tags: binary search, data structures, dfs and similar, greedy, implementation
Correct Solution:
```
for _ in range(int(input())):
s=input()
a=t=0
res='R'+s+'R'
for i in range(len(res)):
if res[i]=='R':
if a<i-t:
a=i-t
t=i
print(a)
``` | output | 1 | 69,077 | 15 | 138,155 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a frog staying to the left of the string s = s_1 s_2 … s_n consisting of n characters (to be more precise, the frog initially stays at the cell 0). Each character of s is either 'L' or 'R'. It means that if the frog is staying at the i-th cell and the i-th character is 'L', the frog can jump only to the left. If the frog is staying at the i-th cell and the i-th character is 'R', the frog can jump only to the right. The frog can jump only to the right from the cell 0.
Note that the frog can jump into the same cell twice and can perform as many jumps as it needs.
The frog wants to reach the n+1-th cell. The frog chooses some positive integer value d before the first jump (and cannot change it later) and jumps by no more than d cells at once. I.e. if the i-th character is 'L' then the frog can jump to any cell in a range [max(0, i - d); i - 1], and if the i-th character is 'R' then the frog can jump to any cell in a range [i + 1; min(n + 1; i + d)].
The frog doesn't want to jump far, so your task is to find the minimum possible value of d such that the frog can reach the cell n+1 from the cell 0 if it can jump by no more than d cells at once. It is guaranteed that it is always possible to reach n+1 from 0.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. The i-th test case is described as a string s consisting of at least 1 and at most 2 ⋅ 10^5 characters 'L' and 'R'.
It is guaranteed that the sum of lengths of strings over all test cases does not exceed 2 ⋅ 10^5 (∑ |s| ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum possible value of d such that the frog can reach the cell n+1 from the cell 0 if it jumps by no more than d at once.
Example
Input
6
LRLRRLL
L
LLR
RRRR
LLLLLL
R
Output
3
2
3
1
7
1
Note
The picture describing the first test case of the example and one of the possible answers:
<image>
In the second test case of the example, the frog can only jump directly from 0 to n+1.
In the third test case of the example, the frog can choose d=3, jump to the cell 3 from the cell 0 and then to the cell 4 from the cell 3.
In the fourth test case of the example, the frog can choose d=1 and jump 5 times to the right.
In the fifth test case of the example, the frog can only jump directly from 0 to n+1.
In the sixth test case of the example, the frog can choose d=1 and jump 2 times to the right. | instruction | 0 | 69,078 | 15 | 138,156 |
Tags: binary search, data structures, dfs and similar, greedy, implementation
Correct Solution:
```
t=int(input())
for you in range(t):
l=input()
li=[0]
for i in range(len(l)):
if(l[i]=='R'):
li.append(i+1)
li.append(len(l)+1)
lo=[]
for i in range(len(li)-1):
lo.append(li[i+1]-li[i])
print(max(lo))
``` | output | 1 | 69,078 | 15 | 138,157 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a frog staying to the left of the string s = s_1 s_2 … s_n consisting of n characters (to be more precise, the frog initially stays at the cell 0). Each character of s is either 'L' or 'R'. It means that if the frog is staying at the i-th cell and the i-th character is 'L', the frog can jump only to the left. If the frog is staying at the i-th cell and the i-th character is 'R', the frog can jump only to the right. The frog can jump only to the right from the cell 0.
Note that the frog can jump into the same cell twice and can perform as many jumps as it needs.
The frog wants to reach the n+1-th cell. The frog chooses some positive integer value d before the first jump (and cannot change it later) and jumps by no more than d cells at once. I.e. if the i-th character is 'L' then the frog can jump to any cell in a range [max(0, i - d); i - 1], and if the i-th character is 'R' then the frog can jump to any cell in a range [i + 1; min(n + 1; i + d)].
The frog doesn't want to jump far, so your task is to find the minimum possible value of d such that the frog can reach the cell n+1 from the cell 0 if it can jump by no more than d cells at once. It is guaranteed that it is always possible to reach n+1 from 0.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. The i-th test case is described as a string s consisting of at least 1 and at most 2 ⋅ 10^5 characters 'L' and 'R'.
It is guaranteed that the sum of lengths of strings over all test cases does not exceed 2 ⋅ 10^5 (∑ |s| ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum possible value of d such that the frog can reach the cell n+1 from the cell 0 if it jumps by no more than d at once.
Example
Input
6
LRLRRLL
L
LLR
RRRR
LLLLLL
R
Output
3
2
3
1
7
1
Note
The picture describing the first test case of the example and one of the possible answers:
<image>
In the second test case of the example, the frog can only jump directly from 0 to n+1.
In the third test case of the example, the frog can choose d=3, jump to the cell 3 from the cell 0 and then to the cell 4 from the cell 3.
In the fourth test case of the example, the frog can choose d=1 and jump 5 times to the right.
In the fifth test case of the example, the frog can only jump directly from 0 to n+1.
In the sixth test case of the example, the frog can choose d=1 and jump 2 times to the right.
Submitted Solution:
```
for _ in range(int(input())):
s=input()
c=0
MAX=0
for i in s:
if i=="L":
c+=1
else:
c=0
MAX=max(c,MAX)
print(MAX+1)
``` | instruction | 0 | 69,079 | 15 | 138,158 |
Yes | output | 1 | 69,079 | 15 | 138,159 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a frog staying to the left of the string s = s_1 s_2 … s_n consisting of n characters (to be more precise, the frog initially stays at the cell 0). Each character of s is either 'L' or 'R'. It means that if the frog is staying at the i-th cell and the i-th character is 'L', the frog can jump only to the left. If the frog is staying at the i-th cell and the i-th character is 'R', the frog can jump only to the right. The frog can jump only to the right from the cell 0.
Note that the frog can jump into the same cell twice and can perform as many jumps as it needs.
The frog wants to reach the n+1-th cell. The frog chooses some positive integer value d before the first jump (and cannot change it later) and jumps by no more than d cells at once. I.e. if the i-th character is 'L' then the frog can jump to any cell in a range [max(0, i - d); i - 1], and if the i-th character is 'R' then the frog can jump to any cell in a range [i + 1; min(n + 1; i + d)].
The frog doesn't want to jump far, so your task is to find the minimum possible value of d such that the frog can reach the cell n+1 from the cell 0 if it can jump by no more than d cells at once. It is guaranteed that it is always possible to reach n+1 from 0.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. The i-th test case is described as a string s consisting of at least 1 and at most 2 ⋅ 10^5 characters 'L' and 'R'.
It is guaranteed that the sum of lengths of strings over all test cases does not exceed 2 ⋅ 10^5 (∑ |s| ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum possible value of d such that the frog can reach the cell n+1 from the cell 0 if it jumps by no more than d at once.
Example
Input
6
LRLRRLL
L
LLR
RRRR
LLLLLL
R
Output
3
2
3
1
7
1
Note
The picture describing the first test case of the example and one of the possible answers:
<image>
In the second test case of the example, the frog can only jump directly from 0 to n+1.
In the third test case of the example, the frog can choose d=3, jump to the cell 3 from the cell 0 and then to the cell 4 from the cell 3.
In the fourth test case of the example, the frog can choose d=1 and jump 5 times to the right.
In the fifth test case of the example, the frog can only jump directly from 0 to n+1.
In the sixth test case of the example, the frog can choose d=1 and jump 2 times to the right.
Submitted Solution:
```
t=int(input())
while t:
t-=1
s=input()
max=-1
n=len(s)
ind=[]
ind.append(0)
for i in range(n):
if s[i]=='R':
ind.append(i+1)
ind.append(n+1)
for i in range(len(ind)-1):
if ind[i+1]-ind[i]>max:
max=ind[i+1]-ind[i]
print(max)
``` | instruction | 0 | 69,080 | 15 | 138,160 |
Yes | output | 1 | 69,080 | 15 | 138,161 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a frog staying to the left of the string s = s_1 s_2 … s_n consisting of n characters (to be more precise, the frog initially stays at the cell 0). Each character of s is either 'L' or 'R'. It means that if the frog is staying at the i-th cell and the i-th character is 'L', the frog can jump only to the left. If the frog is staying at the i-th cell and the i-th character is 'R', the frog can jump only to the right. The frog can jump only to the right from the cell 0.
Note that the frog can jump into the same cell twice and can perform as many jumps as it needs.
The frog wants to reach the n+1-th cell. The frog chooses some positive integer value d before the first jump (and cannot change it later) and jumps by no more than d cells at once. I.e. if the i-th character is 'L' then the frog can jump to any cell in a range [max(0, i - d); i - 1], and if the i-th character is 'R' then the frog can jump to any cell in a range [i + 1; min(n + 1; i + d)].
The frog doesn't want to jump far, so your task is to find the minimum possible value of d such that the frog can reach the cell n+1 from the cell 0 if it can jump by no more than d cells at once. It is guaranteed that it is always possible to reach n+1 from 0.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. The i-th test case is described as a string s consisting of at least 1 and at most 2 ⋅ 10^5 characters 'L' and 'R'.
It is guaranteed that the sum of lengths of strings over all test cases does not exceed 2 ⋅ 10^5 (∑ |s| ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum possible value of d such that the frog can reach the cell n+1 from the cell 0 if it jumps by no more than d at once.
Example
Input
6
LRLRRLL
L
LLR
RRRR
LLLLLL
R
Output
3
2
3
1
7
1
Note
The picture describing the first test case of the example and one of the possible answers:
<image>
In the second test case of the example, the frog can only jump directly from 0 to n+1.
In the third test case of the example, the frog can choose d=3, jump to the cell 3 from the cell 0 and then to the cell 4 from the cell 3.
In the fourth test case of the example, the frog can choose d=1 and jump 5 times to the right.
In the fifth test case of the example, the frog can only jump directly from 0 to n+1.
In the sixth test case of the example, the frog can choose d=1 and jump 2 times to the right.
Submitted Solution:
```
import collections
import sys;input=sys.stdin.readline
L=''
def f(d):
i=0
n=len(L)
while True:
for j in range(d,0,-1):
if i+j>=n+1:
return True
if L[i+j-1]=='R':
i=i+j
break
else:
break
return False
for _ in range(int(input())):
L=input().strip()
s,e=0,len(L)+2
while e-s>1:
m=(s+e)//2
if f(m): e=m
else: s=m
print(e)
``` | instruction | 0 | 69,081 | 15 | 138,162 |
Yes | output | 1 | 69,081 | 15 | 138,163 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.