text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the year of 30XX participants of some world programming championship live in a single large hotel. The hotel has n floors. Each floor has m sections with a single corridor connecting all of them. The sections are enumerated from 1 to m along the corridor, and all sections with equal numbers on different floors are located exactly one above the other. Thus, the hotel can be represented as a rectangle of height n and width m. We can denote sections with pairs of integers (i, j), where i is the floor, and j is the section number on the floor.
The guests can walk along the corridor on each floor, use stairs and elevators. Each stairs or elevator occupies all sections (1, x), (2, x), …, (n, x) for some x between 1 and m. All sections not occupied with stairs or elevators contain guest rooms. It takes one time unit to move between neighboring sections on the same floor or to move one floor up or down using stairs. It takes one time unit to move up to v floors in any direction using an elevator. You can assume you don't have to wait for an elevator, and the time needed to enter or exit an elevator is negligible.
You are to process q queries. Each query is a question "what is the minimum time needed to go from a room in section (x_1, y_1) to a room in section (x_2, y_2)?"
Input
The first line contains five integers n, m, c_l, c_e, v (2 ≤ n, m ≤ 10^8, 0 ≤ c_l, c_e ≤ 10^5, 1 ≤ c_l + c_e ≤ m - 1, 1 ≤ v ≤ n - 1) — the number of floors and section on each floor, the number of stairs, the number of elevators and the maximum speed of an elevator, respectively.
The second line contains c_l integers l_1, …, l_{c_l} in increasing order (1 ≤ l_i ≤ m), denoting the positions of the stairs. If c_l = 0, the second line is empty.
The third line contains c_e integers e_1, …, e_{c_e} in increasing order, denoting the elevators positions in the same format. It is guaranteed that all integers l_i and e_i are distinct.
The fourth line contains a single integer q (1 ≤ q ≤ 10^5) — the number of queries.
The next q lines describe queries. Each of these lines contains four integers x_1, y_1, x_2, y_2 (1 ≤ x_1, x_2 ≤ n, 1 ≤ y_1, y_2 ≤ m) — the coordinates of starting and finishing sections for the query. It is guaranteed that the starting and finishing sections are distinct. It is also guaranteed that these sections contain guest rooms, i. e. y_1 and y_2 are not among l_i and e_i.
Output
Print q integers, one per line — the answers for the queries.
Example
Input
5 6 1 1 3
2
5
3
1 1 5 6
1 3 5 4
3 3 5 3
Output
7
5
4
Note
In the first query the optimal way is to go to the elevator in the 5-th section in four time units, use it to go to the fifth floor in two time units and go to the destination in one more time unit.
In the second query it is still optimal to use the elevator, but in the third query it is better to use the stairs in the section 2.
Submitted Solution:
```
import sys
input=sys.stdin.readline
import math
import bisect
n,m,cl,ce,v=map(int,input().split())
l=[int(i) for i in input().split() if i!='\n' ]
e=[int(i) for i in input().split() if i!='\n']
q=int(input())
for i in range(q):
x1,y1,x2,y2=map(int,input().split())
lft,neareststa,sta,nearestele=0,0,0,0
if x2==x1 and y1==y2:
output=0
elif x2==x1:
output=abs(y2-y1)
else:
lft=math.ceil(abs((x2-x1))/v)
sta=abs(x2-x1)
if cl>0:
nearestele=bisect.bisect_left(l,y1)
if len(l)>nearestele:
first=abs(l[nearestele]-y1)+abs(y2-l[nearestele])
else:
first=1000000000001
if nearestele!=0:
second=abs(l[nearestele-1]-y1)+abs(y2-l[nearestele-1])
else:
second=1000000000001
nearestele=min(first,second)
else:
nearestele=1000000000001
if ce>0:
neareststa=bisect.bisect_left(e,y1)
if len(e)>neareststa:
first=abs(e[neareststa]-y1)+abs(y2-e[neareststa])
else:
first=1000000000001
if neareststa!=0:
second=abs(e[neareststa-1]-y1)+abs(y2-e[neareststa-1])
else:
second=1000000000001
neareststa=min(first,second)
else:
neareststa=1000000000001
output=min(lft+neareststa,sta+nearestele)
sys.stdout.write(str(output)+'\n')
```
Yes
| 99,200 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the year of 30XX participants of some world programming championship live in a single large hotel. The hotel has n floors. Each floor has m sections with a single corridor connecting all of them. The sections are enumerated from 1 to m along the corridor, and all sections with equal numbers on different floors are located exactly one above the other. Thus, the hotel can be represented as a rectangle of height n and width m. We can denote sections with pairs of integers (i, j), where i is the floor, and j is the section number on the floor.
The guests can walk along the corridor on each floor, use stairs and elevators. Each stairs or elevator occupies all sections (1, x), (2, x), …, (n, x) for some x between 1 and m. All sections not occupied with stairs or elevators contain guest rooms. It takes one time unit to move between neighboring sections on the same floor or to move one floor up or down using stairs. It takes one time unit to move up to v floors in any direction using an elevator. You can assume you don't have to wait for an elevator, and the time needed to enter or exit an elevator is negligible.
You are to process q queries. Each query is a question "what is the minimum time needed to go from a room in section (x_1, y_1) to a room in section (x_2, y_2)?"
Input
The first line contains five integers n, m, c_l, c_e, v (2 ≤ n, m ≤ 10^8, 0 ≤ c_l, c_e ≤ 10^5, 1 ≤ c_l + c_e ≤ m - 1, 1 ≤ v ≤ n - 1) — the number of floors and section on each floor, the number of stairs, the number of elevators and the maximum speed of an elevator, respectively.
The second line contains c_l integers l_1, …, l_{c_l} in increasing order (1 ≤ l_i ≤ m), denoting the positions of the stairs. If c_l = 0, the second line is empty.
The third line contains c_e integers e_1, …, e_{c_e} in increasing order, denoting the elevators positions in the same format. It is guaranteed that all integers l_i and e_i are distinct.
The fourth line contains a single integer q (1 ≤ q ≤ 10^5) — the number of queries.
The next q lines describe queries. Each of these lines contains four integers x_1, y_1, x_2, y_2 (1 ≤ x_1, x_2 ≤ n, 1 ≤ y_1, y_2 ≤ m) — the coordinates of starting and finishing sections for the query. It is guaranteed that the starting and finishing sections are distinct. It is also guaranteed that these sections contain guest rooms, i. e. y_1 and y_2 are not among l_i and e_i.
Output
Print q integers, one per line — the answers for the queries.
Example
Input
5 6 1 1 3
2
5
3
1 1 5 6
1 3 5 4
3 3 5 3
Output
7
5
4
Note
In the first query the optimal way is to go to the elevator in the 5-th section in four time units, use it to go to the fifth floor in two time units and go to the destination in one more time unit.
In the second query it is still optimal to use the elevator, but in the third query it is better to use the stairs in the section 2.
Submitted Solution:
```
# Code by Sounak, IIESTS
# ------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
from collections import deque
import threading
# sys.setrecursionlimit(300000)
# threading.stack_size(10**8)
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")
# -------------------------------------------------------------------------
# mod = 9223372036854775807
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
class SegmentTree1:
def __init__(self, data, default=10 ** 6, func=lambda a, b: min(a, b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
MOD = 10 ** 9 + 7
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
mod = 10 ** 9 + 7
omod = 998244353
# -------------------------------------------------------------------------
prime = [True for i in range(10)]
pp = [0] * 10
def SieveOfEratosthenes(n=10):
p = 2
c = 0
while (p * p <= n):
if (prime[p] == True):
c += 1
for i in range(p, n + 1, p):
pp[i] += 1
prime[i] = False
p += 1
# ---------------------------------Binary Search------------------------------------------
def binarySearch(arr, n, key):
left = 0
right = n - 1
res = -1
while (left <= right):
mid = (right + left) // 2
if (arr[mid] >= key):
res = arr[mid]
right = mid - 1
else:
left = mid + 1
return res
def binarySearch1(arr, n, key):
left = 0
right = n - 1
res = -1
while (left <= right):
mid = (right + left) // 2
if (arr[mid]>=key):
right = mid - 1
else:
res = arr[mid]
left = mid + 1
return res
# ---------------------------------running code------------------------------------------
n, m, cl, ce, v = map(int, input().split())
l = list(map(int, input().split()))
e = list(map(int, input().split()))
l.sort()
e.sort()
q = int(input())
for i in range(q):
res = 10**10
x1, y1, x2, y2 = map(int, input().split())
if x1==x2:
print(abs(y1-y2))
continue
lx1 = binarySearch(l, cl, y1)
lx2 = binarySearch1(l, cl, y1)
ex1 = binarySearch(e, ce, y1)
ex2 = binarySearch1(e, ce, y1)
if lx1!=-1:
res = min(res,abs(lx1 - y1) + abs(lx1 - y2) + abs(x1 - x2))
if lx2!=-1:
res = min(res, abs(lx2 - y1) + abs(lx2 - y2) + abs(x1 - x2))
if ex1!=-1:
res = min(res, abs(ex1 - y1) + abs(ex1 - y2) + math.ceil(abs(x1 - x2) / v))
if ex2!=-1:
res = min(res, abs(ex2 - y1) + abs(ex2 - y2) + math.ceil(abs(x1 - x2) / v))
print(res)
```
Yes
| 99,201 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the year of 30XX participants of some world programming championship live in a single large hotel. The hotel has n floors. Each floor has m sections with a single corridor connecting all of them. The sections are enumerated from 1 to m along the corridor, and all sections with equal numbers on different floors are located exactly one above the other. Thus, the hotel can be represented as a rectangle of height n and width m. We can denote sections with pairs of integers (i, j), where i is the floor, and j is the section number on the floor.
The guests can walk along the corridor on each floor, use stairs and elevators. Each stairs or elevator occupies all sections (1, x), (2, x), …, (n, x) for some x between 1 and m. All sections not occupied with stairs or elevators contain guest rooms. It takes one time unit to move between neighboring sections on the same floor or to move one floor up or down using stairs. It takes one time unit to move up to v floors in any direction using an elevator. You can assume you don't have to wait for an elevator, and the time needed to enter or exit an elevator is negligible.
You are to process q queries. Each query is a question "what is the minimum time needed to go from a room in section (x_1, y_1) to a room in section (x_2, y_2)?"
Input
The first line contains five integers n, m, c_l, c_e, v (2 ≤ n, m ≤ 10^8, 0 ≤ c_l, c_e ≤ 10^5, 1 ≤ c_l + c_e ≤ m - 1, 1 ≤ v ≤ n - 1) — the number of floors and section on each floor, the number of stairs, the number of elevators and the maximum speed of an elevator, respectively.
The second line contains c_l integers l_1, …, l_{c_l} in increasing order (1 ≤ l_i ≤ m), denoting the positions of the stairs. If c_l = 0, the second line is empty.
The third line contains c_e integers e_1, …, e_{c_e} in increasing order, denoting the elevators positions in the same format. It is guaranteed that all integers l_i and e_i are distinct.
The fourth line contains a single integer q (1 ≤ q ≤ 10^5) — the number of queries.
The next q lines describe queries. Each of these lines contains four integers x_1, y_1, x_2, y_2 (1 ≤ x_1, x_2 ≤ n, 1 ≤ y_1, y_2 ≤ m) — the coordinates of starting and finishing sections for the query. It is guaranteed that the starting and finishing sections are distinct. It is also guaranteed that these sections contain guest rooms, i. e. y_1 and y_2 are not among l_i and e_i.
Output
Print q integers, one per line — the answers for the queries.
Example
Input
5 6 1 1 3
2
5
3
1 1 5 6
1 3 5 4
3 3 5 3
Output
7
5
4
Note
In the first query the optimal way is to go to the elevator in the 5-th section in four time units, use it to go to the fifth floor in two time units and go to the destination in one more time unit.
In the second query it is still optimal to use the elevator, but in the third query it is better to use the stairs in the section 2.
Submitted Solution:
```
import sys
input=sys.stdin.readline
import math
import bisect
n,m,cl,ce,v=map(int,input().split())
l=[int(i) for i in input().split() if i!='\n' ]
e=[int(i) for i in input().split() if i!='\n']
q=int(input())
for i in range(q):
x1,y1,x2,y2=map(int,input().split())
lft,neareststa,sta,nearestele=0,0,0,0
if x2==x1 and y1==y2:
output=0
elif x2==x1:
output=abs(y2-y1)
else:
lft=math.ceil(abs((x2-x1))/v)
#print(lft)
sta=abs(x2-x1)
if cl>0:
nearestele=bisect.bisect_left(l,y1)
if len(l)>nearestele:
first=abs(l[nearestele]-y1)+abs(y2-l[nearestele])
else:
first=1000000000001
if nearestele!=0:
second=abs(l[nearestele-1]-y1)+abs(y2-l[nearestele-1])
else:
second=1000000000001
#print(first,second,nearestele)
nearestele=min(first,second)
else:
nearestele=1000000000001
if ce>0:
neareststa=bisect.bisect_left(e,y1)
#print('n',neareststa)
if len(e)>neareststa:
first=abs(e[neareststa]-y1)+abs(y2-e[neareststa])
#print(first)
else:
first=1000000000001
if neareststa!=0:
second=abs(e[neareststa-1]-y1)+abs(y2-e[neareststa-1])
else:
second=1000000000001
neareststa=min(first,second)
else:
neareststa=1000000000001
#print(lft,sta,neareststa,nearestele,first,second)
output=min(lft+neareststa,sta+nearestele)
sys.stdout.write(str(output)+'\n')
```
Yes
| 99,202 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the year of 30XX participants of some world programming championship live in a single large hotel. The hotel has n floors. Each floor has m sections with a single corridor connecting all of them. The sections are enumerated from 1 to m along the corridor, and all sections with equal numbers on different floors are located exactly one above the other. Thus, the hotel can be represented as a rectangle of height n and width m. We can denote sections with pairs of integers (i, j), where i is the floor, and j is the section number on the floor.
The guests can walk along the corridor on each floor, use stairs and elevators. Each stairs or elevator occupies all sections (1, x), (2, x), …, (n, x) for some x between 1 and m. All sections not occupied with stairs or elevators contain guest rooms. It takes one time unit to move between neighboring sections on the same floor or to move one floor up or down using stairs. It takes one time unit to move up to v floors in any direction using an elevator. You can assume you don't have to wait for an elevator, and the time needed to enter or exit an elevator is negligible.
You are to process q queries. Each query is a question "what is the minimum time needed to go from a room in section (x_1, y_1) to a room in section (x_2, y_2)?"
Input
The first line contains five integers n, m, c_l, c_e, v (2 ≤ n, m ≤ 10^8, 0 ≤ c_l, c_e ≤ 10^5, 1 ≤ c_l + c_e ≤ m - 1, 1 ≤ v ≤ n - 1) — the number of floors and section on each floor, the number of stairs, the number of elevators and the maximum speed of an elevator, respectively.
The second line contains c_l integers l_1, …, l_{c_l} in increasing order (1 ≤ l_i ≤ m), denoting the positions of the stairs. If c_l = 0, the second line is empty.
The third line contains c_e integers e_1, …, e_{c_e} in increasing order, denoting the elevators positions in the same format. It is guaranteed that all integers l_i and e_i are distinct.
The fourth line contains a single integer q (1 ≤ q ≤ 10^5) — the number of queries.
The next q lines describe queries. Each of these lines contains four integers x_1, y_1, x_2, y_2 (1 ≤ x_1, x_2 ≤ n, 1 ≤ y_1, y_2 ≤ m) — the coordinates of starting and finishing sections for the query. It is guaranteed that the starting and finishing sections are distinct. It is also guaranteed that these sections contain guest rooms, i. e. y_1 and y_2 are not among l_i and e_i.
Output
Print q integers, one per line — the answers for the queries.
Example
Input
5 6 1 1 3
2
5
3
1 1 5 6
1 3 5 4
3 3 5 3
Output
7
5
4
Note
In the first query the optimal way is to go to the elevator in the 5-th section in four time units, use it to go to the fifth floor in two time units and go to the destination in one more time unit.
In the second query it is still optimal to use the elevator, but in the third query it is better to use the stairs in the section 2.
Submitted Solution:
```
import math
n, m, cl, ce, v = list(map(int,input().split()))
l = list(map(int,input().split()))
e = list(map(int,input().split()))
q = int(input())
for i in range(0,q):
A = list(map(int,input().split()))
p = m*n
if A[0] == A[2]:
p = abs(A[1]-A[3])
else:
#checking paths by elevator
closest_elevator_left = 0
for k in range(1, A[1]):
if A[1]-k in e:
closest_elevator_left = A[1]-k
break
if closest_elevator_left != 0:
c = abs(A[1]-closest_elevator_left) + math.ceil(abs(A[0]-A[2])/v) + abs(A[3]-closest_elevator_left)
if c <= p:
p = c
closest_elevator_right = 0
for k in range(1, m-A[1]):
if A[1]+k in e:
closest_elevator_right = A[1]+k
break
if closest_elevator_right != 0:
c = abs(A[1]-closest_elevator_right) + math.ceil(abs(A[0]-A[2])/v) + abs(A[3]-closest_elevator_right)
if c <= p:
p = c
#checking paths by stairs
closest_stairs_left = 0
for k in range(1, A[1]):
if A[1]-k in l:
closest_stairs_left = A[1]-k
break
if closest_stairs_left != 0:
c = (A[1]-closest_stairs_left) + abs(A[0]-A[2]) + abs(A[3]-closest_stairs_left)
if c <= p:
p = c
closest_stairs_right = 0
for k in range(1, m-A[1]):
if A[1]+k in l:
closest_stairs_right = A[1]+k
break
if closest_stairs_right != 0:
c = (closest_stairs_right - A[1]) + abs(A[0]-A[2]) + abs(A[3]-closest_stairs_right)
if c <= p:
p = c
print(p)
```
No
| 99,203 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the year of 30XX participants of some world programming championship live in a single large hotel. The hotel has n floors. Each floor has m sections with a single corridor connecting all of them. The sections are enumerated from 1 to m along the corridor, and all sections with equal numbers on different floors are located exactly one above the other. Thus, the hotel can be represented as a rectangle of height n and width m. We can denote sections with pairs of integers (i, j), where i is the floor, and j is the section number on the floor.
The guests can walk along the corridor on each floor, use stairs and elevators. Each stairs or elevator occupies all sections (1, x), (2, x), …, (n, x) for some x between 1 and m. All sections not occupied with stairs or elevators contain guest rooms. It takes one time unit to move between neighboring sections on the same floor or to move one floor up or down using stairs. It takes one time unit to move up to v floors in any direction using an elevator. You can assume you don't have to wait for an elevator, and the time needed to enter or exit an elevator is negligible.
You are to process q queries. Each query is a question "what is the minimum time needed to go from a room in section (x_1, y_1) to a room in section (x_2, y_2)?"
Input
The first line contains five integers n, m, c_l, c_e, v (2 ≤ n, m ≤ 10^8, 0 ≤ c_l, c_e ≤ 10^5, 1 ≤ c_l + c_e ≤ m - 1, 1 ≤ v ≤ n - 1) — the number of floors and section on each floor, the number of stairs, the number of elevators and the maximum speed of an elevator, respectively.
The second line contains c_l integers l_1, …, l_{c_l} in increasing order (1 ≤ l_i ≤ m), denoting the positions of the stairs. If c_l = 0, the second line is empty.
The third line contains c_e integers e_1, …, e_{c_e} in increasing order, denoting the elevators positions in the same format. It is guaranteed that all integers l_i and e_i are distinct.
The fourth line contains a single integer q (1 ≤ q ≤ 10^5) — the number of queries.
The next q lines describe queries. Each of these lines contains four integers x_1, y_1, x_2, y_2 (1 ≤ x_1, x_2 ≤ n, 1 ≤ y_1, y_2 ≤ m) — the coordinates of starting and finishing sections for the query. It is guaranteed that the starting and finishing sections are distinct. It is also guaranteed that these sections contain guest rooms, i. e. y_1 and y_2 are not among l_i and e_i.
Output
Print q integers, one per line — the answers for the queries.
Example
Input
5 6 1 1 3
2
5
3
1 1 5 6
1 3 5 4
3 3 5 3
Output
7
5
4
Note
In the first query the optimal way is to go to the elevator in the 5-th section in four time units, use it to go to the fifth floor in two time units and go to the destination in one more time unit.
In the second query it is still optimal to use the elevator, but in the third query it is better to use the stairs in the section 2.
Submitted Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
from collections import deque
import threading
#sys.setrecursionlimit(300000)
#threading.stack_size(10**8)
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")
#-------------------------------------------------------------------------
#mod = 9223372036854775807
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a+b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
class SegmentTree1:
def __init__(self, data, default=10**6, func=lambda a, b: min(a,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
MOD=10**9+7
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
mod=10**9+7
omod=998244353
#-------------------------------------------------------------------------
prime = [True for i in range(10)]
pp=[0]*10
def SieveOfEratosthenes(n=10):
p = 2
c=0
while (p * p <= n):
if (prime[p] == True):
c+=1
for i in range(p, n+1, p):
pp[i]+=1
prime[i] = False
p += 1
#---------------------------------Binary Search------------------------------------------
def binarySearch(arr, n, key):
left = 0
right = n-1
mid = 0
res=arr[n-1]
while (left <= right):
mid = (right + left)//2
if (arr[mid] >= key):
res=arr[mid]
right = mid-1
else:
left = mid + 1
return res
def binarySearch1(arr, n, key):
left = 0
right = n-1
mid = 0
res=arr[0]
while (left <= right):
mid = (right + left)//2
if (arr[mid] > key):
right = mid-1
else:
res=arr[mid]
left = mid + 1
return res
#---------------------------------running code------------------------------------------
n3,m,cl,ce,v=map(int,input().split())
l=list(map(int,input().split()))
e=list(map(int,input().split()))
q=int(input())
for i in range (q):
res=10**9
x1,y1,x2,y2=map(int,input().split())
if cl>0:
lx1=binarySearch(l, cl, x1)
lx2=binarySearch1(l, cl, x1)
res=abs(lx1-y1)+abs(lx1-y2)+abs(x1-x2)
res=min(res,abs(lx2-y1)+abs(lx2-y2)+abs(x1-x2))
if ce>0:
ex1=binarySearch(e, ce, x1)
ex2=binarySearch1(e, ce, x1)
res=min(res,abs(ex1-y1)+abs(ex1-y2)+math.ceil(abs(x1-x2)/v))
res=min(res,abs(ex2-y1)+abs(ex2-y2)+math.ceil(abs(x1-x2)/v))
print(res)
```
No
| 99,204 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the year of 30XX participants of some world programming championship live in a single large hotel. The hotel has n floors. Each floor has m sections with a single corridor connecting all of them. The sections are enumerated from 1 to m along the corridor, and all sections with equal numbers on different floors are located exactly one above the other. Thus, the hotel can be represented as a rectangle of height n and width m. We can denote sections with pairs of integers (i, j), where i is the floor, and j is the section number on the floor.
The guests can walk along the corridor on each floor, use stairs and elevators. Each stairs or elevator occupies all sections (1, x), (2, x), …, (n, x) for some x between 1 and m. All sections not occupied with stairs or elevators contain guest rooms. It takes one time unit to move between neighboring sections on the same floor or to move one floor up or down using stairs. It takes one time unit to move up to v floors in any direction using an elevator. You can assume you don't have to wait for an elevator, and the time needed to enter or exit an elevator is negligible.
You are to process q queries. Each query is a question "what is the minimum time needed to go from a room in section (x_1, y_1) to a room in section (x_2, y_2)?"
Input
The first line contains five integers n, m, c_l, c_e, v (2 ≤ n, m ≤ 10^8, 0 ≤ c_l, c_e ≤ 10^5, 1 ≤ c_l + c_e ≤ m - 1, 1 ≤ v ≤ n - 1) — the number of floors and section on each floor, the number of stairs, the number of elevators and the maximum speed of an elevator, respectively.
The second line contains c_l integers l_1, …, l_{c_l} in increasing order (1 ≤ l_i ≤ m), denoting the positions of the stairs. If c_l = 0, the second line is empty.
The third line contains c_e integers e_1, …, e_{c_e} in increasing order, denoting the elevators positions in the same format. It is guaranteed that all integers l_i and e_i are distinct.
The fourth line contains a single integer q (1 ≤ q ≤ 10^5) — the number of queries.
The next q lines describe queries. Each of these lines contains four integers x_1, y_1, x_2, y_2 (1 ≤ x_1, x_2 ≤ n, 1 ≤ y_1, y_2 ≤ m) — the coordinates of starting and finishing sections for the query. It is guaranteed that the starting and finishing sections are distinct. It is also guaranteed that these sections contain guest rooms, i. e. y_1 and y_2 are not among l_i and e_i.
Output
Print q integers, one per line — the answers for the queries.
Example
Input
5 6 1 1 3
2
5
3
1 1 5 6
1 3 5 4
3 3 5 3
Output
7
5
4
Note
In the first query the optimal way is to go to the elevator in the 5-th section in four time units, use it to go to the fifth floor in two time units and go to the destination in one more time unit.
In the second query it is still optimal to use the elevator, but in the third query it is better to use the stairs in the section 2.
Submitted Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
from collections import deque
import threading
#sys.setrecursionlimit(300000)
#threading.stack_size(10**8)
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")
#-------------------------------------------------------------------------
#mod = 9223372036854775807
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a+b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
class SegmentTree1:
def __init__(self, data, default=10**6, func=lambda a, b: min(a,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
MOD=10**9+7
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
mod=10**9+7
omod=998244353
#-------------------------------------------------------------------------
prime = [True for i in range(10)]
pp=[0]*10
def SieveOfEratosthenes(n=10):
p = 2
c=0
while (p * p <= n):
if (prime[p] == True):
c+=1
for i in range(p, n+1, p):
pp[i]+=1
prime[i] = False
p += 1
#---------------------------------Binary Search------------------------------------------
def binarySearch(arr, n, key):
left = 0
right = n-1
mid = 0
res=arr[n-1]
while (left <= right):
mid = (right + left)//2
if (arr[mid] >= key):
res=arr[mid]
right = mid-1
else:
left = mid + 1
return res
def binarySearch1(arr, n, key):
left = 0
right = n-1
mid = 0
res=arr[0]
while (left <= right):
mid = (right + left)//2
if (arr[mid] > key):
right = mid-1
else:
res=arr[mid]
left = mid + 1
return res
#---------------------------------running code------------------------------------------
n,m,cl,ce,v=map(int,input().split())
l=list(map(int,input().split()))
e=list(map(int,input().split()))
q=int(input())
for i in range (q):
res=10**9
x1,y1,x2,y2=map(int,input().split())
if cl>0:
lx1=binarySearch(l, cl, x1)
lx2=binarySearch1(l, cl, x1)
res=abs(lx1-y1)+abs(lx1-y2)+abs(x1-x2)
res=min(res,abs(lx2-y1)+abs(lx2-y2)+abs(x1-x2))
if ce>0:
ex1=binarySearch(e, ce, x1)
ex2=binarySearch1(e, ce, x1)
res=min(res,abs(ex1-y1)+abs(ex1-y2)+math.ceil(abs(x1-x2)/v))
res=min(res,abs(ex2-y1)+abs(ex2-y2)+math.ceil(abs(x1-x2)/v))
print(res)
```
No
| 99,205 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the year of 30XX participants of some world programming championship live in a single large hotel. The hotel has n floors. Each floor has m sections with a single corridor connecting all of them. The sections are enumerated from 1 to m along the corridor, and all sections with equal numbers on different floors are located exactly one above the other. Thus, the hotel can be represented as a rectangle of height n and width m. We can denote sections with pairs of integers (i, j), where i is the floor, and j is the section number on the floor.
The guests can walk along the corridor on each floor, use stairs and elevators. Each stairs or elevator occupies all sections (1, x), (2, x), …, (n, x) for some x between 1 and m. All sections not occupied with stairs or elevators contain guest rooms. It takes one time unit to move between neighboring sections on the same floor or to move one floor up or down using stairs. It takes one time unit to move up to v floors in any direction using an elevator. You can assume you don't have to wait for an elevator, and the time needed to enter or exit an elevator is negligible.
You are to process q queries. Each query is a question "what is the minimum time needed to go from a room in section (x_1, y_1) to a room in section (x_2, y_2)?"
Input
The first line contains five integers n, m, c_l, c_e, v (2 ≤ n, m ≤ 10^8, 0 ≤ c_l, c_e ≤ 10^5, 1 ≤ c_l + c_e ≤ m - 1, 1 ≤ v ≤ n - 1) — the number of floors and section on each floor, the number of stairs, the number of elevators and the maximum speed of an elevator, respectively.
The second line contains c_l integers l_1, …, l_{c_l} in increasing order (1 ≤ l_i ≤ m), denoting the positions of the stairs. If c_l = 0, the second line is empty.
The third line contains c_e integers e_1, …, e_{c_e} in increasing order, denoting the elevators positions in the same format. It is guaranteed that all integers l_i and e_i are distinct.
The fourth line contains a single integer q (1 ≤ q ≤ 10^5) — the number of queries.
The next q lines describe queries. Each of these lines contains four integers x_1, y_1, x_2, y_2 (1 ≤ x_1, x_2 ≤ n, 1 ≤ y_1, y_2 ≤ m) — the coordinates of starting and finishing sections for the query. It is guaranteed that the starting and finishing sections are distinct. It is also guaranteed that these sections contain guest rooms, i. e. y_1 and y_2 are not among l_i and e_i.
Output
Print q integers, one per line — the answers for the queries.
Example
Input
5 6 1 1 3
2
5
3
1 1 5 6
1 3 5 4
3 3 5 3
Output
7
5
4
Note
In the first query the optimal way is to go to the elevator in the 5-th section in four time units, use it to go to the fifth floor in two time units and go to the destination in one more time unit.
In the second query it is still optimal to use the elevator, but in the third query it is better to use the stairs in the section 2.
Submitted Solution:
```
import bisect
import math
n,m,c1,ce,v=map(int,input().split())
posstairs=list(map(int,input().split()))
posele=list(map(int,input().split()))
q=int(input())
for i in range(0,q):
y1,x1,y2,x2=map(int,input().split())
if x2<x1:
x1,x2=x2,x1
ind2=bisect.bisect_left(posstairs,x1)
if ce!=0:
ind1=bisect.bisect_left(posele,x1)
if ind1==ce:
ind1-=1
t1=abs(x1-posele[ind1])+abs(posele[ind1]-x2)+math.ceil((y2-y1)/v)
if c1!=0:
ind2=bisect.bisect_left(posstairs,x1)
if ind2==c1:
ind2-=1
t2=abs(x1-posstairs[ind2])+abs(posstairs[ind2]-x2)+abs(y2-y1)
if y1==y2:
print(abs(x2-x1))
elif ce!=0 and c1!=0:
print(min(t1,t2))
elif ce!=0:
print(t1)
else :
print(t2)
```
No
| 99,206 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of n lowercase Latin letters. You have to type this string using your keyboard.
Initially, you have an empty string. Until you type the whole string, you may perform the following operation:
* add a character to the end of the string.
Besides, at most once you may perform one additional operation: copy the string and append it to itself.
For example, if you have to type string abcabca, you can type it in 7 operations if you type all the characters one by one. However, you can type it in 5 operations if you type the string abc first and then copy it and type the last character.
If you have to type string aaaaaaaaa, the best option is to type 4 characters one by one, then copy the string, and then type the remaining character.
Print the minimum number of operations you need to type the given string.
Input
The first line of the input containing only one integer number n (1 ≤ n ≤ 100) — the length of the string you have to type. The second line containing the string s consisting of n lowercase Latin letters.
Output
Print one integer number — the minimum number of operations you need to type the given string.
Examples
Input
7
abcabca
Output
5
Input
8
abcdefgh
Output
8
Note
The first test described in the problem statement.
In the second test you can only type all the characters one by one.
Tags: implementation, strings
Correct Solution:
```
if __name__ == '__main__':
n = int(input())
ss = input()
ans = n
for i in range(1, n // 2+1):
if ss[0: i] == ss[i:i+i]:
ans = n - i + 1
print(ans)
```
| 99,207 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of n lowercase Latin letters. You have to type this string using your keyboard.
Initially, you have an empty string. Until you type the whole string, you may perform the following operation:
* add a character to the end of the string.
Besides, at most once you may perform one additional operation: copy the string and append it to itself.
For example, if you have to type string abcabca, you can type it in 7 operations if you type all the characters one by one. However, you can type it in 5 operations if you type the string abc first and then copy it and type the last character.
If you have to type string aaaaaaaaa, the best option is to type 4 characters one by one, then copy the string, and then type the remaining character.
Print the minimum number of operations you need to type the given string.
Input
The first line of the input containing only one integer number n (1 ≤ n ≤ 100) — the length of the string you have to type. The second line containing the string s consisting of n lowercase Latin letters.
Output
Print one integer number — the minimum number of operations you need to type the given string.
Examples
Input
7
abcabca
Output
5
Input
8
abcdefgh
Output
8
Note
The first test described in the problem statement.
In the second test you can only type all the characters one by one.
Tags: implementation, strings
Correct Solution:
```
n = int(input())
s = input()
size = 0
i = n-1
while i>-1:
if i%2 ==0:
size+=1
i-=1
elif s[:(i+1)//2]==s[(i+1)//2:(i+1)]:
size +=(i+1)//2+1
break
else:
size +=2
i-=2
print(size)
```
| 99,208 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of n lowercase Latin letters. You have to type this string using your keyboard.
Initially, you have an empty string. Until you type the whole string, you may perform the following operation:
* add a character to the end of the string.
Besides, at most once you may perform one additional operation: copy the string and append it to itself.
For example, if you have to type string abcabca, you can type it in 7 operations if you type all the characters one by one. However, you can type it in 5 operations if you type the string abc first and then copy it and type the last character.
If you have to type string aaaaaaaaa, the best option is to type 4 characters one by one, then copy the string, and then type the remaining character.
Print the minimum number of operations you need to type the given string.
Input
The first line of the input containing only one integer number n (1 ≤ n ≤ 100) — the length of the string you have to type. The second line containing the string s consisting of n lowercase Latin letters.
Output
Print one integer number — the minimum number of operations you need to type the given string.
Examples
Input
7
abcabca
Output
5
Input
8
abcdefgh
Output
8
Note
The first test described in the problem statement.
In the second test you can only type all the characters one by one.
Tags: implementation, strings
Correct Solution:
```
n = int(input())
s = input()
m = ''
for i in range(1, len(s)):
if s[0:i] == s[i:i * 2] and len(s[0:i]) > len(m):
m = s[0:i]
if len(m) == 0:
print(len(s))
else:
print(len(s) - len(m) + 1)
```
| 99,209 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of n lowercase Latin letters. You have to type this string using your keyboard.
Initially, you have an empty string. Until you type the whole string, you may perform the following operation:
* add a character to the end of the string.
Besides, at most once you may perform one additional operation: copy the string and append it to itself.
For example, if you have to type string abcabca, you can type it in 7 operations if you type all the characters one by one. However, you can type it in 5 operations if you type the string abc first and then copy it and type the last character.
If you have to type string aaaaaaaaa, the best option is to type 4 characters one by one, then copy the string, and then type the remaining character.
Print the minimum number of operations you need to type the given string.
Input
The first line of the input containing only one integer number n (1 ≤ n ≤ 100) — the length of the string you have to type. The second line containing the string s consisting of n lowercase Latin letters.
Output
Print one integer number — the minimum number of operations you need to type the given string.
Examples
Input
7
abcabca
Output
5
Input
8
abcdefgh
Output
8
Note
The first test described in the problem statement.
In the second test you can only type all the characters one by one.
Tags: implementation, strings
Correct Solution:
```
import getpass
import sys
import math
import random
import itertools
import bisect
import time
files = True
debug = False
if getpass.getuser() == 'frohenk' and files:
debug = True
sys.stdin = open("test.in")
# sys.stdout = open('test.out', 'w')
elif files:
# fname = "gift"
# sys.stdin = open("%s.in" % fname)
# sys.stdout = open('%s.out' % fname, 'w')
pass
def lcm(a, b):
return a * b // math.gcd(a, b)
def ria():
return [int(i) for i in input().split()]
def range_sum(a, b):
ass = (((b - a + 1) // 2) * (a + b))
if (a - b) % 2 == 0:
ass += (b - a + 2) // 2
return ass
def comba(n, x):
return (math.factorial(n) // math.factorial(n - x)) // math.factorial(x)
n = ria()[0]
suma = n
st = input()
mx = 0
for i in range(1, n + 1):
if i + i <= n:
if st[:i] == st[i:i + i]:
mx = max(mx, len(st[:i]) - 1)
print(n - mx)
```
| 99,210 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of n lowercase Latin letters. You have to type this string using your keyboard.
Initially, you have an empty string. Until you type the whole string, you may perform the following operation:
* add a character to the end of the string.
Besides, at most once you may perform one additional operation: copy the string and append it to itself.
For example, if you have to type string abcabca, you can type it in 7 operations if you type all the characters one by one. However, you can type it in 5 operations if you type the string abc first and then copy it and type the last character.
If you have to type string aaaaaaaaa, the best option is to type 4 characters one by one, then copy the string, and then type the remaining character.
Print the minimum number of operations you need to type the given string.
Input
The first line of the input containing only one integer number n (1 ≤ n ≤ 100) — the length of the string you have to type. The second line containing the string s consisting of n lowercase Latin letters.
Output
Print one integer number — the minimum number of operations you need to type the given string.
Examples
Input
7
abcabca
Output
5
Input
8
abcdefgh
Output
8
Note
The first test described in the problem statement.
In the second test you can only type all the characters one by one.
Tags: implementation, strings
Correct Solution:
```
n=int(input())
st = input()
c=0
x=0
ok = 0
for i in range(1,n//2+1):
# print(st[:x+1],st[x+1:2*x+2])
if st[ : i]==st[i:2*i]:
x=i
print(min([n,n-x+1]))
```
| 99,211 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of n lowercase Latin letters. You have to type this string using your keyboard.
Initially, you have an empty string. Until you type the whole string, you may perform the following operation:
* add a character to the end of the string.
Besides, at most once you may perform one additional operation: copy the string and append it to itself.
For example, if you have to type string abcabca, you can type it in 7 operations if you type all the characters one by one. However, you can type it in 5 operations if you type the string abc first and then copy it and type the last character.
If you have to type string aaaaaaaaa, the best option is to type 4 characters one by one, then copy the string, and then type the remaining character.
Print the minimum number of operations you need to type the given string.
Input
The first line of the input containing only one integer number n (1 ≤ n ≤ 100) — the length of the string you have to type. The second line containing the string s consisting of n lowercase Latin letters.
Output
Print one integer number — the minimum number of operations you need to type the given string.
Examples
Input
7
abcabca
Output
5
Input
8
abcdefgh
Output
8
Note
The first test described in the problem statement.
In the second test you can only type all the characters one by one.
Tags: implementation, strings
Correct Solution:
```
L = int(input())
s = input()
for i in range(L//2, 2-1, -1):
if s[i:].startswith(s[:i]):
print(L-i+1)
break
else:
print(L)
```
| 99,212 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of n lowercase Latin letters. You have to type this string using your keyboard.
Initially, you have an empty string. Until you type the whole string, you may perform the following operation:
* add a character to the end of the string.
Besides, at most once you may perform one additional operation: copy the string and append it to itself.
For example, if you have to type string abcabca, you can type it in 7 operations if you type all the characters one by one. However, you can type it in 5 operations if you type the string abc first and then copy it and type the last character.
If you have to type string aaaaaaaaa, the best option is to type 4 characters one by one, then copy the string, and then type the remaining character.
Print the minimum number of operations you need to type the given string.
Input
The first line of the input containing only one integer number n (1 ≤ n ≤ 100) — the length of the string you have to type. The second line containing the string s consisting of n lowercase Latin letters.
Output
Print one integer number — the minimum number of operations you need to type the given string.
Examples
Input
7
abcabca
Output
5
Input
8
abcdefgh
Output
8
Note
The first test described in the problem statement.
In the second test you can only type all the characters one by one.
Tags: implementation, strings
Correct Solution:
```
n = int(input())
s = input()
for l in range(n // 2, 0, -1):
if s[:l] == s[l:l * 2]:
print(len(s) - l + 1)
exit(0)
print(n)
```
| 99,213 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of n lowercase Latin letters. You have to type this string using your keyboard.
Initially, you have an empty string. Until you type the whole string, you may perform the following operation:
* add a character to the end of the string.
Besides, at most once you may perform one additional operation: copy the string and append it to itself.
For example, if you have to type string abcabca, you can type it in 7 operations if you type all the characters one by one. However, you can type it in 5 operations if you type the string abc first and then copy it and type the last character.
If you have to type string aaaaaaaaa, the best option is to type 4 characters one by one, then copy the string, and then type the remaining character.
Print the minimum number of operations you need to type the given string.
Input
The first line of the input containing only one integer number n (1 ≤ n ≤ 100) — the length of the string you have to type. The second line containing the string s consisting of n lowercase Latin letters.
Output
Print one integer number — the minimum number of operations you need to type the given string.
Examples
Input
7
abcabca
Output
5
Input
8
abcdefgh
Output
8
Note
The first test described in the problem statement.
In the second test you can only type all the characters one by one.
Tags: implementation, strings
Correct Solution:
```
#codeforces_954B
n = int(input())
k = n
s = input()
rez = 0
while n>0:
if n & 1:
n -= 1
pass;
elif s[:n//2] == s[n//2:n]:
rez = n//2 +1
break;
else:
n -= 2
print(k-n+rez)
```
| 99,214 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of n lowercase Latin letters. You have to type this string using your keyboard.
Initially, you have an empty string. Until you type the whole string, you may perform the following operation:
* add a character to the end of the string.
Besides, at most once you may perform one additional operation: copy the string and append it to itself.
For example, if you have to type string abcabca, you can type it in 7 operations if you type all the characters one by one. However, you can type it in 5 operations if you type the string abc first and then copy it and type the last character.
If you have to type string aaaaaaaaa, the best option is to type 4 characters one by one, then copy the string, and then type the remaining character.
Print the minimum number of operations you need to type the given string.
Input
The first line of the input containing only one integer number n (1 ≤ n ≤ 100) — the length of the string you have to type. The second line containing the string s consisting of n lowercase Latin letters.
Output
Print one integer number — the minimum number of operations you need to type the given string.
Examples
Input
7
abcabca
Output
5
Input
8
abcdefgh
Output
8
Note
The first test described in the problem statement.
In the second test you can only type all the characters one by one.
Submitted Solution:
```
n = int(input())
s = input()
ans = n
for i in range(n):
if 2 * i <= n and s[:i] == s[i: 2 * i]:
ans = min(ans, n - i + 1)
print(ans)
```
Yes
| 99,215 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of n lowercase Latin letters. You have to type this string using your keyboard.
Initially, you have an empty string. Until you type the whole string, you may perform the following operation:
* add a character to the end of the string.
Besides, at most once you may perform one additional operation: copy the string and append it to itself.
For example, if you have to type string abcabca, you can type it in 7 operations if you type all the characters one by one. However, you can type it in 5 operations if you type the string abc first and then copy it and type the last character.
If you have to type string aaaaaaaaa, the best option is to type 4 characters one by one, then copy the string, and then type the remaining character.
Print the minimum number of operations you need to type the given string.
Input
The first line of the input containing only one integer number n (1 ≤ n ≤ 100) — the length of the string you have to type. The second line containing the string s consisting of n lowercase Latin letters.
Output
Print one integer number — the minimum number of operations you need to type the given string.
Examples
Input
7
abcabca
Output
5
Input
8
abcdefgh
Output
8
Note
The first test described in the problem statement.
In the second test you can only type all the characters one by one.
Submitted Solution:
```
n=int(input()); ans=0; u=n*[0]
s=input()
for t in range(n):
if t%2==1:
if s[:int((t+1)/2)]==s[int((t+1)/2):(t+1)]:
ans=t
print (int((ans+1)/2)+1+n-ans-1)
```
Yes
| 99,216 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of n lowercase Latin letters. You have to type this string using your keyboard.
Initially, you have an empty string. Until you type the whole string, you may perform the following operation:
* add a character to the end of the string.
Besides, at most once you may perform one additional operation: copy the string and append it to itself.
For example, if you have to type string abcabca, you can type it in 7 operations if you type all the characters one by one. However, you can type it in 5 operations if you type the string abc first and then copy it and type the last character.
If you have to type string aaaaaaaaa, the best option is to type 4 characters one by one, then copy the string, and then type the remaining character.
Print the minimum number of operations you need to type the given string.
Input
The first line of the input containing only one integer number n (1 ≤ n ≤ 100) — the length of the string you have to type. The second line containing the string s consisting of n lowercase Latin letters.
Output
Print one integer number — the minimum number of operations you need to type the given string.
Examples
Input
7
abcabca
Output
5
Input
8
abcdefgh
Output
8
Note
The first test described in the problem statement.
In the second test you can only type all the characters one by one.
Submitted Solution:
```
n = int(input())
s = str(input())
ans = len(s)
for i in range(1, n+1):
if s[:i] + s[:i] == s[:2*i] and 2*i <= n:
ans = min(ans, n-i+1)
print(ans)
```
Yes
| 99,217 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of n lowercase Latin letters. You have to type this string using your keyboard.
Initially, you have an empty string. Until you type the whole string, you may perform the following operation:
* add a character to the end of the string.
Besides, at most once you may perform one additional operation: copy the string and append it to itself.
For example, if you have to type string abcabca, you can type it in 7 operations if you type all the characters one by one. However, you can type it in 5 operations if you type the string abc first and then copy it and type the last character.
If you have to type string aaaaaaaaa, the best option is to type 4 characters one by one, then copy the string, and then type the remaining character.
Print the minimum number of operations you need to type the given string.
Input
The first line of the input containing only one integer number n (1 ≤ n ≤ 100) — the length of the string you have to type. The second line containing the string s consisting of n lowercase Latin letters.
Output
Print one integer number — the minimum number of operations you need to type the given string.
Examples
Input
7
abcabca
Output
5
Input
8
abcdefgh
Output
8
Note
The first test described in the problem statement.
In the second test you can only type all the characters one by one.
Submitted Solution:
```
n = int(input())
str1 = input()
x = 0
for i in range(1, n//2 +1):
if str1[:i] == str1[i:i*2]:
x=i
print( n - max(x-1 , 0))
```
Yes
| 99,218 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of n lowercase Latin letters. You have to type this string using your keyboard.
Initially, you have an empty string. Until you type the whole string, you may perform the following operation:
* add a character to the end of the string.
Besides, at most once you may perform one additional operation: copy the string and append it to itself.
For example, if you have to type string abcabca, you can type it in 7 operations if you type all the characters one by one. However, you can type it in 5 operations if you type the string abc first and then copy it and type the last character.
If you have to type string aaaaaaaaa, the best option is to type 4 characters one by one, then copy the string, and then type the remaining character.
Print the minimum number of operations you need to type the given string.
Input
The first line of the input containing only one integer number n (1 ≤ n ≤ 100) — the length of the string you have to type. The second line containing the string s consisting of n lowercase Latin letters.
Output
Print one integer number — the minimum number of operations you need to type the given string.
Examples
Input
7
abcabca
Output
5
Input
8
abcdefgh
Output
8
Note
The first test described in the problem statement.
In the second test you can only type all the characters one by one.
Submitted Solution:
```
z=input()
x=input()
l=int(z)
n=0
while(n<=l/2):
if x[0:n]==x[n+1:2*n+1]:
great=n
n=n+1
print(l-great)
```
No
| 99,219 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of n lowercase Latin letters. You have to type this string using your keyboard.
Initially, you have an empty string. Until you type the whole string, you may perform the following operation:
* add a character to the end of the string.
Besides, at most once you may perform one additional operation: copy the string and append it to itself.
For example, if you have to type string abcabca, you can type it in 7 operations if you type all the characters one by one. However, you can type it in 5 operations if you type the string abc first and then copy it and type the last character.
If you have to type string aaaaaaaaa, the best option is to type 4 characters one by one, then copy the string, and then type the remaining character.
Print the minimum number of operations you need to type the given string.
Input
The first line of the input containing only one integer number n (1 ≤ n ≤ 100) — the length of the string you have to type. The second line containing the string s consisting of n lowercase Latin letters.
Output
Print one integer number — the minimum number of operations you need to type the given string.
Examples
Input
7
abcabca
Output
5
Input
8
abcdefgh
Output
8
Note
The first test described in the problem statement.
In the second test you can only type all the characters one by one.
Submitted Solution:
```
n = int(input())
s = input()
for k in range(n // 2, 0, -1):
for i in range(n):
if i + k + k > n:
break
if s[i:i + k] == s[i + k: i + k + k]:
print(n - k + 1)
exit(0)
print(n)
```
No
| 99,220 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of n lowercase Latin letters. You have to type this string using your keyboard.
Initially, you have an empty string. Until you type the whole string, you may perform the following operation:
* add a character to the end of the string.
Besides, at most once you may perform one additional operation: copy the string and append it to itself.
For example, if you have to type string abcabca, you can type it in 7 operations if you type all the characters one by one. However, you can type it in 5 operations if you type the string abc first and then copy it and type the last character.
If you have to type string aaaaaaaaa, the best option is to type 4 characters one by one, then copy the string, and then type the remaining character.
Print the minimum number of operations you need to type the given string.
Input
The first line of the input containing only one integer number n (1 ≤ n ≤ 100) — the length of the string you have to type. The second line containing the string s consisting of n lowercase Latin letters.
Output
Print one integer number — the minimum number of operations you need to type the given string.
Examples
Input
7
abcabca
Output
5
Input
8
abcdefgh
Output
8
Note
The first test described in the problem statement.
In the second test you can only type all the characters one by one.
Submitted Solution:
```
x = int(input())
y = input()
def operations(x):
if x == 0:
return 0
if x % 2 == 0:
part = int(x/2)
if y[0:part] == y[part:2*part]:
return part
else:
return 1 + operations(x-1)
else:
return 1 + operations(x-1)
```
No
| 99,221 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of n lowercase Latin letters. You have to type this string using your keyboard.
Initially, you have an empty string. Until you type the whole string, you may perform the following operation:
* add a character to the end of the string.
Besides, at most once you may perform one additional operation: copy the string and append it to itself.
For example, if you have to type string abcabca, you can type it in 7 operations if you type all the characters one by one. However, you can type it in 5 operations if you type the string abc first and then copy it and type the last character.
If you have to type string aaaaaaaaa, the best option is to type 4 characters one by one, then copy the string, and then type the remaining character.
Print the minimum number of operations you need to type the given string.
Input
The first line of the input containing only one integer number n (1 ≤ n ≤ 100) — the length of the string you have to type. The second line containing the string s consisting of n lowercase Latin letters.
Output
Print one integer number — the minimum number of operations you need to type the given string.
Examples
Input
7
abcabca
Output
5
Input
8
abcdefgh
Output
8
Note
The first test described in the problem statement.
In the second test you can only type all the characters one by one.
Submitted Solution:
```
a= input()
ho=0
for i in range(0, len(a)//2):
if(a[0:i] == a[i:2*i]):
ho=i
ho=ho+1
an=len(a)-ho
print(an)
```
No
| 99,222 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A necklace can be described as a string of links ('-') and pearls ('o'), with the last link or pearl connected to the first one.
<image>
You can remove a link or a pearl and insert it between two other existing links or pearls (or between a link and a pearl) on the necklace. This process can be repeated as many times as you like, but you can't throw away any parts.
Can you make the number of links between every two adjacent pearls equal? Two pearls are considered to be adjacent if there is no other pearl between them.
Note that the final necklace should remain as one circular part of the same length as the initial necklace.
Input
The only line of input contains a string s (3 ≤ |s| ≤ 100), representing the necklace, where a dash '-' represents a link and the lowercase English letter 'o' represents a pearl.
Output
Print "YES" if the links and pearls can be rejoined such that the number of links between adjacent pearls is equal. Otherwise print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
<span class="tex-font-style-tt">-o-o--</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---o-</span>
Output
NO
Input
ooo
Output
YES
Tags: implementation, math
Correct Solution:
```
# coding=utf-8
s = str(input())
links = 0
for i in range(len(s)):
if s[i] == '-':
links += 1
pearls = len(s) - links
if pearls == 0:
print('YES')
elif links%pearls == 0:
print('YES')
else:
print('NO')
```
| 99,223 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A necklace can be described as a string of links ('-') and pearls ('o'), with the last link or pearl connected to the first one.
<image>
You can remove a link or a pearl and insert it between two other existing links or pearls (or between a link and a pearl) on the necklace. This process can be repeated as many times as you like, but you can't throw away any parts.
Can you make the number of links between every two adjacent pearls equal? Two pearls are considered to be adjacent if there is no other pearl between them.
Note that the final necklace should remain as one circular part of the same length as the initial necklace.
Input
The only line of input contains a string s (3 ≤ |s| ≤ 100), representing the necklace, where a dash '-' represents a link and the lowercase English letter 'o' represents a pearl.
Output
Print "YES" if the links and pearls can be rejoined such that the number of links between adjacent pearls is equal. Otherwise print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
<span class="tex-font-style-tt">-o-o--</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---o-</span>
Output
NO
Input
ooo
Output
YES
Tags: implementation, math
Correct Solution:
```
s = input()
ls = len(s)
ac = 0
bc = 0
for i in range(ls):
if s[i] == 'o':
ac += 1
elif s[i] == '-':
bc += 1
if ac == 0:
print('YES')
elif bc % ac == 0:
print('YES')
else:
print('NO')
```
| 99,224 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A necklace can be described as a string of links ('-') and pearls ('o'), with the last link or pearl connected to the first one.
<image>
You can remove a link or a pearl and insert it between two other existing links or pearls (or between a link and a pearl) on the necklace. This process can be repeated as many times as you like, but you can't throw away any parts.
Can you make the number of links between every two adjacent pearls equal? Two pearls are considered to be adjacent if there is no other pearl between them.
Note that the final necklace should remain as one circular part of the same length as the initial necklace.
Input
The only line of input contains a string s (3 ≤ |s| ≤ 100), representing the necklace, where a dash '-' represents a link and the lowercase English letter 'o' represents a pearl.
Output
Print "YES" if the links and pearls can be rejoined such that the number of links between adjacent pearls is equal. Otherwise print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
<span class="tex-font-style-tt">-o-o--</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---o-</span>
Output
NO
Input
ooo
Output
YES
Tags: implementation, math
Correct Solution:
```
a = input()
t = a.count("o")
r = len(a) - t
if t == 0:
print("YES")
elif r%(t) == 0:
print("YES")
else:
print("NO")
```
| 99,225 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A necklace can be described as a string of links ('-') and pearls ('o'), with the last link or pearl connected to the first one.
<image>
You can remove a link or a pearl and insert it between two other existing links or pearls (or between a link and a pearl) on the necklace. This process can be repeated as many times as you like, but you can't throw away any parts.
Can you make the number of links between every two adjacent pearls equal? Two pearls are considered to be adjacent if there is no other pearl between them.
Note that the final necklace should remain as one circular part of the same length as the initial necklace.
Input
The only line of input contains a string s (3 ≤ |s| ≤ 100), representing the necklace, where a dash '-' represents a link and the lowercase English letter 'o' represents a pearl.
Output
Print "YES" if the links and pearls can be rejoined such that the number of links between adjacent pearls is equal. Otherwise print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
<span class="tex-font-style-tt">-o-o--</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---o-</span>
Output
NO
Input
ooo
Output
YES
Tags: implementation, math
Correct Solution:
```
x=input()
# print(x.count('-')%x.count('o'))
if 'o' not in x:
print('YES')
elif '-' not in x:
print('YES')
elif x.count('o')==1:
print('YES')
elif x.count('-')%x.count('o')==0:
print('YES')
else:
print('NO')
```
| 99,226 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A necklace can be described as a string of links ('-') and pearls ('o'), with the last link or pearl connected to the first one.
<image>
You can remove a link or a pearl and insert it between two other existing links or pearls (or between a link and a pearl) on the necklace. This process can be repeated as many times as you like, but you can't throw away any parts.
Can you make the number of links between every two adjacent pearls equal? Two pearls are considered to be adjacent if there is no other pearl between them.
Note that the final necklace should remain as one circular part of the same length as the initial necklace.
Input
The only line of input contains a string s (3 ≤ |s| ≤ 100), representing the necklace, where a dash '-' represents a link and the lowercase English letter 'o' represents a pearl.
Output
Print "YES" if the links and pearls can be rejoined such that the number of links between adjacent pearls is equal. Otherwise print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
<span class="tex-font-style-tt">-o-o--</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---o-</span>
Output
NO
Input
ooo
Output
YES
Tags: implementation, math
Correct Solution:
```
from collections import Counter
l= Counter(input())
print("NO" if l["o"] and l["-"] % l["o"] else "YES")
```
| 99,227 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A necklace can be described as a string of links ('-') and pearls ('o'), with the last link or pearl connected to the first one.
<image>
You can remove a link or a pearl and insert it between two other existing links or pearls (or between a link and a pearl) on the necklace. This process can be repeated as many times as you like, but you can't throw away any parts.
Can you make the number of links between every two adjacent pearls equal? Two pearls are considered to be adjacent if there is no other pearl between them.
Note that the final necklace should remain as one circular part of the same length as the initial necklace.
Input
The only line of input contains a string s (3 ≤ |s| ≤ 100), representing the necklace, where a dash '-' represents a link and the lowercase English letter 'o' represents a pearl.
Output
Print "YES" if the links and pearls can be rejoined such that the number of links between adjacent pearls is equal. Otherwise print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
<span class="tex-font-style-tt">-o-o--</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---o-</span>
Output
NO
Input
ooo
Output
YES
Tags: implementation, math
Correct Solution:
```
import sys,os,io
from sys import stdin
from math import log, gcd, ceil
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from bisect import bisect_left , bisect_right
import math
alphabets = list('abcdefghijklmnopqrstuvwxyz')
def isPrime(x):
for i in range(2,x):
if i*i>x:
break
if (x%i==0):
return False
return True
def ncr(n, r, p):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den,
p - 2, p)) % p
def primeFactors(n):
l = []
while n % 2 == 0:
l.append(2)
n = n / 2
for i in range(3,int(math.sqrt(n))+1,2):
while n % i== 0:
l.append(int(i))
n = n / i
if n > 2:
l.append(n)
return list(set(l))
def power(x, y, p) :
res = 1
x = x % p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) :
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def SieveOfEratosthenes(n):
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return prime
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def si():
return input()
def prefix_sum(arr):
r = [0] * (len(arr)+1)
for i, el in enumerate(arr):
r[i+1] = r[i] + el
return r
def divideCeil(n,x):
if (n%x==0):
return n//x
return n//x+1
def ii():
return int(input())
def li():
return list(map(int,input().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
def power_set(L):
cardinality=len(L)
n=2 ** cardinality
powerset = []
for i in range(n):
a=bin(i)[2:]
subset=[]
for j in range(len(a)):
if a[-j-1]=='1':
subset.append(L[j])
powerset.append(subset)
powerset_orderred=[]
for k in range(cardinality+1):
for w in powerset:
if len(w)==k:
powerset_orderred.append(w)
return powerset_orderred
def fastPlrintNextLines(a):
# 12
# 3
# 1
#like this
#a is list of strings
print('\n'.join(map(str,a)))
def sortByFirstAndSecond(A):
A = sorted(A,key = lambda x:x[0])
A = sorted(A,key = lambda x:x[1])
return list(A)
#__________________________TEMPLATE__________________OVER_______________________________________________________
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r") ; sys.stdout = open("output.txt","w")
# else:
# input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def solve():
s = list(si())
if s.count('o')==0 :
print("YES")
return
if (s.count('-')%s.count('o')==0):
print("YES")
return
print("NO")
t = 1
# t = int(input())
for _ in range(t):
solve()
```
| 99,228 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A necklace can be described as a string of links ('-') and pearls ('o'), with the last link or pearl connected to the first one.
<image>
You can remove a link or a pearl and insert it between two other existing links or pearls (or between a link and a pearl) on the necklace. This process can be repeated as many times as you like, but you can't throw away any parts.
Can you make the number of links between every two adjacent pearls equal? Two pearls are considered to be adjacent if there is no other pearl between them.
Note that the final necklace should remain as one circular part of the same length as the initial necklace.
Input
The only line of input contains a string s (3 ≤ |s| ≤ 100), representing the necklace, where a dash '-' represents a link and the lowercase English letter 'o' represents a pearl.
Output
Print "YES" if the links and pearls can be rejoined such that the number of links between adjacent pearls is equal. Otherwise print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
<span class="tex-font-style-tt">-o-o--</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---o-</span>
Output
NO
Input
ooo
Output
YES
Tags: implementation, math
Correct Solution:
```
s = input()
p = s.count('o')
n = len(s)
if p == 0 or n % p == 0:
ans = 'YES'
else:
ans = 'NO'
print(ans)
```
| 99,229 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A necklace can be described as a string of links ('-') and pearls ('o'), with the last link or pearl connected to the first one.
<image>
You can remove a link or a pearl and insert it between two other existing links or pearls (or between a link and a pearl) on the necklace. This process can be repeated as many times as you like, but you can't throw away any parts.
Can you make the number of links between every two adjacent pearls equal? Two pearls are considered to be adjacent if there is no other pearl between them.
Note that the final necklace should remain as one circular part of the same length as the initial necklace.
Input
The only line of input contains a string s (3 ≤ |s| ≤ 100), representing the necklace, where a dash '-' represents a link and the lowercase English letter 'o' represents a pearl.
Output
Print "YES" if the links and pearls can be rejoined such that the number of links between adjacent pearls is equal. Otherwise print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
<span class="tex-font-style-tt">-o-o--</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---o-</span>
Output
NO
Input
ooo
Output
YES
Tags: implementation, math
Correct Solution:
```
s = input()
count1 = count2 = 0
for i in s:
if i =="-":
count1+=1
else:
count2+=1
if count2==0 or count1==0:
print("YES")
else:
if count1%count2==0:
print("YES")
else:
print("NO")
```
| 99,230 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A necklace can be described as a string of links ('-') and pearls ('o'), with the last link or pearl connected to the first one.
<image>
You can remove a link or a pearl and insert it between two other existing links or pearls (or between a link and a pearl) on the necklace. This process can be repeated as many times as you like, but you can't throw away any parts.
Can you make the number of links between every two adjacent pearls equal? Two pearls are considered to be adjacent if there is no other pearl between them.
Note that the final necklace should remain as one circular part of the same length as the initial necklace.
Input
The only line of input contains a string s (3 ≤ |s| ≤ 100), representing the necklace, where a dash '-' represents a link and the lowercase English letter 'o' represents a pearl.
Output
Print "YES" if the links and pearls can be rejoined such that the number of links between adjacent pearls is equal. Otherwise print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
<span class="tex-font-style-tt">-o-o--</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---o-</span>
Output
NO
Input
ooo
Output
YES
Submitted Solution:
```
from collections import Counter
c = Counter(input())
print("Yes" if c['o'] == 0 or not c['-']%c['o'] else "No")
```
Yes
| 99,231 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A necklace can be described as a string of links ('-') and pearls ('o'), with the last link or pearl connected to the first one.
<image>
You can remove a link or a pearl and insert it between two other existing links or pearls (or between a link and a pearl) on the necklace. This process can be repeated as many times as you like, but you can't throw away any parts.
Can you make the number of links between every two adjacent pearls equal? Two pearls are considered to be adjacent if there is no other pearl between them.
Note that the final necklace should remain as one circular part of the same length as the initial necklace.
Input
The only line of input contains a string s (3 ≤ |s| ≤ 100), representing the necklace, where a dash '-' represents a link and the lowercase English letter 'o' represents a pearl.
Output
Print "YES" if the links and pearls can be rejoined such that the number of links between adjacent pearls is equal. Otherwise print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
<span class="tex-font-style-tt">-o-o--</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---o-</span>
Output
NO
Input
ooo
Output
YES
Submitted Solution:
```
s=input()
n=len(s)
count=0
for i in range(n):
if s[i]=="o":
count+=1
yo=n-count
if count==0:
print("YES")
elif (yo%count==0):
print("YES")
else:
print("NO")
```
Yes
| 99,232 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A necklace can be described as a string of links ('-') and pearls ('o'), with the last link or pearl connected to the first one.
<image>
You can remove a link or a pearl and insert it between two other existing links or pearls (or between a link and a pearl) on the necklace. This process can be repeated as many times as you like, but you can't throw away any parts.
Can you make the number of links between every two adjacent pearls equal? Two pearls are considered to be adjacent if there is no other pearl between them.
Note that the final necklace should remain as one circular part of the same length as the initial necklace.
Input
The only line of input contains a string s (3 ≤ |s| ≤ 100), representing the necklace, where a dash '-' represents a link and the lowercase English letter 'o' represents a pearl.
Output
Print "YES" if the links and pearls can be rejoined such that the number of links between adjacent pearls is equal. Otherwise print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
<span class="tex-font-style-tt">-o-o--</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---o-</span>
Output
NO
Input
ooo
Output
YES
Submitted Solution:
```
def solve(linha, perolas):
if perolas == 0:
return True
else:
return linha % perolas == 0
def main():
s = input()
x, y = 0, 0
for c in s:
if c == '-':
x += 1
else:
y += 1
if solve(x, y):
print('YES')
else:
print('NO')
if __name__ == "__main__":
main()
```
Yes
| 99,233 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A necklace can be described as a string of links ('-') and pearls ('o'), with the last link or pearl connected to the first one.
<image>
You can remove a link or a pearl and insert it between two other existing links or pearls (or between a link and a pearl) on the necklace. This process can be repeated as many times as you like, but you can't throw away any parts.
Can you make the number of links between every two adjacent pearls equal? Two pearls are considered to be adjacent if there is no other pearl between them.
Note that the final necklace should remain as one circular part of the same length as the initial necklace.
Input
The only line of input contains a string s (3 ≤ |s| ≤ 100), representing the necklace, where a dash '-' represents a link and the lowercase English letter 'o' represents a pearl.
Output
Print "YES" if the links and pearls can be rejoined such that the number of links between adjacent pearls is equal. Otherwise print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
<span class="tex-font-style-tt">-o-o--</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---o-</span>
Output
NO
Input
ooo
Output
YES
Submitted Solution:
```
def main():
necklace = input()
n_pearls = necklace.count('o')
n_links = len(necklace) - n_pearls
print('YES' if n_pearls == 0 or n_links % n_pearls == 0 else 'NO')
if __name__ == '__main__':
main()
```
Yes
| 99,234 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A necklace can be described as a string of links ('-') and pearls ('o'), with the last link or pearl connected to the first one.
<image>
You can remove a link or a pearl and insert it between two other existing links or pearls (or between a link and a pearl) on the necklace. This process can be repeated as many times as you like, but you can't throw away any parts.
Can you make the number of links between every two adjacent pearls equal? Two pearls are considered to be adjacent if there is no other pearl between them.
Note that the final necklace should remain as one circular part of the same length as the initial necklace.
Input
The only line of input contains a string s (3 ≤ |s| ≤ 100), representing the necklace, where a dash '-' represents a link and the lowercase English letter 'o' represents a pearl.
Output
Print "YES" if the links and pearls can be rejoined such that the number of links between adjacent pearls is equal. Otherwise print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
<span class="tex-font-style-tt">-o-o--</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---o-</span>
Output
NO
Input
ooo
Output
YES
Submitted Solution:
```
n=input()
l=len(n)
x=n.count('o')
if l%(x+1) and x!=l:
print("NO")
else:
print("YES")
```
No
| 99,235 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A necklace can be described as a string of links ('-') and pearls ('o'), with the last link or pearl connected to the first one.
<image>
You can remove a link or a pearl and insert it between two other existing links or pearls (or between a link and a pearl) on the necklace. This process can be repeated as many times as you like, but you can't throw away any parts.
Can you make the number of links between every two adjacent pearls equal? Two pearls are considered to be adjacent if there is no other pearl between them.
Note that the final necklace should remain as one circular part of the same length as the initial necklace.
Input
The only line of input contains a string s (3 ≤ |s| ≤ 100), representing the necklace, where a dash '-' represents a link and the lowercase English letter 'o' represents a pearl.
Output
Print "YES" if the links and pearls can be rejoined such that the number of links between adjacent pearls is equal. Otherwise print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
<span class="tex-font-style-tt">-o-o--</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---o-</span>
Output
NO
Input
ooo
Output
YES
Submitted Solution:
```
l = list(input())
c = len(l)
if l.count('-')%2==0:
print("YES")
elif l.count('o')==0:
print("YES")
elif l.count('o')==c:
print("YES")
elif l.count('-')%2==1 and l.count('o')%2==1:
print("YES")
elif l.count('o')%2==1 and l.count('-')%2==0:
print("NO")
else:
print("NO")
```
No
| 99,236 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A necklace can be described as a string of links ('-') and pearls ('o'), with the last link or pearl connected to the first one.
<image>
You can remove a link or a pearl and insert it between two other existing links or pearls (or between a link and a pearl) on the necklace. This process can be repeated as many times as you like, but you can't throw away any parts.
Can you make the number of links between every two adjacent pearls equal? Two pearls are considered to be adjacent if there is no other pearl between them.
Note that the final necklace should remain as one circular part of the same length as the initial necklace.
Input
The only line of input contains a string s (3 ≤ |s| ≤ 100), representing the necklace, where a dash '-' represents a link and the lowercase English letter 'o' represents a pearl.
Output
Print "YES" if the links and pearls can be rejoined such that the number of links between adjacent pearls is equal. Otherwise print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
<span class="tex-font-style-tt">-o-o--</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---o-</span>
Output
NO
Input
ooo
Output
YES
Submitted Solution:
```
string = input()
link = string.count('-')
pearl = len(string) - link
if pearl > 0 and link % pearl == 0:
# if link == 0 or pearl == 1, link % pearl == 0
print("YES")
else:
print("NO")
```
No
| 99,237 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A necklace can be described as a string of links ('-') and pearls ('o'), with the last link or pearl connected to the first one.
<image>
You can remove a link or a pearl and insert it between two other existing links or pearls (or between a link and a pearl) on the necklace. This process can be repeated as many times as you like, but you can't throw away any parts.
Can you make the number of links between every two adjacent pearls equal? Two pearls are considered to be adjacent if there is no other pearl between them.
Note that the final necklace should remain as one circular part of the same length as the initial necklace.
Input
The only line of input contains a string s (3 ≤ |s| ≤ 100), representing the necklace, where a dash '-' represents a link and the lowercase English letter 'o' represents a pearl.
Output
Print "YES" if the links and pearls can be rejoined such that the number of links between adjacent pearls is equal. Otherwise print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
<span class="tex-font-style-tt">-o-o--</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---</span>
Output
YES
Input
<span class="tex-font-style-tt">-o---o-</span>
Output
NO
Input
ooo
Output
YES
Submitted Solution:
```
print("YES")
```
No
| 99,238 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Yakko, Wakko and Dot, world-famous animaniacs, decided to rest from acting in cartoons, and take a leave to travel a bit. Yakko dreamt to go to Pennsylvania, his Motherland and the Motherland of his ancestors. Wakko thought about Tasmania, its beaches, sun and sea. Dot chose Transylvania as the most mysterious and unpredictable place.
But to their great regret, the leave turned to be very short, so it will be enough to visit one of the three above named places. That's why Yakko, as the cleverest, came up with a truly genius idea: let each of the three roll an ordinary six-sided die, and the one with the highest amount of points will be the winner, and will take the other two to the place of his/her dreams.
Yakko thrown a die and got Y points, Wakko — W points. It was Dot's turn. But she didn't hurry. Dot wanted to know for sure what were her chances to visit Transylvania.
It is known that Yakko and Wakko are true gentlemen, that's why if they have the same amount of points with Dot, they will let Dot win.
Input
The only line of the input file contains two natural numbers Y and W — the results of Yakko's and Wakko's die rolls.
Output
Output the required probability in the form of irreducible fraction in format «A/B», where A — the numerator, and B — the denominator. If the required probability equals to zero, output «0/1». If the required probability equals to 1, output «1/1».
Examples
Input
4 2
Output
1/2
Note
Dot will go to Transylvania, if she is lucky to roll 4, 5 or 6 points.
Tags: math, probabilities
Correct Solution:
```
from math import gcd
v=list(map(int,input().split()))
a=max(v)
x=6-a+1
z=6
d=gcd(x,z)
x=x//d
z=z//d
print(str(x)+'/'+str(z))
```
| 99,239 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Yakko, Wakko and Dot, world-famous animaniacs, decided to rest from acting in cartoons, and take a leave to travel a bit. Yakko dreamt to go to Pennsylvania, his Motherland and the Motherland of his ancestors. Wakko thought about Tasmania, its beaches, sun and sea. Dot chose Transylvania as the most mysterious and unpredictable place.
But to their great regret, the leave turned to be very short, so it will be enough to visit one of the three above named places. That's why Yakko, as the cleverest, came up with a truly genius idea: let each of the three roll an ordinary six-sided die, and the one with the highest amount of points will be the winner, and will take the other two to the place of his/her dreams.
Yakko thrown a die and got Y points, Wakko — W points. It was Dot's turn. But she didn't hurry. Dot wanted to know for sure what were her chances to visit Transylvania.
It is known that Yakko and Wakko are true gentlemen, that's why if they have the same amount of points with Dot, they will let Dot win.
Input
The only line of the input file contains two natural numbers Y and W — the results of Yakko's and Wakko's die rolls.
Output
Output the required probability in the form of irreducible fraction in format «A/B», where A — the numerator, and B — the denominator. If the required probability equals to zero, output «0/1». If the required probability equals to 1, output «1/1».
Examples
Input
4 2
Output
1/2
Note
Dot will go to Transylvania, if she is lucky to roll 4, 5 or 6 points.
Tags: math, probabilities
Correct Solution:
```
import math
a = max(map(int, input().split()))
num = 7 - a
den = 6
g = math.gcd(num, den)
print(str(num // g) + '/' + str(den // g))
```
| 99,240 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Yakko, Wakko and Dot, world-famous animaniacs, decided to rest from acting in cartoons, and take a leave to travel a bit. Yakko dreamt to go to Pennsylvania, his Motherland and the Motherland of his ancestors. Wakko thought about Tasmania, its beaches, sun and sea. Dot chose Transylvania as the most mysterious and unpredictable place.
But to their great regret, the leave turned to be very short, so it will be enough to visit one of the three above named places. That's why Yakko, as the cleverest, came up with a truly genius idea: let each of the three roll an ordinary six-sided die, and the one with the highest amount of points will be the winner, and will take the other two to the place of his/her dreams.
Yakko thrown a die and got Y points, Wakko — W points. It was Dot's turn. But she didn't hurry. Dot wanted to know for sure what were her chances to visit Transylvania.
It is known that Yakko and Wakko are true gentlemen, that's why if they have the same amount of points with Dot, they will let Dot win.
Input
The only line of the input file contains two natural numbers Y and W — the results of Yakko's and Wakko's die rolls.
Output
Output the required probability in the form of irreducible fraction in format «A/B», where A — the numerator, and B — the denominator. If the required probability equals to zero, output «0/1». If the required probability equals to 1, output «1/1».
Examples
Input
4 2
Output
1/2
Note
Dot will go to Transylvania, if she is lucky to roll 4, 5 or 6 points.
Tags: math, probabilities
Correct Solution:
```
from fractions import Fraction
a_b = input()
ab = a_b.split()
ab = list(map(int,ab))
a,b = ab
m = max(a,b)
ans = Fraction(6-m+1,6)
if ans == 1:
print('1/1')
elif ans == 0:
print('0/1')
else:
print(ans)
```
| 99,241 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Yakko, Wakko and Dot, world-famous animaniacs, decided to rest from acting in cartoons, and take a leave to travel a bit. Yakko dreamt to go to Pennsylvania, his Motherland and the Motherland of his ancestors. Wakko thought about Tasmania, its beaches, sun and sea. Dot chose Transylvania as the most mysterious and unpredictable place.
But to their great regret, the leave turned to be very short, so it will be enough to visit one of the three above named places. That's why Yakko, as the cleverest, came up with a truly genius idea: let each of the three roll an ordinary six-sided die, and the one with the highest amount of points will be the winner, and will take the other two to the place of his/her dreams.
Yakko thrown a die and got Y points, Wakko — W points. It was Dot's turn. But she didn't hurry. Dot wanted to know for sure what were her chances to visit Transylvania.
It is known that Yakko and Wakko are true gentlemen, that's why if they have the same amount of points with Dot, they will let Dot win.
Input
The only line of the input file contains two natural numbers Y and W — the results of Yakko's and Wakko's die rolls.
Output
Output the required probability in the form of irreducible fraction in format «A/B», where A — the numerator, and B — the denominator. If the required probability equals to zero, output «0/1». If the required probability equals to 1, output «1/1».
Examples
Input
4 2
Output
1/2
Note
Dot will go to Transylvania, if she is lucky to roll 4, 5 or 6 points.
Tags: math, probabilities
Correct Solution:
```
from fractions import Fraction
inp = list(map(int, input().rstrip().split()))
if max(inp) == 0:
print('0/1')
else:
prob = (6 - max(inp) + 1) / 6
prob = Fraction(prob).limit_denominator(6)
if prob == 1:
print('1/1')
elif prob <= 0:
print('0/1')
else:
print(prob)
```
| 99,242 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Yakko, Wakko and Dot, world-famous animaniacs, decided to rest from acting in cartoons, and take a leave to travel a bit. Yakko dreamt to go to Pennsylvania, his Motherland and the Motherland of his ancestors. Wakko thought about Tasmania, its beaches, sun and sea. Dot chose Transylvania as the most mysterious and unpredictable place.
But to their great regret, the leave turned to be very short, so it will be enough to visit one of the three above named places. That's why Yakko, as the cleverest, came up with a truly genius idea: let each of the three roll an ordinary six-sided die, and the one with the highest amount of points will be the winner, and will take the other two to the place of his/her dreams.
Yakko thrown a die and got Y points, Wakko — W points. It was Dot's turn. But she didn't hurry. Dot wanted to know for sure what were her chances to visit Transylvania.
It is known that Yakko and Wakko are true gentlemen, that's why if they have the same amount of points with Dot, they will let Dot win.
Input
The only line of the input file contains two natural numbers Y and W — the results of Yakko's and Wakko's die rolls.
Output
Output the required probability in the form of irreducible fraction in format «A/B», where A — the numerator, and B — the denominator. If the required probability equals to zero, output «0/1». If the required probability equals to 1, output «1/1».
Examples
Input
4 2
Output
1/2
Note
Dot will go to Transylvania, if she is lucky to roll 4, 5 or 6 points.
Tags: math, probabilities
Correct Solution:
```
import fractions
while(1):
try:
y,w=map(int,input().split())
maxx=max(y,w)
prob=6-maxx+1
g=fractions.gcd(prob,6)
prob=prob//g
print(prob,end="/")
print(6//g)
except EOFError:
break
```
| 99,243 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Yakko, Wakko and Dot, world-famous animaniacs, decided to rest from acting in cartoons, and take a leave to travel a bit. Yakko dreamt to go to Pennsylvania, his Motherland and the Motherland of his ancestors. Wakko thought about Tasmania, its beaches, sun and sea. Dot chose Transylvania as the most mysterious and unpredictable place.
But to their great regret, the leave turned to be very short, so it will be enough to visit one of the three above named places. That's why Yakko, as the cleverest, came up with a truly genius idea: let each of the three roll an ordinary six-sided die, and the one with the highest amount of points will be the winner, and will take the other two to the place of his/her dreams.
Yakko thrown a die and got Y points, Wakko — W points. It was Dot's turn. But she didn't hurry. Dot wanted to know for sure what were her chances to visit Transylvania.
It is known that Yakko and Wakko are true gentlemen, that's why if they have the same amount of points with Dot, they will let Dot win.
Input
The only line of the input file contains two natural numbers Y and W — the results of Yakko's and Wakko's die rolls.
Output
Output the required probability in the form of irreducible fraction in format «A/B», where A — the numerator, and B — the denominator. If the required probability equals to zero, output «0/1». If the required probability equals to 1, output «1/1».
Examples
Input
4 2
Output
1/2
Note
Dot will go to Transylvania, if she is lucky to roll 4, 5 or 6 points.
Tags: math, probabilities
Correct Solution:
```
a , b = map(int,input().split())
max1 = max(a,b)
k = 6-(max1-1)
if k==1:print("1"+"/"+"6")
elif k==2:print("1"+"/"+"3")
elif k==3:print("1"+"/"+"2")
elif k==4:print("2"+"/"+"3")
elif k==5:print("5"+"/"+"6")
elif k==6:print("1"+"/"+"1")
```
| 99,244 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Yakko, Wakko and Dot, world-famous animaniacs, decided to rest from acting in cartoons, and take a leave to travel a bit. Yakko dreamt to go to Pennsylvania, his Motherland and the Motherland of his ancestors. Wakko thought about Tasmania, its beaches, sun and sea. Dot chose Transylvania as the most mysterious and unpredictable place.
But to their great regret, the leave turned to be very short, so it will be enough to visit one of the three above named places. That's why Yakko, as the cleverest, came up with a truly genius idea: let each of the three roll an ordinary six-sided die, and the one with the highest amount of points will be the winner, and will take the other two to the place of his/her dreams.
Yakko thrown a die and got Y points, Wakko — W points. It was Dot's turn. But she didn't hurry. Dot wanted to know for sure what were her chances to visit Transylvania.
It is known that Yakko and Wakko are true gentlemen, that's why if they have the same amount of points with Dot, they will let Dot win.
Input
The only line of the input file contains two natural numbers Y and W — the results of Yakko's and Wakko's die rolls.
Output
Output the required probability in the form of irreducible fraction in format «A/B», where A — the numerator, and B — the denominator. If the required probability equals to zero, output «0/1». If the required probability equals to 1, output «1/1».
Examples
Input
4 2
Output
1/2
Note
Dot will go to Transylvania, if she is lucky to roll 4, 5 or 6 points.
Tags: math, probabilities
Correct Solution:
```
from fractions import Fraction
x = list(map(lambda y: int(y), input().split(" ")))
y = 7 - max(x)
if y == 6:
print("1/1")
else:
print(Fraction(y, 6))
```
| 99,245 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Yakko, Wakko and Dot, world-famous animaniacs, decided to rest from acting in cartoons, and take a leave to travel a bit. Yakko dreamt to go to Pennsylvania, his Motherland and the Motherland of his ancestors. Wakko thought about Tasmania, its beaches, sun and sea. Dot chose Transylvania as the most mysterious and unpredictable place.
But to their great regret, the leave turned to be very short, so it will be enough to visit one of the three above named places. That's why Yakko, as the cleverest, came up with a truly genius idea: let each of the three roll an ordinary six-sided die, and the one with the highest amount of points will be the winner, and will take the other two to the place of his/her dreams.
Yakko thrown a die and got Y points, Wakko — W points. It was Dot's turn. But she didn't hurry. Dot wanted to know for sure what were her chances to visit Transylvania.
It is known that Yakko and Wakko are true gentlemen, that's why if they have the same amount of points with Dot, they will let Dot win.
Input
The only line of the input file contains two natural numbers Y and W — the results of Yakko's and Wakko's die rolls.
Output
Output the required probability in the form of irreducible fraction in format «A/B», where A — the numerator, and B — the denominator. If the required probability equals to zero, output «0/1». If the required probability equals to 1, output «1/1».
Examples
Input
4 2
Output
1/2
Note
Dot will go to Transylvania, if she is lucky to roll 4, 5 or 6 points.
Tags: math, probabilities
Correct Solution:
```
n,m=input().split()
n=int(n)
m=int(m)
if n>=m:
a=0
for i in range(1,7):
if n<=i:
a=a+1
else:
a=0
for i in range(1,7):
if m<=i:
a=a+1
if a==1:
print(str(1)+"/"+str(6))
if a==2:
print(str(1)+"/"+str(3))
if a==3:
print(str(1)+"/"+str(2))
if a==4:
print(str(2)+"/"+str(3))
if a==5:
print(str(5)+"/"+str(6))
if a==6:
print(str(1)+"/"+str(1))
```
| 99,246 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Yakko, Wakko and Dot, world-famous animaniacs, decided to rest from acting in cartoons, and take a leave to travel a bit. Yakko dreamt to go to Pennsylvania, his Motherland and the Motherland of his ancestors. Wakko thought about Tasmania, its beaches, sun and sea. Dot chose Transylvania as the most mysterious and unpredictable place.
But to their great regret, the leave turned to be very short, so it will be enough to visit one of the three above named places. That's why Yakko, as the cleverest, came up with a truly genius idea: let each of the three roll an ordinary six-sided die, and the one with the highest amount of points will be the winner, and will take the other two to the place of his/her dreams.
Yakko thrown a die and got Y points, Wakko — W points. It was Dot's turn. But she didn't hurry. Dot wanted to know for sure what were her chances to visit Transylvania.
It is known that Yakko and Wakko are true gentlemen, that's why if they have the same amount of points with Dot, they will let Dot win.
Input
The only line of the input file contains two natural numbers Y and W — the results of Yakko's and Wakko's die rolls.
Output
Output the required probability in the form of irreducible fraction in format «A/B», where A — the numerator, and B — the denominator. If the required probability equals to zero, output «0/1». If the required probability equals to 1, output «1/1».
Examples
Input
4 2
Output
1/2
Note
Dot will go to Transylvania, if she is lucky to roll 4, 5 or 6 points.
Submitted Solution:
```
x , y= map(int,input().split())
if x == 1 and y ==1:
print('1/1')
elif (6-max(x,y)+1) %2 ==0:
print(str(int((6-max(x,y)+1)/2))+'/'+str(int(6/2)))
elif (6-max(x,y)+1)%3 ==0:
print('1/2')
else:
print(str((6-max(x,y)+1))+'/'+'6')
```
Yes
| 99,247 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Yakko, Wakko and Dot, world-famous animaniacs, decided to rest from acting in cartoons, and take a leave to travel a bit. Yakko dreamt to go to Pennsylvania, his Motherland and the Motherland of his ancestors. Wakko thought about Tasmania, its beaches, sun and sea. Dot chose Transylvania as the most mysterious and unpredictable place.
But to their great regret, the leave turned to be very short, so it will be enough to visit one of the three above named places. That's why Yakko, as the cleverest, came up with a truly genius idea: let each of the three roll an ordinary six-sided die, and the one with the highest amount of points will be the winner, and will take the other two to the place of his/her dreams.
Yakko thrown a die and got Y points, Wakko — W points. It was Dot's turn. But she didn't hurry. Dot wanted to know for sure what were her chances to visit Transylvania.
It is known that Yakko and Wakko are true gentlemen, that's why if they have the same amount of points with Dot, they will let Dot win.
Input
The only line of the input file contains two natural numbers Y and W — the results of Yakko's and Wakko's die rolls.
Output
Output the required probability in the form of irreducible fraction in format «A/B», where A — the numerator, and B — the denominator. If the required probability equals to zero, output «0/1». If the required probability equals to 1, output «1/1».
Examples
Input
4 2
Output
1/2
Note
Dot will go to Transylvania, if she is lucky to roll 4, 5 or 6 points.
Submitted Solution:
```
def sr(ch):
ch1=ch+' '
l=[]
p=''
for i in ch1:
if i!=' ':
p=p+i
else:
l.append(int(p))
p=''
return l
def pgcd(x,y):
if y==0:
return x
else:
r=x%y
return pgcd(y,r)
ch=str(input())
l=sr(ch)
x=l[0]
y=l[1]
z=max(x,y)
def prob(x,y):
ch='/'
return str(int(x/pgcd(x,y)))+ch+str(int(y/pgcd(x,y)))
print(prob(6-z+1,6))
```
Yes
| 99,248 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Yakko, Wakko and Dot, world-famous animaniacs, decided to rest from acting in cartoons, and take a leave to travel a bit. Yakko dreamt to go to Pennsylvania, his Motherland and the Motherland of his ancestors. Wakko thought about Tasmania, its beaches, sun and sea. Dot chose Transylvania as the most mysterious and unpredictable place.
But to their great regret, the leave turned to be very short, so it will be enough to visit one of the three above named places. That's why Yakko, as the cleverest, came up with a truly genius idea: let each of the three roll an ordinary six-sided die, and the one with the highest amount of points will be the winner, and will take the other two to the place of his/her dreams.
Yakko thrown a die and got Y points, Wakko — W points. It was Dot's turn. But she didn't hurry. Dot wanted to know for sure what were her chances to visit Transylvania.
It is known that Yakko and Wakko are true gentlemen, that's why if they have the same amount of points with Dot, they will let Dot win.
Input
The only line of the input file contains two natural numbers Y and W — the results of Yakko's and Wakko's die rolls.
Output
Output the required probability in the form of irreducible fraction in format «A/B», where A — the numerator, and B — the denominator. If the required probability equals to zero, output «0/1». If the required probability equals to 1, output «1/1».
Examples
Input
4 2
Output
1/2
Note
Dot will go to Transylvania, if she is lucky to roll 4, 5 or 6 points.
Submitted Solution:
```
from array import array # noqa: F401
from math import gcd
x, y = map(int, input().split())
n = 6 - max(x, y) + 1
d = 6
g = gcd(n, d)
print(f'{n//g}/{d//g}')
```
Yes
| 99,249 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Yakko, Wakko and Dot, world-famous animaniacs, decided to rest from acting in cartoons, and take a leave to travel a bit. Yakko dreamt to go to Pennsylvania, his Motherland and the Motherland of his ancestors. Wakko thought about Tasmania, its beaches, sun and sea. Dot chose Transylvania as the most mysterious and unpredictable place.
But to their great regret, the leave turned to be very short, so it will be enough to visit one of the three above named places. That's why Yakko, as the cleverest, came up with a truly genius idea: let each of the three roll an ordinary six-sided die, and the one with the highest amount of points will be the winner, and will take the other two to the place of his/her dreams.
Yakko thrown a die and got Y points, Wakko — W points. It was Dot's turn. But she didn't hurry. Dot wanted to know for sure what were her chances to visit Transylvania.
It is known that Yakko and Wakko are true gentlemen, that's why if they have the same amount of points with Dot, they will let Dot win.
Input
The only line of the input file contains two natural numbers Y and W — the results of Yakko's and Wakko's die rolls.
Output
Output the required probability in the form of irreducible fraction in format «A/B», where A — the numerator, and B — the denominator. If the required probability equals to zero, output «0/1». If the required probability equals to 1, output «1/1».
Examples
Input
4 2
Output
1/2
Note
Dot will go to Transylvania, if she is lucky to roll 4, 5 or 6 points.
Submitted Solution:
```
a, b = map(int, input().split(' '))
a = max(a, b)
if a == 1:
a = '1/1'
elif a == 2:
a = '5/6'
elif a == 3:
a = '2/3'
elif a == 4:
a = '1/2'
elif a == 5:
a = '1/3'
elif a == 6:
a = '1/6'
print(a)
```
Yes
| 99,250 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Yakko, Wakko and Dot, world-famous animaniacs, decided to rest from acting in cartoons, and take a leave to travel a bit. Yakko dreamt to go to Pennsylvania, his Motherland and the Motherland of his ancestors. Wakko thought about Tasmania, its beaches, sun and sea. Dot chose Transylvania as the most mysterious and unpredictable place.
But to their great regret, the leave turned to be very short, so it will be enough to visit one of the three above named places. That's why Yakko, as the cleverest, came up with a truly genius idea: let each of the three roll an ordinary six-sided die, and the one with the highest amount of points will be the winner, and will take the other two to the place of his/her dreams.
Yakko thrown a die and got Y points, Wakko — W points. It was Dot's turn. But she didn't hurry. Dot wanted to know for sure what were her chances to visit Transylvania.
It is known that Yakko and Wakko are true gentlemen, that's why if they have the same amount of points with Dot, they will let Dot win.
Input
The only line of the input file contains two natural numbers Y and W — the results of Yakko's and Wakko's die rolls.
Output
Output the required probability in the form of irreducible fraction in format «A/B», where A — the numerator, and B — the denominator. If the required probability equals to zero, output «0/1». If the required probability equals to 1, output «1/1».
Examples
Input
4 2
Output
1/2
Note
Dot will go to Transylvania, if she is lucky to roll 4, 5 or 6 points.
Submitted Solution:
```
print((7 - max([int(x) for x in input().split()]))/6)
```
No
| 99,251 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Yakko, Wakko and Dot, world-famous animaniacs, decided to rest from acting in cartoons, and take a leave to travel a bit. Yakko dreamt to go to Pennsylvania, his Motherland and the Motherland of his ancestors. Wakko thought about Tasmania, its beaches, sun and sea. Dot chose Transylvania as the most mysterious and unpredictable place.
But to their great regret, the leave turned to be very short, so it will be enough to visit one of the three above named places. That's why Yakko, as the cleverest, came up with a truly genius idea: let each of the three roll an ordinary six-sided die, and the one with the highest amount of points will be the winner, and will take the other two to the place of his/her dreams.
Yakko thrown a die and got Y points, Wakko — W points. It was Dot's turn. But she didn't hurry. Dot wanted to know for sure what were her chances to visit Transylvania.
It is known that Yakko and Wakko are true gentlemen, that's why if they have the same amount of points with Dot, they will let Dot win.
Input
The only line of the input file contains two natural numbers Y and W — the results of Yakko's and Wakko's die rolls.
Output
Output the required probability in the form of irreducible fraction in format «A/B», where A — the numerator, and B — the denominator. If the required probability equals to zero, output «0/1». If the required probability equals to 1, output «1/1».
Examples
Input
4 2
Output
1/2
Note
Dot will go to Transylvania, if she is lucky to roll 4, 5 or 6 points.
Submitted Solution:
```
from fractions import Fraction
y, w = map(int, input().split())
mx = max(y, w)
ans = 7 - mx
print(Fraction(ans/6))
```
No
| 99,252 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Yakko, Wakko and Dot, world-famous animaniacs, decided to rest from acting in cartoons, and take a leave to travel a bit. Yakko dreamt to go to Pennsylvania, his Motherland and the Motherland of his ancestors. Wakko thought about Tasmania, its beaches, sun and sea. Dot chose Transylvania as the most mysterious and unpredictable place.
But to their great regret, the leave turned to be very short, so it will be enough to visit one of the three above named places. That's why Yakko, as the cleverest, came up with a truly genius idea: let each of the three roll an ordinary six-sided die, and the one with the highest amount of points will be the winner, and will take the other two to the place of his/her dreams.
Yakko thrown a die and got Y points, Wakko — W points. It was Dot's turn. But she didn't hurry. Dot wanted to know for sure what were her chances to visit Transylvania.
It is known that Yakko and Wakko are true gentlemen, that's why if they have the same amount of points with Dot, they will let Dot win.
Input
The only line of the input file contains two natural numbers Y and W — the results of Yakko's and Wakko's die rolls.
Output
Output the required probability in the form of irreducible fraction in format «A/B», where A — the numerator, and B — the denominator. If the required probability equals to zero, output «0/1». If the required probability equals to 1, output «1/1».
Examples
Input
4 2
Output
1/2
Note
Dot will go to Transylvania, if she is lucky to roll 4, 5 or 6 points.
Submitted Solution:
```
temp = [int(x) for x in input().split()]
y = temp[0]
w = temp[1]
d = 6-(max(y, w)-1)
if d == 0 or d == 6:
print(str(d%5) + '/1')
elif d%2 == 0:
print(str(d//2) + '/3')
elif d == 5:
print('5/6')
else:
print('1/2')
```
No
| 99,253 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Yakko, Wakko and Dot, world-famous animaniacs, decided to rest from acting in cartoons, and take a leave to travel a bit. Yakko dreamt to go to Pennsylvania, his Motherland and the Motherland of his ancestors. Wakko thought about Tasmania, its beaches, sun and sea. Dot chose Transylvania as the most mysterious and unpredictable place.
But to their great regret, the leave turned to be very short, so it will be enough to visit one of the three above named places. That's why Yakko, as the cleverest, came up with a truly genius idea: let each of the three roll an ordinary six-sided die, and the one with the highest amount of points will be the winner, and will take the other two to the place of his/her dreams.
Yakko thrown a die and got Y points, Wakko — W points. It was Dot's turn. But she didn't hurry. Dot wanted to know for sure what were her chances to visit Transylvania.
It is known that Yakko and Wakko are true gentlemen, that's why if they have the same amount of points with Dot, they will let Dot win.
Input
The only line of the input file contains two natural numbers Y and W — the results of Yakko's and Wakko's die rolls.
Output
Output the required probability in the form of irreducible fraction in format «A/B», where A — the numerator, and B — the denominator. If the required probability equals to zero, output «0/1». If the required probability equals to 1, output «1/1».
Examples
Input
4 2
Output
1/2
Note
Dot will go to Transylvania, if she is lucky to roll 4, 5 or 6 points.
Submitted Solution:
```
from fractions import Fraction
Y,W=map(int,input().split())
if Y>W:
print(Fraction((6-(Y-1)),6))
if Y<W:
print(Fraction((6-(W-1)),6))
if Y==W:
print(Fraction((6-(W-1)),6))
```
No
| 99,254 |
Provide a correct Python 3 solution for this coding contest problem.
Given are a permutation p_1, p_2, \dots, p_N of (1, 2, ..., N) and an integer K. Maroon performs the following operation for i = 1, 2, \dots, N - K + 1 in this order:
* Shuffle p_i, p_{i + 1}, \dots, p_{i + K - 1} uniformly randomly.
Find the expected value of the inversion number of the sequence after all the operations are performed, and print it modulo 998244353.
More specifically, from the constraints of this problem, it can be proved that the expected value is always a rational number, which can be represented as an irreducible fraction \frac{P}{Q}, and that the integer R that satisfies R \times Q \equiv P \pmod{998244353}, 0 \leq R < 998244353 is uniquely determined. Print this R.
Here, the inversion number of a sequence a_1, a_2, \dots, a_N is defined to be the number of ordered pairs (i, j) that satisfy i < j, a_i > a_j.
Constraints
* 2 \leq N \leq 200,000
* 2 \leq K \leq N
* (p_1, p_2, \dots, p_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
p_1 p_2 ... p_N
Output
Print the expected value modulo 998244353.
Examples
Input
3 2
1 2 3
Output
1
Input
10 3
1 8 4 9 2 3 7 10 5 6
Output
164091855
"Correct Solution:
```
class BIT: #0-indexed
__slots__ = ["size", "tree","depth","n0"]
def __init__(self, n):
self.size = n
self.tree = [0]*(n+1)
self.depth = n.bit_length()
self.n0 = 1<<self.depth
def get_sum(self, i): #a_0 + ... + a_{i} #閉区間
s = 0; i += 1
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def range_sum(self,l,r): #a_l + ... + a_r 閉区間
return self.get_sum(r) - self.get_sum(l-1)
def add(self, i, x):
i += 1
while i <= self.size:
self.tree[i] += x
i += i & -i
def bisect_left(self,w):
#和が w 以上になる最小の index
#w が存在しない場合 self.size を返す
if w <= 0: return 0
x,k = 0,self.n0
for _ in range(self.depth):
k >>= 1
if x+k <= self.size and self.tree[x+k] < w:
w -= self.tree[x+k]
x += k
return x
# coding: utf-8
# Your code here!
import sys
readline = sys.stdin.readline
read = sys.stdin.read
n,k = map(int,readline().split())
*p, = map(int,readline().split())
b = BIT(n)
num = BIT(n)
MOD = 998244353
inv2 = (MOD+1)//2
for i in range(k):
b.add(p[i]-1,inv2)
num.add(p[i]-1,1)
ans = k*(k-1)//2%MOD*inv2%MOD
prob = (k-1)*pow(k,MOD-2,MOD)%MOD #(k-1/k)
pinv = pow(prob,MOD-2,MOD)
val = pinv*inv2%MOD #(k-1)/k/2: これを bit に足していく
rate = prob #倍率
for j in range(k,n):
# p_i < p_j
pj = p[j]-1
v = b.get_sum(pj)
ans += v*rate%MOD
ans %= MOD
# p_i > p_j
w = b.get_sum(n-1)-v
ans += (j - num.get_sum(pj)) - w*rate%MOD
ans %= MOD
b.add(pj,val)
num.add(pj,1)
val = val*pinv%MOD
rate = rate*prob%MOD
print(ans%MOD)
```
| 99,255 |
Provide a correct Python 3 solution for this coding contest problem.
Given are a permutation p_1, p_2, \dots, p_N of (1, 2, ..., N) and an integer K. Maroon performs the following operation for i = 1, 2, \dots, N - K + 1 in this order:
* Shuffle p_i, p_{i + 1}, \dots, p_{i + K - 1} uniformly randomly.
Find the expected value of the inversion number of the sequence after all the operations are performed, and print it modulo 998244353.
More specifically, from the constraints of this problem, it can be proved that the expected value is always a rational number, which can be represented as an irreducible fraction \frac{P}{Q}, and that the integer R that satisfies R \times Q \equiv P \pmod{998244353}, 0 \leq R < 998244353 is uniquely determined. Print this R.
Here, the inversion number of a sequence a_1, a_2, \dots, a_N is defined to be the number of ordered pairs (i, j) that satisfy i < j, a_i > a_j.
Constraints
* 2 \leq N \leq 200,000
* 2 \leq K \leq N
* (p_1, p_2, \dots, p_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
p_1 p_2 ... p_N
Output
Print the expected value modulo 998244353.
Examples
Input
3 2
1 2 3
Output
1
Input
10 3
1 8 4 9 2 3 7 10 5 6
Output
164091855
"Correct Solution:
```
class SegmentTree():
def __init__(self, init, unit, f):
self.unit = unit
self.f = f
if type(init) == int:
self.n = init
# self.n = 1 << (self.n - 1).bit_length()
self.X = [unit] * (self.n * 2)
else:
self.n = len(init)
# self.n = 1 << (self.n - 1).bit_length()
self.X = [unit] * self.n + init + [unit] * (self.n - len(init))
for i in range(self.n-1, 0, -1):
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
def getvalue(self, i):
i += self.n
return self.X[i]
def update(self, i, x):
i += self.n
self.X[i] = x
i >>= 1
while i:
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
i >>= 1
def add(self, i, x):
i += self.n
self.X[i] = (self.X[i] + x) % mod
i >>= 1
while i:
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
i >>= 1
def getrange(self, l, r):
l += self.n
r += self.n
al = self.unit
ar = self.unit
while l < r:
if l & 1:
al = self.f(al, self.X[l])
l += 1
if r & 1:
r -= 1
ar = self.f(self.X[r], ar)
l >>= 1
r >>= 1
return self.f(al, ar)
def debug(self):
de = []
a, b = self.n, self.n * 2
while b:
de.append(self.X[a:b])
a, b = a//2, a
print("--- debug ---")
for d in de[::-1]:
print(d)
print("--- ---")
def r(a):
for i in range(1, 10001):
if i and a * i % mod <= 10000:
return str(a*i%mod) + "/" + str(i)
if i and -a * i % mod <= 10000:
return str(-(-a*i%mod)) + "/" + str(i)
return a
mod = 998244353
N, K = map(int, input().split())
P = [int(a) - 1 for a in input().split()]
f = lambda a, b: (a + b) % mod
p1 = (K - 1) * (K - 2) * pow(4, mod - 2, mod) % mod
p2 = K * (K - 1) * pow(4, mod - 2, mod) % mod
m = (K - 1) * pow(K, mod - 2, mod) % mod
invm = K * pow(K - 1, mod - 2, mod) % mod
st1 = SegmentTree(N, 0, f)
st2 = SegmentTree(N, 0, f)
ans = p2
for i, x in enumerate(P):
if i >= K:
ans = (ans + st1.getrange(x, N)) % mod
st1.add(x, 1)
s = 1
invs = 1
st = SegmentTree(N, 0, f)
for i, x in enumerate(P[:K]):
st.add(x, 1)
for i in range(K, N):
s = s * m % mod
invs = invs * invm % mod
x = P[i]
a = st.getrange(x, N) * s % mod
ans = (ans + p2 - p1 - a) % mod
st.add(x, invs % mod)
print(ans)
```
| 99,256 |
Provide a correct Python 3 solution for this coding contest problem.
Given are a permutation p_1, p_2, \dots, p_N of (1, 2, ..., N) and an integer K. Maroon performs the following operation for i = 1, 2, \dots, N - K + 1 in this order:
* Shuffle p_i, p_{i + 1}, \dots, p_{i + K - 1} uniformly randomly.
Find the expected value of the inversion number of the sequence after all the operations are performed, and print it modulo 998244353.
More specifically, from the constraints of this problem, it can be proved that the expected value is always a rational number, which can be represented as an irreducible fraction \frac{P}{Q}, and that the integer R that satisfies R \times Q \equiv P \pmod{998244353}, 0 \leq R < 998244353 is uniquely determined. Print this R.
Here, the inversion number of a sequence a_1, a_2, \dots, a_N is defined to be the number of ordered pairs (i, j) that satisfy i < j, a_i > a_j.
Constraints
* 2 \leq N \leq 200,000
* 2 \leq K \leq N
* (p_1, p_2, \dots, p_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
p_1 p_2 ... p_N
Output
Print the expected value modulo 998244353.
Examples
Input
3 2
1 2 3
Output
1
Input
10 3
1 8 4 9 2 3 7 10 5 6
Output
164091855
"Correct Solution:
```
class BIT: #0-indexed
__slots__ = ["size", "tree","depth","n0"]
def __init__(self, n):
self.size = n
self.tree = [0]*(n+1)
self.depth = n.bit_length()
self.n0 = 1<<self.depth
def get_sum(self, i): #a_0 + ... + a_{i} #閉区間
s = 0; i += 1
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def range_sum(self,l,r): #a_l + ... + a_r 閉区間
return self.get_sum(r) - self.get_sum(l-1)
def add(self, i, x):
i += 1
while i <= self.size:
self.tree[i] += x
i += i & -i
def bisect_left(self,w):
#和が w 以上になる最小の index
#w が存在しない場合 self.size を返す
if w <= 0: return 0
x,k = 0,self.n0
for _ in range(self.depth):
k >>= 1
if x+k <= self.size and self.tree[x+k] < w:
w -= self.tree[x+k]
x += k
return x
# coding: utf-8
# Your code here!
import sys
readline = sys.stdin.readline
read = sys.stdin.read
n,k = map(int,readline().split())
*p, = map(int,readline().split())
b = BIT(n)
num = BIT(n)
MOD = 998244353
inv = (MOD+1)//2
for i in range(k):
b.add(p[i]-1,1)
num.add(p[i]-1,1)
ans = k*(k-1)//2%MOD*inv%MOD
tot = k
rate = (k-1)*pow(k,MOD-2,MOD)%MOD
rateinv = pow(rate,MOD-2,MOD)
bunbo = rate
hosei = rateinv
for i in range(k,n):
pi = p[i]-1
v = b.get_sum(pi)
#print(v*inv%MOD*bunbo%MOD,v*inv%MOD*bunbo%MOD*4%MOD,"v")
ans += v*inv%MOD*bunbo%MOD
ans %= MOD
x = i - num.get_sum(pi)
w = x - (tot-v)*inv%MOD*bunbo%MOD
#print(x,tot,v)
#print(w,w*4%MOD,"w")
ans += w
ans %= MOD
b.add(pi,hosei)
num.add(pi,1)
tot += hosei
hosei = hosei*rateinv%MOD
bunbo = bunbo*rate%MOD
print(ans%MOD)
#print(ans*8%MOD)
```
| 99,257 |
Provide a correct Python 3 solution for this coding contest problem.
Given are a permutation p_1, p_2, \dots, p_N of (1, 2, ..., N) and an integer K. Maroon performs the following operation for i = 1, 2, \dots, N - K + 1 in this order:
* Shuffle p_i, p_{i + 1}, \dots, p_{i + K - 1} uniformly randomly.
Find the expected value of the inversion number of the sequence after all the operations are performed, and print it modulo 998244353.
More specifically, from the constraints of this problem, it can be proved that the expected value is always a rational number, which can be represented as an irreducible fraction \frac{P}{Q}, and that the integer R that satisfies R \times Q \equiv P \pmod{998244353}, 0 \leq R < 998244353 is uniquely determined. Print this R.
Here, the inversion number of a sequence a_1, a_2, \dots, a_N is defined to be the number of ordered pairs (i, j) that satisfy i < j, a_i > a_j.
Constraints
* 2 \leq N \leq 200,000
* 2 \leq K \leq N
* (p_1, p_2, \dots, p_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
p_1 p_2 ... p_N
Output
Print the expected value modulo 998244353.
Examples
Input
3 2
1 2 3
Output
1
Input
10 3
1 8 4 9 2 3 7 10 5 6
Output
164091855
"Correct Solution:
```
class SegmentTree:
def __init__(self, data, default=0, func=max):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
"""func of data[start, stop)"""
start += self._size
stop += self._size
res_left = res_right = self._default
while start < stop:
if start & 1:
res_left = self._func(res_left, self.data[start])
start += 1
if stop & 1:
stop -= 1
res_right = self._func(self.data[stop], res_right)
start >>= 1
stop >>= 1
return self._func(res_left, res_right)
def __repr__(self):
return "SegmentTree({0})".format(self.data)
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, y, x = egcd(b % a, a)
return (g, x - (b // a) * y, y)
def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
n, k = map(int, input().split())
p = list(map(lambda x: int(x) - 1, input().split()))
out = 0
mod = 998244353
mult_r = (k-1) * modinv(k, mod)
mult_inv = modinv(mult_r, mod)
mult = 1
inv = 1
seg = SegmentTree([0] * n, func = lambda x,y: x+y)
seg2 = SegmentTree([0] * n, func = lambda x,y: x+y)
for i in range(n):
if i >= k:
mult *= mult_r
mult %= mod
inv *= mult_inv
inv %= mod
expected_above = (seg.query(p[i], n) * mult) % mod
expected_below = (seg.query(0,p[i]) * mult) % mod
tot_above = seg2.query(p[i], n)
#tot_below = seg2.query(0, p[i])
out += tot_above - modinv(2, mod) * (expected_above)
out += modinv(2, mod) * (expected_below)
out %= mod
seg[p[i]] = inv
seg2[p[i]] = 1
print(out)
#print((modinv(2, mod) * dout) % mod)
```
| 99,258 |
Provide a correct Python 3 solution for this coding contest problem.
Given are a permutation p_1, p_2, \dots, p_N of (1, 2, ..., N) and an integer K. Maroon performs the following operation for i = 1, 2, \dots, N - K + 1 in this order:
* Shuffle p_i, p_{i + 1}, \dots, p_{i + K - 1} uniformly randomly.
Find the expected value of the inversion number of the sequence after all the operations are performed, and print it modulo 998244353.
More specifically, from the constraints of this problem, it can be proved that the expected value is always a rational number, which can be represented as an irreducible fraction \frac{P}{Q}, and that the integer R that satisfies R \times Q \equiv P \pmod{998244353}, 0 \leq R < 998244353 is uniquely determined. Print this R.
Here, the inversion number of a sequence a_1, a_2, \dots, a_N is defined to be the number of ordered pairs (i, j) that satisfy i < j, a_i > a_j.
Constraints
* 2 \leq N \leq 200,000
* 2 \leq K \leq N
* (p_1, p_2, \dots, p_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
p_1 p_2 ... p_N
Output
Print the expected value modulo 998244353.
Examples
Input
3 2
1 2 3
Output
1
Input
10 3
1 8 4 9 2 3 7 10 5 6
Output
164091855
"Correct Solution:
```
import sys
readline = sys.stdin.buffer.readline
mod=998244353
class BIT:
def __init__(self,n):
self.n=n
self.buf=[0]*n
def add(self,i,v):
buf=self.buf
while i<n:
buf[i]+=v
if buf[i]>=mod:
buf[i]-=mod
i+=(i+1)&(-i-1)
def get(self,i):
buf=self.buf
res=0
while i>=0:
res+=buf[i]
if res>=mod:
res-=mod
i-=(i+1)&(-i-1)
return res
def rng(self,b,e):
res=self.get(e-1)-self.get(b)
if res<0:
res+=mod
return res
n,k=map(int,readline().split())
p=list(map(int,readline().split()))
for i in range(n):
p[i]-=1
ans=0
bit=BIT(n)
for i in range(n):
ans+=i-bit.get(p[i])
bit.add(p[i],1)
z=pow(2,mod-2,mod);
w=1
winv=1
rem=(k-1)*pow(k,mod-2,mod)%mod
reminv=pow(rem,mod-2,mod)
bit=BIT(n)
for i in range(n):
lw=bit.get(p[i])
up=bit.rng(p[i],n)
dif=(lw-up+mod)%mod
ans=(ans+dif*w*z)%mod
bit.add(p[i],winv)
if i>=k-1:
w=w*rem%mod
winv=winv*reminv%mod
print(ans)
```
| 99,259 |
Provide a correct Python 3 solution for this coding contest problem.
Given are a permutation p_1, p_2, \dots, p_N of (1, 2, ..., N) and an integer K. Maroon performs the following operation for i = 1, 2, \dots, N - K + 1 in this order:
* Shuffle p_i, p_{i + 1}, \dots, p_{i + K - 1} uniformly randomly.
Find the expected value of the inversion number of the sequence after all the operations are performed, and print it modulo 998244353.
More specifically, from the constraints of this problem, it can be proved that the expected value is always a rational number, which can be represented as an irreducible fraction \frac{P}{Q}, and that the integer R that satisfies R \times Q \equiv P \pmod{998244353}, 0 \leq R < 998244353 is uniquely determined. Print this R.
Here, the inversion number of a sequence a_1, a_2, \dots, a_N is defined to be the number of ordered pairs (i, j) that satisfy i < j, a_i > a_j.
Constraints
* 2 \leq N \leq 200,000
* 2 \leq K \leq N
* (p_1, p_2, \dots, p_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
p_1 p_2 ... p_N
Output
Print the expected value modulo 998244353.
Examples
Input
3 2
1 2 3
Output
1
Input
10 3
1 8 4 9 2 3 7 10 5 6
Output
164091855
"Correct Solution:
```
import sys
readline = sys.stdin.readline
class BIT:
#1-indexed
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
self.p = 2**(n.bit_length() - 1)
self.dep = n.bit_length()
def get(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
def bl(self, v):
if v <= 0:
return -1
s = 0
k = self.p
for _ in range(self.dep):
if s + k <= self.size and self.tree[s+k] < v:
s += k
v -= self.tree[s+k]
k //= 2
return s + 1
N, K = map(int, readline().split())
MOD = 998244353
P = list(map(int, readline().split()))
r = (K-1)*pow(K, MOD-2, MOD)
L = [pow(r, max(0, i-K+1), MOD) for i in range(N)]
Linv = [pow(l, MOD-2, MOD) for l in L]
T1 = BIT(N)
T2 = BIT(N)
ans = 0
asum = 0
ti = (MOD+1)//2
for i in range(N):
ans += i - T2.get(P[i])
g1 = T1.get(P[i])
ans = (ans + ti*L[i]*(2*g1-asum))%MOD
T2.add(P[i], 1)
T1.add(P[i], Linv[i])
asum = (asum + Linv[i]) % MOD
print(ans)
```
| 99,260 |
Provide a correct Python 3 solution for this coding contest problem.
The cat Snuke wants to play a popular Japanese game called ÅtCoder, so Iroha has decided to teach him Japanese.
When counting pencils in Japanese, the counter word "本" follows the number. The pronunciation of this word varies depending on the number. Specifically, the pronunciation of "本" in the phrase "N 本" for a positive integer N not exceeding 999 is as follows:
* `hon` when the digit in the one's place of N is 2, 4, 5, 7, or 9;
* `pon` when the digit in the one's place of N is 0, 1, 6 or 8;
* `bon` when the digit in the one's place of N is 3.
Given N, print the pronunciation of "本" in the phrase "N 本".
Constraints
* N is a positive integer not exceeding 999.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
16
Output
pon
Input
2
Output
hon
Input
183
Output
bon
"Correct Solution:
```
m = 'pphbhhphph'
print(m[int(input())%10] + 'on')
```
| 99,261 |
Provide a correct Python 3 solution for this coding contest problem.
The cat Snuke wants to play a popular Japanese game called ÅtCoder, so Iroha has decided to teach him Japanese.
When counting pencils in Japanese, the counter word "本" follows the number. The pronunciation of this word varies depending on the number. Specifically, the pronunciation of "本" in the phrase "N 本" for a positive integer N not exceeding 999 is as follows:
* `hon` when the digit in the one's place of N is 2, 4, 5, 7, or 9;
* `pon` when the digit in the one's place of N is 0, 1, 6 or 8;
* `bon` when the digit in the one's place of N is 3.
Given N, print the pronunciation of "本" in the phrase "N 本".
Constraints
* N is a positive integer not exceeding 999.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
16
Output
pon
Input
2
Output
hon
Input
183
Output
bon
"Correct Solution:
```
N = int(input()) % 10
a = ["pon","pon","hon","bon","hon","hon","pon","hon","pon","hon"]
print(a[N])
```
| 99,262 |
Provide a correct Python 3 solution for this coding contest problem.
The cat Snuke wants to play a popular Japanese game called ÅtCoder, so Iroha has decided to teach him Japanese.
When counting pencils in Japanese, the counter word "本" follows the number. The pronunciation of this word varies depending on the number. Specifically, the pronunciation of "本" in the phrase "N 本" for a positive integer N not exceeding 999 is as follows:
* `hon` when the digit in the one's place of N is 2, 4, 5, 7, or 9;
* `pon` when the digit in the one's place of N is 0, 1, 6 or 8;
* `bon` when the digit in the one's place of N is 3.
Given N, print the pronunciation of "本" in the phrase "N 本".
Constraints
* N is a positive integer not exceeding 999.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
16
Output
pon
Input
2
Output
hon
Input
183
Output
bon
"Correct Solution:
```
n = input()
nl = n[-1]
if nl in "24579":
print("hon")
elif nl in "0168":
print("pon")
else:
print("bon")
```
| 99,263 |
Provide a correct Python 3 solution for this coding contest problem.
The cat Snuke wants to play a popular Japanese game called ÅtCoder, so Iroha has decided to teach him Japanese.
When counting pencils in Japanese, the counter word "本" follows the number. The pronunciation of this word varies depending on the number. Specifically, the pronunciation of "本" in the phrase "N 本" for a positive integer N not exceeding 999 is as follows:
* `hon` when the digit in the one's place of N is 2, 4, 5, 7, or 9;
* `pon` when the digit in the one's place of N is 0, 1, 6 or 8;
* `bon` when the digit in the one's place of N is 3.
Given N, print the pronunciation of "本" in the phrase "N 本".
Constraints
* N is a positive integer not exceeding 999.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
16
Output
pon
Input
2
Output
hon
Input
183
Output
bon
"Correct Solution:
```
a = input()[-1]
if a in "24579":
print("hon")
elif a in "0168":
print("pon")
else:
print("bon")
```
| 99,264 |
Provide a correct Python 3 solution for this coding contest problem.
The cat Snuke wants to play a popular Japanese game called ÅtCoder, so Iroha has decided to teach him Japanese.
When counting pencils in Japanese, the counter word "本" follows the number. The pronunciation of this word varies depending on the number. Specifically, the pronunciation of "本" in the phrase "N 本" for a positive integer N not exceeding 999 is as follows:
* `hon` when the digit in the one's place of N is 2, 4, 5, 7, or 9;
* `pon` when the digit in the one's place of N is 0, 1, 6 or 8;
* `bon` when the digit in the one's place of N is 3.
Given N, print the pronunciation of "本" in the phrase "N 本".
Constraints
* N is a positive integer not exceeding 999.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
16
Output
pon
Input
2
Output
hon
Input
183
Output
bon
"Correct Solution:
```
N = input()
if N[-1] == '3':
print('bon')
elif N[-1] in '0168':
print('pon')
else:
print('hon')
```
| 99,265 |
Provide a correct Python 3 solution for this coding contest problem.
The cat Snuke wants to play a popular Japanese game called ÅtCoder, so Iroha has decided to teach him Japanese.
When counting pencils in Japanese, the counter word "本" follows the number. The pronunciation of this word varies depending on the number. Specifically, the pronunciation of "本" in the phrase "N 本" for a positive integer N not exceeding 999 is as follows:
* `hon` when the digit in the one's place of N is 2, 4, 5, 7, or 9;
* `pon` when the digit in the one's place of N is 0, 1, 6 or 8;
* `bon` when the digit in the one's place of N is 3.
Given N, print the pronunciation of "本" in the phrase "N 本".
Constraints
* N is a positive integer not exceeding 999.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
16
Output
pon
Input
2
Output
hon
Input
183
Output
bon
"Correct Solution:
```
N=int(input())
if N%10==3:
print("bon")
elif N%10 in [0,1,6,8]:
print("pon")
else:
print("hon")
```
| 99,266 |
Provide a correct Python 3 solution for this coding contest problem.
The cat Snuke wants to play a popular Japanese game called ÅtCoder, so Iroha has decided to teach him Japanese.
When counting pencils in Japanese, the counter word "本" follows the number. The pronunciation of this word varies depending on the number. Specifically, the pronunciation of "本" in the phrase "N 本" for a positive integer N not exceeding 999 is as follows:
* `hon` when the digit in the one's place of N is 2, 4, 5, 7, or 9;
* `pon` when the digit in the one's place of N is 0, 1, 6 or 8;
* `bon` when the digit in the one's place of N is 3.
Given N, print the pronunciation of "本" in the phrase "N 本".
Constraints
* N is a positive integer not exceeding 999.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
16
Output
pon
Input
2
Output
hon
Input
183
Output
bon
"Correct Solution:
```
n=int(input())
x=["pon","pon","hon","bon","hon","hon","pon","hon","pon","hon"]
print(x[n%10])
```
| 99,267 |
Provide a correct Python 3 solution for this coding contest problem.
The cat Snuke wants to play a popular Japanese game called ÅtCoder, so Iroha has decided to teach him Japanese.
When counting pencils in Japanese, the counter word "本" follows the number. The pronunciation of this word varies depending on the number. Specifically, the pronunciation of "本" in the phrase "N 本" for a positive integer N not exceeding 999 is as follows:
* `hon` when the digit in the one's place of N is 2, 4, 5, 7, or 9;
* `pon` when the digit in the one's place of N is 0, 1, 6 or 8;
* `bon` when the digit in the one's place of N is 3.
Given N, print the pronunciation of "本" in the phrase "N 本".
Constraints
* N is a positive integer not exceeding 999.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
16
Output
pon
Input
2
Output
hon
Input
183
Output
bon
"Correct Solution:
```
s =int(list(input())[-1])
if s in [2,4,5,7,9]:print('hon')
elif s in [0,1,6,8]:print('pon')
else:print('bon')
```
| 99,268 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The cat Snuke wants to play a popular Japanese game called ÅtCoder, so Iroha has decided to teach him Japanese.
When counting pencils in Japanese, the counter word "本" follows the number. The pronunciation of this word varies depending on the number. Specifically, the pronunciation of "本" in the phrase "N 本" for a positive integer N not exceeding 999 is as follows:
* `hon` when the digit in the one's place of N is 2, 4, 5, 7, or 9;
* `pon` when the digit in the one's place of N is 0, 1, 6 or 8;
* `bon` when the digit in the one's place of N is 3.
Given N, print the pronunciation of "本" in the phrase "N 本".
Constraints
* N is a positive integer not exceeding 999.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
16
Output
pon
Input
2
Output
hon
Input
183
Output
bon
Submitted Solution:
```
N=input()
x=N[-1]
print('bon' if x=='3' else 'pon' if x in '0168' else 'hon')
```
Yes
| 99,269 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The cat Snuke wants to play a popular Japanese game called ÅtCoder, so Iroha has decided to teach him Japanese.
When counting pencils in Japanese, the counter word "本" follows the number. The pronunciation of this word varies depending on the number. Specifically, the pronunciation of "本" in the phrase "N 本" for a positive integer N not exceeding 999 is as follows:
* `hon` when the digit in the one's place of N is 2, 4, 5, 7, or 9;
* `pon` when the digit in the one's place of N is 0, 1, 6 or 8;
* `bon` when the digit in the one's place of N is 3.
Given N, print the pronunciation of "本" in the phrase "N 本".
Constraints
* N is a positive integer not exceeding 999.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
16
Output
pon
Input
2
Output
hon
Input
183
Output
bon
Submitted Solution:
```
n = input()
print('bon' if n[-1]=='3' else 'pon' if n[-1] in ['0','1','6','8'] else 'hon')
```
Yes
| 99,270 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The cat Snuke wants to play a popular Japanese game called ÅtCoder, so Iroha has decided to teach him Japanese.
When counting pencils in Japanese, the counter word "本" follows the number. The pronunciation of this word varies depending on the number. Specifically, the pronunciation of "本" in the phrase "N 本" for a positive integer N not exceeding 999 is as follows:
* `hon` when the digit in the one's place of N is 2, 4, 5, 7, or 9;
* `pon` when the digit in the one's place of N is 0, 1, 6 or 8;
* `bon` when the digit in the one's place of N is 3.
Given N, print the pronunciation of "本" in the phrase "N 本".
Constraints
* N is a positive integer not exceeding 999.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
16
Output
pon
Input
2
Output
hon
Input
183
Output
bon
Submitted Solution:
```
n = int(input()[-1])
print(['pon', 'pon', 'hon', 'bon', 'hon', 'hon', 'pon', 'hon', 'pon', 'hon'][n])
```
Yes
| 99,271 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The cat Snuke wants to play a popular Japanese game called ÅtCoder, so Iroha has decided to teach him Japanese.
When counting pencils in Japanese, the counter word "本" follows the number. The pronunciation of this word varies depending on the number. Specifically, the pronunciation of "本" in the phrase "N 本" for a positive integer N not exceeding 999 is as follows:
* `hon` when the digit in the one's place of N is 2, 4, 5, 7, or 9;
* `pon` when the digit in the one's place of N is 0, 1, 6 or 8;
* `bon` when the digit in the one's place of N is 3.
Given N, print the pronunciation of "本" in the phrase "N 本".
Constraints
* N is a positive integer not exceeding 999.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
16
Output
pon
Input
2
Output
hon
Input
183
Output
bon
Submitted Solution:
```
N = input()
print("hon" if N[-1] in "24579" else "pon" if N[-1] in "0168" else "bon")
```
Yes
| 99,272 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The cat Snuke wants to play a popular Japanese game called ÅtCoder, so Iroha has decided to teach him Japanese.
When counting pencils in Japanese, the counter word "本" follows the number. The pronunciation of this word varies depending on the number. Specifically, the pronunciation of "本" in the phrase "N 本" for a positive integer N not exceeding 999 is as follows:
* `hon` when the digit in the one's place of N is 2, 4, 5, 7, or 9;
* `pon` when the digit in the one's place of N is 0, 1, 6 or 8;
* `bon` when the digit in the one's place of N is 3.
Given N, print the pronunciation of "本" in the phrase "N 本".
Constraints
* N is a positive integer not exceeding 999.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
16
Output
pon
Input
2
Output
hon
Input
183
Output
bon
Submitted Solution:
```
a=input()
b=a[-1]
if b=="2" or "4" or "5" or "7" or "9":
print("hon")
elif b=="0" or b=="1" or b=="6" or b=="8":
print("pon")
else:
print("bon")
```
No
| 99,273 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The cat Snuke wants to play a popular Japanese game called ÅtCoder, so Iroha has decided to teach him Japanese.
When counting pencils in Japanese, the counter word "本" follows the number. The pronunciation of this word varies depending on the number. Specifically, the pronunciation of "本" in the phrase "N 本" for a positive integer N not exceeding 999 is as follows:
* `hon` when the digit in the one's place of N is 2, 4, 5, 7, or 9;
* `pon` when the digit in the one's place of N is 0, 1, 6 or 8;
* `bon` when the digit in the one's place of N is 3.
Given N, print the pronunciation of "本" in the phrase "N 本".
Constraints
* N is a positive integer not exceeding 999.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
16
Output
pon
Input
2
Output
hon
Input
183
Output
bon
Submitted Solution:
```
N = str(input())
num = N[-1]
if num == 3:
print('bon')
elif num == 0 or num == 1 or num == 6 or num == 8:
print('pon')
else:
print('hon')
```
No
| 99,274 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The cat Snuke wants to play a popular Japanese game called ÅtCoder, so Iroha has decided to teach him Japanese.
When counting pencils in Japanese, the counter word "本" follows the number. The pronunciation of this word varies depending on the number. Specifically, the pronunciation of "本" in the phrase "N 本" for a positive integer N not exceeding 999 is as follows:
* `hon` when the digit in the one's place of N is 2, 4, 5, 7, or 9;
* `pon` when the digit in the one's place of N is 0, 1, 6 or 8;
* `bon` when the digit in the one's place of N is 3.
Given N, print the pronunciation of "本" in the phrase "N 本".
Constraints
* N is a positive integer not exceeding 999.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
16
Output
pon
Input
2
Output
hon
Input
183
Output
bon
Submitted Solution:
```
print(123)
```
No
| 99,275 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The cat Snuke wants to play a popular Japanese game called ÅtCoder, so Iroha has decided to teach him Japanese.
When counting pencils in Japanese, the counter word "本" follows the number. The pronunciation of this word varies depending on the number. Specifically, the pronunciation of "本" in the phrase "N 本" for a positive integer N not exceeding 999 is as follows:
* `hon` when the digit in the one's place of N is 2, 4, 5, 7, or 9;
* `pon` when the digit in the one's place of N is 0, 1, 6 or 8;
* `bon` when the digit in the one's place of N is 3.
Given N, print the pronunciation of "本" in the phrase "N 本".
Constraints
* N is a positive integer not exceeding 999.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
16
Output
pon
Input
2
Output
hon
Input
183
Output
bon
Submitted Solution:
```
n = input()
if n[-1]=[2,4,5,7,9]
print(n'hon')
elif n[-1]=[0,1,6,8]
print(n'pon')
elif n[-1]=[3]
print(n'bon')
```
No
| 99,276 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has a maze, which is a grid of H \times W squares with H horizontal rows and W vertical columns.
The square at the i-th row from the top and the j-th column is a "wall" square if S_{ij} is `#`, and a "road" square if S_{ij} is `.`.
From a road square, you can move to a horizontally or vertically adjacent road square.
You cannot move out of the maze, move to a wall square, or move diagonally.
Takahashi will choose a starting square and a goal square, which can be any road squares, and give the maze to Aoki.
Aoki will then travel from the starting square to the goal square, in the minimum number of moves required.
In this situation, find the maximum possible number of moves Aoki has to make.
Constraints
* 1 \leq H,W \leq 20
* S_{ij} is `.` or `#`.
* S contains at least two occurrences of `.`.
* Any road square can be reached from any road square in zero or more moves.
Input
Input is given from Standard Input in the following format:
H W
S_{11}...S_{1W}
:
S_{H1}...S_{HW}
Output
Print the maximum possible number of moves Aoki has to make.
Examples
Input
3 3
...
...
...
Output
4
Input
3 5
...#.
.#.#.
.#...
Output
10
"Correct Solution:
```
h,w=map(int,input().split())
g=[[*input()] for _ in range(h)]
from collections import *
a=0
for sx in range(h):
for sy in range(w):
if g[sx][sy]=='#': continue
d=[[-1]*w for _ in range(h)]
d[sx][sy]=0
q=deque([(sx,sy)])
while q:
x,y=q.popleft()
t=d[x][y]+1
for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:
nx,ny=x+dx,y+dy
if 0<=nx<h and 0<=ny<w and g[nx][ny]=='.' and d[nx][ny]<0:
d[nx][ny]=t
q.append((nx,ny))
a=max(a,t)
print(a)
```
| 99,277 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has a maze, which is a grid of H \times W squares with H horizontal rows and W vertical columns.
The square at the i-th row from the top and the j-th column is a "wall" square if S_{ij} is `#`, and a "road" square if S_{ij} is `.`.
From a road square, you can move to a horizontally or vertically adjacent road square.
You cannot move out of the maze, move to a wall square, or move diagonally.
Takahashi will choose a starting square and a goal square, which can be any road squares, and give the maze to Aoki.
Aoki will then travel from the starting square to the goal square, in the minimum number of moves required.
In this situation, find the maximum possible number of moves Aoki has to make.
Constraints
* 1 \leq H,W \leq 20
* S_{ij} is `.` or `#`.
* S contains at least two occurrences of `.`.
* Any road square can be reached from any road square in zero or more moves.
Input
Input is given from Standard Input in the following format:
H W
S_{11}...S_{1W}
:
S_{H1}...S_{HW}
Output
Print the maximum possible number of moves Aoki has to make.
Examples
Input
3 3
...
...
...
Output
4
Input
3 5
...#.
.#.#.
.#...
Output
10
"Correct Solution:
```
from collections import deque
h,w=map(int,input().split())
S=[input() for _ in range(h)]
ans=0
inf=float("inf")
for i in range(h):
for j in range(w):
if S[i][j]!="#":
dp=[[inf for _ in range(w)]for _ in range(h)]
dp[i][j]=0
que=deque([(i,j)])
while que:
si,sj=que.popleft()
for ni,nj in [(si+1,sj),(si-1,sj),(si,sj+1),(si,sj-1)]:
if 0<=ni<h and 0<=nj<w and S[ni][nj]!="#":
if dp[ni][nj]>dp[si][sj]+1:
dp[ni][nj]=dp[si][sj]+1
ans=max(ans,dp[si][sj]+1)
que.append((ni,nj))
print(ans)
```
| 99,278 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has a maze, which is a grid of H \times W squares with H horizontal rows and W vertical columns.
The square at the i-th row from the top and the j-th column is a "wall" square if S_{ij} is `#`, and a "road" square if S_{ij} is `.`.
From a road square, you can move to a horizontally or vertically adjacent road square.
You cannot move out of the maze, move to a wall square, or move diagonally.
Takahashi will choose a starting square and a goal square, which can be any road squares, and give the maze to Aoki.
Aoki will then travel from the starting square to the goal square, in the minimum number of moves required.
In this situation, find the maximum possible number of moves Aoki has to make.
Constraints
* 1 \leq H,W \leq 20
* S_{ij} is `.` or `#`.
* S contains at least two occurrences of `.`.
* Any road square can be reached from any road square in zero or more moves.
Input
Input is given from Standard Input in the following format:
H W
S_{11}...S_{1W}
:
S_{H1}...S_{HW}
Output
Print the maximum possible number of moves Aoki has to make.
Examples
Input
3 3
...
...
...
Output
4
Input
3 5
...#.
.#.#.
.#...
Output
10
"Correct Solution:
```
# D - Maze Master
from collections import deque
def bfs(start: int):
queue = deque([start])
dist = {start: 0}
while queue:
x = queue.popleft()
for nx in (x + 1, x - 1, x + W, x - W):
if maze[nx] == "." and nx not in dist:
dist[nx] = dist[x] + 1
queue.append(nx)
return max(dist.values())
def main():
global W, maze
H, W = map(int, input().split())
H, W = H + 2, W + 2
maze = "#" * W
for _ in range(H - 2):
maze += "#" + input().rstrip() + "#"
maze += "#" * W
ans = max(bfs(i) for i, x in enumerate(maze) if x == ".")
print(ans)
if __name__ == "__main__":
main()
```
| 99,279 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has a maze, which is a grid of H \times W squares with H horizontal rows and W vertical columns.
The square at the i-th row from the top and the j-th column is a "wall" square if S_{ij} is `#`, and a "road" square if S_{ij} is `.`.
From a road square, you can move to a horizontally or vertically adjacent road square.
You cannot move out of the maze, move to a wall square, or move diagonally.
Takahashi will choose a starting square and a goal square, which can be any road squares, and give the maze to Aoki.
Aoki will then travel from the starting square to the goal square, in the minimum number of moves required.
In this situation, find the maximum possible number of moves Aoki has to make.
Constraints
* 1 \leq H,W \leq 20
* S_{ij} is `.` or `#`.
* S contains at least two occurrences of `.`.
* Any road square can be reached from any road square in zero or more moves.
Input
Input is given from Standard Input in the following format:
H W
S_{11}...S_{1W}
:
S_{H1}...S_{HW}
Output
Print the maximum possible number of moves Aoki has to make.
Examples
Input
3 3
...
...
...
Output
4
Input
3 5
...#.
.#.#.
.#...
Output
10
"Correct Solution:
```
from collections import deque
h, w = map(int, input().split())
a = ''.join(input() + '#' for _ in range(h))
n = len(a)
b = ['#'] * w
r = 0
for i in range(n):
if a[i] == '.':
b[:-w] = a
b[i] = 0
q = deque([i])
while(q):
i = q.popleft()
r = max(r, b[i])
for j in (i - 1, i + 1, i - w - 1, i + w + 1):
if b[j] == '.':
b[j] = b[i] + 1
q.append(j)
print(r)
```
| 99,280 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has a maze, which is a grid of H \times W squares with H horizontal rows and W vertical columns.
The square at the i-th row from the top and the j-th column is a "wall" square if S_{ij} is `#`, and a "road" square if S_{ij} is `.`.
From a road square, you can move to a horizontally or vertically adjacent road square.
You cannot move out of the maze, move to a wall square, or move diagonally.
Takahashi will choose a starting square and a goal square, which can be any road squares, and give the maze to Aoki.
Aoki will then travel from the starting square to the goal square, in the minimum number of moves required.
In this situation, find the maximum possible number of moves Aoki has to make.
Constraints
* 1 \leq H,W \leq 20
* S_{ij} is `.` or `#`.
* S contains at least two occurrences of `.`.
* Any road square can be reached from any road square in zero or more moves.
Input
Input is given from Standard Input in the following format:
H W
S_{11}...S_{1W}
:
S_{H1}...S_{HW}
Output
Print the maximum possible number of moves Aoki has to make.
Examples
Input
3 3
...
...
...
Output
4
Input
3 5
...#.
.#.#.
.#...
Output
10
"Correct Solution:
```
H,W = map(int,input().split())
S = [None]*W
S = [list(input()) for i in range(H)]
dx = [1,-1,0,0]
dy = [0,0,1,-1]
def max_distance(i,j):
not_visit = [[-1]*W for i in range(H)]
not_visit[i][j] = 0
stack = [(i,j)]
while stack != []:
y,x = stack.pop(0)
for i in range(4):
if 0<= x+dx[i] <W and 0<= y+dy[i] <H and S[y+dy[i]][x+dx[i]] != "#" and not_visit[y+dy[i]][x+dx[i]] == -1:
not_visit[y+dy[i]][x+dx[i]] = not_visit[y][x] + 1
stack.append((y+dy[i],x+dx[i]))
return not_visit[y][x]
ans = 0
for i in range(H):
for j in range(W):
if S[i][j] != "#":
ans = max(ans,max_distance(i,j))
print(ans)
```
| 99,281 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has a maze, which is a grid of H \times W squares with H horizontal rows and W vertical columns.
The square at the i-th row from the top and the j-th column is a "wall" square if S_{ij} is `#`, and a "road" square if S_{ij} is `.`.
From a road square, you can move to a horizontally or vertically adjacent road square.
You cannot move out of the maze, move to a wall square, or move diagonally.
Takahashi will choose a starting square and a goal square, which can be any road squares, and give the maze to Aoki.
Aoki will then travel from the starting square to the goal square, in the minimum number of moves required.
In this situation, find the maximum possible number of moves Aoki has to make.
Constraints
* 1 \leq H,W \leq 20
* S_{ij} is `.` or `#`.
* S contains at least two occurrences of `.`.
* Any road square can be reached from any road square in zero or more moves.
Input
Input is given from Standard Input in the following format:
H W
S_{11}...S_{1W}
:
S_{H1}...S_{HW}
Output
Print the maximum possible number of moves Aoki has to make.
Examples
Input
3 3
...
...
...
Output
4
Input
3 5
...#.
.#.#.
.#...
Output
10
"Correct Solution:
```
h, w = map(int, input().split())
s = [input() for _ in range(h)]
def bfs(x, y):
q = []
dp = {}
def qpush(x, y, t):
if 0 <= x < w and 0 <= y < h and s[y][x] != '#' and (x, y) not in dp:
q.append((x, y))
dp[(x, y)] = t
qpush(x, y, 0)
while len(q) > 0:
(x, y) = q.pop(0)
qpush(x + 1, y, dp[(x, y)] + 1)
qpush(x, y - 1, dp[(x, y)] + 1)
qpush(x - 1, y, dp[(x, y)] + 1)
qpush(x, y + 1, dp[(x, y)] + 1)
return dp.get((x, y), 0)
t = 0
for y in range(h):
for x in range(w):
t = max(t, bfs(x, y))
print(t)
```
| 99,282 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has a maze, which is a grid of H \times W squares with H horizontal rows and W vertical columns.
The square at the i-th row from the top and the j-th column is a "wall" square if S_{ij} is `#`, and a "road" square if S_{ij} is `.`.
From a road square, you can move to a horizontally or vertically adjacent road square.
You cannot move out of the maze, move to a wall square, or move diagonally.
Takahashi will choose a starting square and a goal square, which can be any road squares, and give the maze to Aoki.
Aoki will then travel from the starting square to the goal square, in the minimum number of moves required.
In this situation, find the maximum possible number of moves Aoki has to make.
Constraints
* 1 \leq H,W \leq 20
* S_{ij} is `.` or `#`.
* S contains at least two occurrences of `.`.
* Any road square can be reached from any road square in zero or more moves.
Input
Input is given from Standard Input in the following format:
H W
S_{11}...S_{1W}
:
S_{H1}...S_{HW}
Output
Print the maximum possible number of moves Aoki has to make.
Examples
Input
3 3
...
...
...
Output
4
Input
3 5
...#.
.#.#.
.#...
Output
10
"Correct Solution:
```
from collections import deque
h,w = map(int,input().split())
s = [input() for _ in range(h)]
ans=0
for i in range(h):
for j in range(w):
if s[i][j] =='#':
continue
visited=[[-1]*w for _ in range(h)]
visited[i][j] = 0
cnt=0
q = deque([[i,j]])
while q:
x,y = q.popleft()
for k,l in [[0,-1],[0,1],[1,0],[-1,0]]:
nx,ny = k+x,l+y
if nx<0 or ny<0 or nx>=h or ny>=w:
continue
if s[nx][ny]=='.' and visited[nx][ny]==-1:
visited[nx][ny] = visited[x][y] + 1
q.append([nx,ny])
ans = max(ans,visited[nx][ny])
print(ans)
```
| 99,283 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has a maze, which is a grid of H \times W squares with H horizontal rows and W vertical columns.
The square at the i-th row from the top and the j-th column is a "wall" square if S_{ij} is `#`, and a "road" square if S_{ij} is `.`.
From a road square, you can move to a horizontally or vertically adjacent road square.
You cannot move out of the maze, move to a wall square, or move diagonally.
Takahashi will choose a starting square and a goal square, which can be any road squares, and give the maze to Aoki.
Aoki will then travel from the starting square to the goal square, in the minimum number of moves required.
In this situation, find the maximum possible number of moves Aoki has to make.
Constraints
* 1 \leq H,W \leq 20
* S_{ij} is `.` or `#`.
* S contains at least two occurrences of `.`.
* Any road square can be reached from any road square in zero or more moves.
Input
Input is given from Standard Input in the following format:
H W
S_{11}...S_{1W}
:
S_{H1}...S_{HW}
Output
Print the maximum possible number of moves Aoki has to make.
Examples
Input
3 3
...
...
...
Output
4
Input
3 5
...#.
.#.#.
.#...
Output
10
"Correct Solution:
```
from collections import deque
d = [(-1,0),(1,0),(0,1),(0,-1)]
def bfs(y,x,c):
q = deque()
q.append((y,x,c))
ma = 0
visit[y][x] = 1
while q:
y,x,c = q.popleft()
ma = max(ma,c)
for dy,dx in d:
if 0<=y+dy<h and 0<=x+dx<w:
if area[y+dy][x+dx] =="." and visit[y+dy][x+dx] == 0:
q.append((y+dy,x+dx,c+1))
visit[y+dy][x+dx] = 1
return ma
h,w = map(int,input().split())
area = []
for i in range(h):
area.append(list(input()))
ans = 0
for i in range(h):
for j in range(w):
if area[i][j] ==".":
visit = [[0]*w for i in range(h)]
ans = max(ans,bfs(i,j,0))
print(ans)
```
| 99,284 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has a maze, which is a grid of H \times W squares with H horizontal rows and W vertical columns.
The square at the i-th row from the top and the j-th column is a "wall" square if S_{ij} is `#`, and a "road" square if S_{ij} is `.`.
From a road square, you can move to a horizontally or vertically adjacent road square.
You cannot move out of the maze, move to a wall square, or move diagonally.
Takahashi will choose a starting square and a goal square, which can be any road squares, and give the maze to Aoki.
Aoki will then travel from the starting square to the goal square, in the minimum number of moves required.
In this situation, find the maximum possible number of moves Aoki has to make.
Constraints
* 1 \leq H,W \leq 20
* S_{ij} is `.` or `#`.
* S contains at least two occurrences of `.`.
* Any road square can be reached from any road square in zero or more moves.
Input
Input is given from Standard Input in the following format:
H W
S_{11}...S_{1W}
:
S_{H1}...S_{HW}
Output
Print the maximum possible number of moves Aoki has to make.
Examples
Input
3 3
...
...
...
Output
4
Input
3 5
...#.
.#.#.
.#...
Output
10
Submitted Solution:
```
from collections import deque
h,w = map(int,input().split())
G = [input() for i in range(h)]
directions = [(1,0),(0,1),(-1,0),(0,-1)]
ans = 0
for sx in range(w):
for sy in range(h):
if G[sy][sx] == "#":
continue
dist = [[-1] * w for i in range(h)]
dist[sy][sx] = 0
que = deque([[sy, sx]])
while len(que):
y,x = que.popleft()
for dx,dy in directions:
nx = x + dx
ny = y+ dy
if not (0<=nx<w and 0<=ny<h) or G[ny][nx]=="#":
continue
if dist[ny][nx] != -1:
continue
dist[ny][nx] = dist[y][x] +1
que.append([ny,nx])
ans = max(ans, max([max(d) for d in dist]))
print(ans)
```
Yes
| 99,285 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has a maze, which is a grid of H \times W squares with H horizontal rows and W vertical columns.
The square at the i-th row from the top and the j-th column is a "wall" square if S_{ij} is `#`, and a "road" square if S_{ij} is `.`.
From a road square, you can move to a horizontally or vertically adjacent road square.
You cannot move out of the maze, move to a wall square, or move diagonally.
Takahashi will choose a starting square and a goal square, which can be any road squares, and give the maze to Aoki.
Aoki will then travel from the starting square to the goal square, in the minimum number of moves required.
In this situation, find the maximum possible number of moves Aoki has to make.
Constraints
* 1 \leq H,W \leq 20
* S_{ij} is `.` or `#`.
* S contains at least two occurrences of `.`.
* Any road square can be reached from any road square in zero or more moves.
Input
Input is given from Standard Input in the following format:
H W
S_{11}...S_{1W}
:
S_{H1}...S_{HW}
Output
Print the maximum possible number of moves Aoki has to make.
Examples
Input
3 3
...
...
...
Output
4
Input
3 5
...#.
.#.#.
.#...
Output
10
Submitted Solution:
```
from collections import deque
import copy
H,W = map(int,input().split())
S = [list(input()) for _ in range(H)]
def bfs(x,y):
check = copy.deepcopy(S)
que = deque()
que.append((x,y))
check[y][x] = 0
while que.__len__() != 0:
x,y = que.popleft()
tmp = check[y][x]
for dx,dy in (1,0),(-1,0),(0,1),(0,-1):
sx = x + dx
sy = y + dy
if -1 < sx < W and -1 < sy < H:
if check[sy][sx] == '.':
check[sy][sx] = tmp + 1
que.append((sx,sy))
return tmp
ans = 0
for x in range(W):
for y in range(H):
if S[y][x] == '.':
ans = max(bfs(x,y),ans)
print(ans)
```
Yes
| 99,286 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has a maze, which is a grid of H \times W squares with H horizontal rows and W vertical columns.
The square at the i-th row from the top and the j-th column is a "wall" square if S_{ij} is `#`, and a "road" square if S_{ij} is `.`.
From a road square, you can move to a horizontally or vertically adjacent road square.
You cannot move out of the maze, move to a wall square, or move diagonally.
Takahashi will choose a starting square and a goal square, which can be any road squares, and give the maze to Aoki.
Aoki will then travel from the starting square to the goal square, in the minimum number of moves required.
In this situation, find the maximum possible number of moves Aoki has to make.
Constraints
* 1 \leq H,W \leq 20
* S_{ij} is `.` or `#`.
* S contains at least two occurrences of `.`.
* Any road square can be reached from any road square in zero or more moves.
Input
Input is given from Standard Input in the following format:
H W
S_{11}...S_{1W}
:
S_{H1}...S_{HW}
Output
Print the maximum possible number of moves Aoki has to make.
Examples
Input
3 3
...
...
...
Output
4
Input
3 5
...#.
.#.#.
.#...
Output
10
Submitted Solution:
```
from collections import deque
h, w = map(int, input().split())
a = ''.join(input() + '#' for _ in range(h))
n = len(a) - 1
b = ['#'] * w
r = 0
for i in range(n):
if a[i] == '.':
b[:-w] = a
b[i] = 0
q = deque([i])
while(q):
i = q.popleft()
r = max(r, b[i])
for j in (i - 1, i + 1, i - w - 1, i + w + 1):
if b[j] == '.':
b[j] = b[i] + 1
q.append(j)
print(r)
```
Yes
| 99,287 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has a maze, which is a grid of H \times W squares with H horizontal rows and W vertical columns.
The square at the i-th row from the top and the j-th column is a "wall" square if S_{ij} is `#`, and a "road" square if S_{ij} is `.`.
From a road square, you can move to a horizontally or vertically adjacent road square.
You cannot move out of the maze, move to a wall square, or move diagonally.
Takahashi will choose a starting square and a goal square, which can be any road squares, and give the maze to Aoki.
Aoki will then travel from the starting square to the goal square, in the minimum number of moves required.
In this situation, find the maximum possible number of moves Aoki has to make.
Constraints
* 1 \leq H,W \leq 20
* S_{ij} is `.` or `#`.
* S contains at least two occurrences of `.`.
* Any road square can be reached from any road square in zero or more moves.
Input
Input is given from Standard Input in the following format:
H W
S_{11}...S_{1W}
:
S_{H1}...S_{HW}
Output
Print the maximum possible number of moves Aoki has to make.
Examples
Input
3 3
...
...
...
Output
4
Input
3 5
...#.
.#.#.
.#...
Output
10
Submitted Solution:
```
from itertools import count, combinations, product
H,W = map(int,input().split())
H += 2
W += 2
visited = [2**31]*(W*H)
for i in range(1,H-1):
S = input()
for j,v in zip(range(1,W-1),S):
if v == '.':
visited[i*W + j] = 0
res = 1
D = (W,-W,1,-1)
for i in range(W*H):
if visited[i] == 2**31:
continue
q = [i]
visited[i] = i
for dist in count():
if not q:
break
nq = []
for j in q:
for d in D:
if visited[j+d] < i:
visited[j+d] = i
nq.append(j+d)
q = nq
res = max(dist, res)
print(res-1)
```
Yes
| 99,288 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has a maze, which is a grid of H \times W squares with H horizontal rows and W vertical columns.
The square at the i-th row from the top and the j-th column is a "wall" square if S_{ij} is `#`, and a "road" square if S_{ij} is `.`.
From a road square, you can move to a horizontally or vertically adjacent road square.
You cannot move out of the maze, move to a wall square, or move diagonally.
Takahashi will choose a starting square and a goal square, which can be any road squares, and give the maze to Aoki.
Aoki will then travel from the starting square to the goal square, in the minimum number of moves required.
In this situation, find the maximum possible number of moves Aoki has to make.
Constraints
* 1 \leq H,W \leq 20
* S_{ij} is `.` or `#`.
* S contains at least two occurrences of `.`.
* Any road square can be reached from any road square in zero or more moves.
Input
Input is given from Standard Input in the following format:
H W
S_{11}...S_{1W}
:
S_{H1}...S_{HW}
Output
Print the maximum possible number of moves Aoki has to make.
Examples
Input
3 3
...
...
...
Output
4
Input
3 5
...#.
.#.#.
.#...
Output
10
Submitted Solution:
```
from collections import deque
H,W=map(int,input().split())
S=[input() for _ in range(H)]
ans=0
d=deque([])
for i in range(H):
for j in range(W):
d.append((i,j,0))
visited=[[-1]*W for _ in range(H)]
visited[i][j]=0
while d:
x,y,c=d.popleft()
for dx,dy in [(0,1),(1,0),(0,-1),(-1,0)]:
nx,ny=x+dx,y+dy
if 0<=nx<H and 0<=ny<W and visited[nx][ny]==-1 and S[nx][ny]=='.':
visited[nx][ny]=c+1
d.append((nx,ny,c+1))
ans=max(ans,c)
print(ans)
```
No
| 99,289 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has a maze, which is a grid of H \times W squares with H horizontal rows and W vertical columns.
The square at the i-th row from the top and the j-th column is a "wall" square if S_{ij} is `#`, and a "road" square if S_{ij} is `.`.
From a road square, you can move to a horizontally or vertically adjacent road square.
You cannot move out of the maze, move to a wall square, or move diagonally.
Takahashi will choose a starting square and a goal square, which can be any road squares, and give the maze to Aoki.
Aoki will then travel from the starting square to the goal square, in the minimum number of moves required.
In this situation, find the maximum possible number of moves Aoki has to make.
Constraints
* 1 \leq H,W \leq 20
* S_{ij} is `.` or `#`.
* S contains at least two occurrences of `.`.
* Any road square can be reached from any road square in zero or more moves.
Input
Input is given from Standard Input in the following format:
H W
S_{11}...S_{1W}
:
S_{H1}...S_{HW}
Output
Print the maximum possible number of moves Aoki has to make.
Examples
Input
3 3
...
...
...
Output
4
Input
3 5
...#.
.#.#.
.#...
Output
10
Submitted Solution:
```
from collections import deque
def bfs(sy,sx):
m_dis=0
mv_ok=False
move=[[1,0],[0,1],[-1,0],[0,-1]]
visited=[[-1]*yoko for i in range(tate)]
queue=deque()
queue.append([sy,sx]) #queue=deque([[sy,sx]])でもよい
visited[sy][sx]=0 #スタート地点の距離は0
while queue:
mv_ok=False
y,x=queue.popleft()
for dy,dx in move:
my,mx=y+dy,x+dx
if not(0<=my<tate) or not(0<=mx<yoko):
continue
if maze[my][mx]=="." and visited[my][mx]==-1:
queue.append([my,mx])
visited[my][mx]=visited[y][x]+1 # visitedは距離も兼ねてる
mv_ok=True
if mv_ok:
m_dis+=1
return m_dis
tate,yoko=map(int,input().split())
maze=[]
for i in range(tate):
line=list(input())
maze.append(line)
ans=0
for y in range(tate):
for x in range(yoko):
ans=max(ans,bfs(y,x))
print(ans)
```
No
| 99,290 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has a maze, which is a grid of H \times W squares with H horizontal rows and W vertical columns.
The square at the i-th row from the top and the j-th column is a "wall" square if S_{ij} is `#`, and a "road" square if S_{ij} is `.`.
From a road square, you can move to a horizontally or vertically adjacent road square.
You cannot move out of the maze, move to a wall square, or move diagonally.
Takahashi will choose a starting square and a goal square, which can be any road squares, and give the maze to Aoki.
Aoki will then travel from the starting square to the goal square, in the minimum number of moves required.
In this situation, find the maximum possible number of moves Aoki has to make.
Constraints
* 1 \leq H,W \leq 20
* S_{ij} is `.` or `#`.
* S contains at least two occurrences of `.`.
* Any road square can be reached from any road square in zero or more moves.
Input
Input is given from Standard Input in the following format:
H W
S_{11}...S_{1W}
:
S_{H1}...S_{HW}
Output
Print the maximum possible number of moves Aoki has to make.
Examples
Input
3 3
...
...
...
Output
4
Input
3 5
...#.
.#.#.
.#...
Output
10
Submitted Solution:
```
H, W = map(int, input().split())
S = [list(input()) for _ in range(H)]
graph = [[float('inf')]*H*W for _ in range(H*W)]
nv = [(-1, 0), (1, 0), (0, -1), (0, 1)]
for h in range(H):
for w in range(W):
if S[h][w]=='.':
for nx, ny in nv:
if H <= h+nx or h+nx < 0 or W <= w+ny or w+ny < 0:
continue
if S[h+nx][w+ny]=='.':
graph[W*h+w][W*(h+nx)+(w+ny)] = 1
for k in range(H*W):
for i in range(H*W):
for j in range(H*W):
graph[i][i]=0
graph[i][j] = min(graph[i][j], graph[i][k] + graph[k][j])
ans = 0
for i in range(H*W-1):
for j in range(i+1, H*W):
if graph[i][j] != float('inf'):
ans = max(ans, graph[i][j])
print(ans)
```
No
| 99,291 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has a maze, which is a grid of H \times W squares with H horizontal rows and W vertical columns.
The square at the i-th row from the top and the j-th column is a "wall" square if S_{ij} is `#`, and a "road" square if S_{ij} is `.`.
From a road square, you can move to a horizontally or vertically adjacent road square.
You cannot move out of the maze, move to a wall square, or move diagonally.
Takahashi will choose a starting square and a goal square, which can be any road squares, and give the maze to Aoki.
Aoki will then travel from the starting square to the goal square, in the minimum number of moves required.
In this situation, find the maximum possible number of moves Aoki has to make.
Constraints
* 1 \leq H,W \leq 20
* S_{ij} is `.` or `#`.
* S contains at least two occurrences of `.`.
* Any road square can be reached from any road square in zero or more moves.
Input
Input is given from Standard Input in the following format:
H W
S_{11}...S_{1W}
:
S_{H1}...S_{HW}
Output
Print the maximum possible number of moves Aoki has to make.
Examples
Input
3 3
...
...
...
Output
4
Input
3 5
...#.
.#.#.
.#...
Output
10
Submitted Solution:
```
from collections import deque
H, W = map(int, input().split())
field = ''
for i in range(H):
field += input()
def bfs(start):
dist = [0] * (H * W)
q = deque([start])
while q:
p = q.popleft()
c = dist[p] + 1
print(p)
if p % W == 0:
nex_li = [p-W, p+W, p+1]
elif p % W == W - 1:
nex_li = [p-W, p+W, p-1]
else:
nex_li = [p-W, p+W, p-1, p+1]
for nex in nex_li:
if nex != start and nex >= 0 and nex < H * W and field[nex] == '.':
dist[nex] = c
q.append(nex)
return dist[p]
ans = 0
for s in range(H * W):
if field[s] == '.':
ans = max(ans, bfs(s))
print(ans)
```
No
| 99,292 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S consisting of lowercase English letters. Find the maximum positive integer K that satisfies the following condition:
* There exists a partition of S into K non-empty strings S=S_1S_2...S_K such that S_i \neq S_{i+1} (1 \leq i \leq K-1).
Here S_1S_2...S_K represents the concatenation of S_1,S_2,...,S_K in this order.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
Output
Print the maximum positive integer K that satisfies the condition.
Examples
Input
aabbaa
Output
4
Input
aaaccacabaababc
Output
12
"Correct Solution:
```
S = input()
ans = 0
pre = ""
now = ""
for s in S:
now += s
if pre != now:
ans += 1
pre = now
now = ""
print(ans)
```
| 99,293 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S consisting of lowercase English letters. Find the maximum positive integer K that satisfies the following condition:
* There exists a partition of S into K non-empty strings S=S_1S_2...S_K such that S_i \neq S_{i+1} (1 \leq i \leq K-1).
Here S_1S_2...S_K represents the concatenation of S_1,S_2,...,S_K in this order.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
Output
Print the maximum positive integer K that satisfies the condition.
Examples
Input
aabbaa
Output
4
Input
aaaccacabaababc
Output
12
"Correct Solution:
```
S = input().strip()
k = 0
l = ""
r = ""
for s in S:
r += s
if l == r:
continue
l = r
r = ""
k += 1
print(k)
```
| 99,294 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S consisting of lowercase English letters. Find the maximum positive integer K that satisfies the following condition:
* There exists a partition of S into K non-empty strings S=S_1S_2...S_K such that S_i \neq S_{i+1} (1 \leq i \leq K-1).
Here S_1S_2...S_K represents the concatenation of S_1,S_2,...,S_K in this order.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
Output
Print the maximum positive integer K that satisfies the condition.
Examples
Input
aabbaa
Output
4
Input
aaaccacabaababc
Output
12
"Correct Solution:
```
ss = input()
tmp = ""
last = ""
res = 0
for s in ss:
tmp += s
if tmp == last:
continue
last = tmp
tmp = ""
res+=1
print(res)
```
| 99,295 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S consisting of lowercase English letters. Find the maximum positive integer K that satisfies the following condition:
* There exists a partition of S into K non-empty strings S=S_1S_2...S_K such that S_i \neq S_{i+1} (1 \leq i \leq K-1).
Here S_1S_2...S_K represents the concatenation of S_1,S_2,...,S_K in this order.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
Output
Print the maximum positive integer K that satisfies the condition.
Examples
Input
aabbaa
Output
4
Input
aaaccacabaababc
Output
12
"Correct Solution:
```
s=input()
ans=0
mae=""
now=""
for i in s:
now += i
if mae != now:
ans += 1
mae = now
now = ""
print(ans)
```
| 99,296 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S consisting of lowercase English letters. Find the maximum positive integer K that satisfies the following condition:
* There exists a partition of S into K non-empty strings S=S_1S_2...S_K such that S_i \neq S_{i+1} (1 \leq i \leq K-1).
Here S_1S_2...S_K represents the concatenation of S_1,S_2,...,S_K in this order.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
Output
Print the maximum positive integer K that satisfies the condition.
Examples
Input
aabbaa
Output
4
Input
aaaccacabaababc
Output
12
"Correct Solution:
```
S = input()
ans = 0
pre = ''
now = ''
for s in S:
now += s
if pre != now:
ans += 1
pre = now
now = ''
print(ans)
```
| 99,297 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S consisting of lowercase English letters. Find the maximum positive integer K that satisfies the following condition:
* There exists a partition of S into K non-empty strings S=S_1S_2...S_K such that S_i \neq S_{i+1} (1 \leq i \leq K-1).
Here S_1S_2...S_K represents the concatenation of S_1,S_2,...,S_K in this order.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
Output
Print the maximum positive integer K that satisfies the condition.
Examples
Input
aabbaa
Output
4
Input
aaaccacabaababc
Output
12
"Correct Solution:
```
S = str(input())
ans = 0
p = ''
q = ''
for s in S:
p += s
if p != q:
ans += 1
q = p
p = ''
print(ans)
```
| 99,298 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S consisting of lowercase English letters. Find the maximum positive integer K that satisfies the following condition:
* There exists a partition of S into K non-empty strings S=S_1S_2...S_K such that S_i \neq S_{i+1} (1 \leq i \leq K-1).
Here S_1S_2...S_K represents the concatenation of S_1,S_2,...,S_K in this order.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
Output
Print the maximum positive integer K that satisfies the condition.
Examples
Input
aabbaa
Output
4
Input
aaaccacabaababc
Output
12
"Correct Solution:
```
s = input()
prev = ""
lets = ""
ans = 0
for i in s:
lets += i
if lets != prev:
ans += 1
prev = lets
lets = ""
print(ans)
```
| 99,299 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.