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.
A simple recommendation system would recommend a user things liked by a certain number of their friends. In this problem you will implement part of such a system.
You are given user's friends' opinions about a list of items. You are also given a threshold T — the minimal number of "likes" necessary for an item to be recommended to the user.
Output the number of items in the list liked by at least T of user's friends.
Input
The first line of the input will contain three space-separated integers: the number of friends F (1 ≤ F ≤ 10), the number of items I (1 ≤ I ≤ 10) and the threshold T (1 ≤ T ≤ F).
The following F lines of input contain user's friends' opinions. j-th character of i-th line is 'Y' if i-th friend likes j-th item, and 'N' otherwise.
Output
Output an integer — the number of items liked by at least T of user's friends.
Examples
Input
3 3 2
YYY
NNN
YNY
Output
2
Input
4 4 1
NNNY
NNYN
NYNN
YNNN
Output
4
Submitted Solution:
```
s=input().split()
F, I, T = (int(s[i]) for i in range(3))
a=[""]*F
for i in range(F):
a[i]=input()
ans=0
for i in range(I):
cnt= 0
for j in range(F):
if a[j][i]=='Y':
cnt+=1
if cnt>=T:
ans+= 1
print(ans)
```
No
| 92,200 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A simple recommendation system would recommend a user things liked by a certain number of their friends. In this problem you will implement part of such a system.
You are given user's friends' opinions about a list of items. You are also given a threshold T — the minimal number of "likes" necessary for an item to be recommended to the user.
Output the number of items in the list liked by at least T of user's friends.
Input
The first line of the input will contain three space-separated integers: the number of friends F (1 ≤ F ≤ 10), the number of items I (1 ≤ I ≤ 10) and the threshold T (1 ≤ T ≤ F).
The following F lines of input contain user's friends' opinions. j-th character of i-th line is 'Y' if i-th friend likes j-th item, and 'N' otherwise.
Output
Output an integer — the number of items liked by at least T of user's friends.
Examples
Input
3 3 2
YYY
NNN
YNY
Output
2
Input
4 4 1
NNNY
NNYN
NYNN
YNNN
Output
4
Submitted Solution:
```
f,i,t = (int(i) for i in input().split())
a = [0]*i
for l in range(f):
s = input()
for m in range(i):
if s[m] =='Y':
a[m]+=1
ans = 0
for j in range(i):
if a[j] >= t:
ans+=1
print(ans)
```
No
| 92,201 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A simple recommendation system would recommend a user things liked by a certain number of their friends. In this problem you will implement part of such a system.
You are given user's friends' opinions about a list of items. You are also given a threshold T — the minimal number of "likes" necessary for an item to be recommended to the user.
Output the number of items in the list liked by at least T of user's friends.
Input
The first line of the input will contain three space-separated integers: the number of friends F (1 ≤ F ≤ 10), the number of items I (1 ≤ I ≤ 10) and the threshold T (1 ≤ T ≤ F).
The following F lines of input contain user's friends' opinions. j-th character of i-th line is 'Y' if i-th friend likes j-th item, and 'N' otherwise.
Output
Output an integer — the number of items liked by at least T of user's friends.
Examples
Input
3 3 2
YYY
NNN
YNY
Output
2
Input
4 4 1
NNNY
NNYN
NYNN
YNNN
Output
4
Submitted Solution:
```
def main():
f, i, t = map(int, input().split())
total = [0] * i
for _ in range(f):
likes = input()
for j in range(i):
if likes[j] == 'Y':
total[j] += 1
# print(total)
print(sum(1 for tot in total if tot >= t))
main()
```
No
| 92,202 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities in Bearland, numbered 1 through n. Cities are arranged in one long row. The distance between cities i and j is equal to |i - j|.
Limak is a police officer. He lives in a city a. His job is to catch criminals. It's hard because he doesn't know in which cities criminals are. Though, he knows that there is at most one criminal in each city.
Limak is going to use a BCD (Bear Criminal Detector). The BCD will tell Limak how many criminals there are for every distance from a city a. After that, Limak can catch a criminal in each city for which he is sure that there must be a criminal.
You know in which cities criminals are. Count the number of criminals Limak will catch, after he uses the BCD.
Input
The first line of the input contains two integers n and a (1 ≤ a ≤ n ≤ 100) — the number of cities and the index of city where Limak lives.
The second line contains n integers t1, t2, ..., tn (0 ≤ ti ≤ 1). There are ti criminals in the i-th city.
Output
Print the number of criminals Limak will catch.
Examples
Input
6 3
1 1 1 0 1 0
Output
3
Input
5 2
0 0 0 1 0
Output
1
Note
In the first sample, there are six cities and Limak lives in the third one (blue arrow below). Criminals are in cities marked red.
<image>
Using the BCD gives Limak the following information:
* There is one criminal at distance 0 from the third city — Limak is sure that this criminal is exactly in the third city.
* There is one criminal at distance 1 from the third city — Limak doesn't know if a criminal is in the second or fourth city.
* There are two criminals at distance 2 from the third city — Limak is sure that there is one criminal in the first city and one in the fifth city.
* There are zero criminals for every greater distance.
So, Limak will catch criminals in cities 1, 3 and 5, that is 3 criminals in total.
In the second sample (drawing below), the BCD gives Limak the information that there is one criminal at distance 2 from Limak's city. There is only one city at distance 2 so Limak is sure where a criminal is.
<image>
Tags: constructive algorithms, implementation
Correct Solution:
```
n, a = map(int, input().split())
criminals = list(map(int, input().split()))
current = a - 1
distance = 1
sum = 0
if criminals[current] == 1:
sum = 1
while current + distance < n or current - distance >= 0:
if current + distance >= n:
if criminals[current - distance] == 1:
sum += 1
elif current - distance < 0:
if criminals[current + distance] == 1:
sum += 1
else:
if criminals[current - distance] == 1 and criminals[current + distance] == 1:
sum += 2
distance += 1
print(str(sum))
```
| 92,203 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities in Bearland, numbered 1 through n. Cities are arranged in one long row. The distance between cities i and j is equal to |i - j|.
Limak is a police officer. He lives in a city a. His job is to catch criminals. It's hard because he doesn't know in which cities criminals are. Though, he knows that there is at most one criminal in each city.
Limak is going to use a BCD (Bear Criminal Detector). The BCD will tell Limak how many criminals there are for every distance from a city a. After that, Limak can catch a criminal in each city for which he is sure that there must be a criminal.
You know in which cities criminals are. Count the number of criminals Limak will catch, after he uses the BCD.
Input
The first line of the input contains two integers n and a (1 ≤ a ≤ n ≤ 100) — the number of cities and the index of city where Limak lives.
The second line contains n integers t1, t2, ..., tn (0 ≤ ti ≤ 1). There are ti criminals in the i-th city.
Output
Print the number of criminals Limak will catch.
Examples
Input
6 3
1 1 1 0 1 0
Output
3
Input
5 2
0 0 0 1 0
Output
1
Note
In the first sample, there are six cities and Limak lives in the third one (blue arrow below). Criminals are in cities marked red.
<image>
Using the BCD gives Limak the following information:
* There is one criminal at distance 0 from the third city — Limak is sure that this criminal is exactly in the third city.
* There is one criminal at distance 1 from the third city — Limak doesn't know if a criminal is in the second or fourth city.
* There are two criminals at distance 2 from the third city — Limak is sure that there is one criminal in the first city and one in the fifth city.
* There are zero criminals for every greater distance.
So, Limak will catch criminals in cities 1, 3 and 5, that is 3 criminals in total.
In the second sample (drawing below), the BCD gives Limak the information that there is one criminal at distance 2 from Limak's city. There is only one city at distance 2 so Limak is sure where a criminal is.
<image>
Tags: constructive algorithms, implementation
Correct Solution:
```
n,k=map(int,input().split())
c=list(map(int,input().split()))
tot=0
if c[k-1]==1:
tot+=1
pivot=k-1
left_pointer=k-1
right_pointer=k-1
while left_pointer>0 or right_pointer<n-1:
left_pointer-=1
right_pointer+=1
if left_pointer>=0 and right_pointer<=n-1:
if c[left_pointer]==c[right_pointer] and c[left_pointer]==1:
tot+=2
elif left_pointer<0 and right_pointer<=n-1:
if c[right_pointer]==1:
tot+=1
elif left_pointer>=0 and right_pointer>=n:
if c[left_pointer]==1:
tot+=1
else:
break
print(tot)
```
| 92,204 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities in Bearland, numbered 1 through n. Cities are arranged in one long row. The distance between cities i and j is equal to |i - j|.
Limak is a police officer. He lives in a city a. His job is to catch criminals. It's hard because he doesn't know in which cities criminals are. Though, he knows that there is at most one criminal in each city.
Limak is going to use a BCD (Bear Criminal Detector). The BCD will tell Limak how many criminals there are for every distance from a city a. After that, Limak can catch a criminal in each city for which he is sure that there must be a criminal.
You know in which cities criminals are. Count the number of criminals Limak will catch, after he uses the BCD.
Input
The first line of the input contains two integers n and a (1 ≤ a ≤ n ≤ 100) — the number of cities and the index of city where Limak lives.
The second line contains n integers t1, t2, ..., tn (0 ≤ ti ≤ 1). There are ti criminals in the i-th city.
Output
Print the number of criminals Limak will catch.
Examples
Input
6 3
1 1 1 0 1 0
Output
3
Input
5 2
0 0 0 1 0
Output
1
Note
In the first sample, there are six cities and Limak lives in the third one (blue arrow below). Criminals are in cities marked red.
<image>
Using the BCD gives Limak the following information:
* There is one criminal at distance 0 from the third city — Limak is sure that this criminal is exactly in the third city.
* There is one criminal at distance 1 from the third city — Limak doesn't know if a criminal is in the second or fourth city.
* There are two criminals at distance 2 from the third city — Limak is sure that there is one criminal in the first city and one in the fifth city.
* There are zero criminals for every greater distance.
So, Limak will catch criminals in cities 1, 3 and 5, that is 3 criminals in total.
In the second sample (drawing below), the BCD gives Limak the information that there is one criminal at distance 2 from Limak's city. There is only one city at distance 2 so Limak is sure where a criminal is.
<image>
Tags: constructive algorithms, implementation
Correct Solution:
```
n,a=map(int,input().split())
a-=1
t=list(map(int,input().split()))
ans=0
for i in range(n):
if t[i]:
distance=i-a
j=a-distance
if j<0 or j>=n or t[i]==t[j]:
ans+=1
print(ans)
```
| 92,205 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities in Bearland, numbered 1 through n. Cities are arranged in one long row. The distance between cities i and j is equal to |i - j|.
Limak is a police officer. He lives in a city a. His job is to catch criminals. It's hard because he doesn't know in which cities criminals are. Though, he knows that there is at most one criminal in each city.
Limak is going to use a BCD (Bear Criminal Detector). The BCD will tell Limak how many criminals there are for every distance from a city a. After that, Limak can catch a criminal in each city for which he is sure that there must be a criminal.
You know in which cities criminals are. Count the number of criminals Limak will catch, after he uses the BCD.
Input
The first line of the input contains two integers n and a (1 ≤ a ≤ n ≤ 100) — the number of cities and the index of city where Limak lives.
The second line contains n integers t1, t2, ..., tn (0 ≤ ti ≤ 1). There are ti criminals in the i-th city.
Output
Print the number of criminals Limak will catch.
Examples
Input
6 3
1 1 1 0 1 0
Output
3
Input
5 2
0 0 0 1 0
Output
1
Note
In the first sample, there are six cities and Limak lives in the third one (blue arrow below). Criminals are in cities marked red.
<image>
Using the BCD gives Limak the following information:
* There is one criminal at distance 0 from the third city — Limak is sure that this criminal is exactly in the third city.
* There is one criminal at distance 1 from the third city — Limak doesn't know if a criminal is in the second or fourth city.
* There are two criminals at distance 2 from the third city — Limak is sure that there is one criminal in the first city and one in the fifth city.
* There are zero criminals for every greater distance.
So, Limak will catch criminals in cities 1, 3 and 5, that is 3 criminals in total.
In the second sample (drawing below), the BCD gives Limak the information that there is one criminal at distance 2 from Limak's city. There is only one city at distance 2 so Limak is sure where a criminal is.
<image>
Tags: constructive algorithms, implementation
Correct Solution:
```
# import sys
# sys.stdin = open("test.in","r")
# sys.stdout = open("test.out","w")
n,a=map(int,input().split())
b=list(map(int,input().split()))
c,d=a-2,a
e=sum(b)
while c>=0 and d<n:
e-=(b[c]+b[d])%2
c-=1
d+=1
print(e)
```
| 92,206 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities in Bearland, numbered 1 through n. Cities are arranged in one long row. The distance between cities i and j is equal to |i - j|.
Limak is a police officer. He lives in a city a. His job is to catch criminals. It's hard because he doesn't know in which cities criminals are. Though, he knows that there is at most one criminal in each city.
Limak is going to use a BCD (Bear Criminal Detector). The BCD will tell Limak how many criminals there are for every distance from a city a. After that, Limak can catch a criminal in each city for which he is sure that there must be a criminal.
You know in which cities criminals are. Count the number of criminals Limak will catch, after he uses the BCD.
Input
The first line of the input contains two integers n and a (1 ≤ a ≤ n ≤ 100) — the number of cities and the index of city where Limak lives.
The second line contains n integers t1, t2, ..., tn (0 ≤ ti ≤ 1). There are ti criminals in the i-th city.
Output
Print the number of criminals Limak will catch.
Examples
Input
6 3
1 1 1 0 1 0
Output
3
Input
5 2
0 0 0 1 0
Output
1
Note
In the first sample, there are six cities and Limak lives in the third one (blue arrow below). Criminals are in cities marked red.
<image>
Using the BCD gives Limak the following information:
* There is one criminal at distance 0 from the third city — Limak is sure that this criminal is exactly in the third city.
* There is one criminal at distance 1 from the third city — Limak doesn't know if a criminal is in the second or fourth city.
* There are two criminals at distance 2 from the third city — Limak is sure that there is one criminal in the first city and one in the fifth city.
* There are zero criminals for every greater distance.
So, Limak will catch criminals in cities 1, 3 and 5, that is 3 criminals in total.
In the second sample (drawing below), the BCD gives Limak the information that there is one criminal at distance 2 from Limak's city. There is only one city at distance 2 so Limak is sure where a criminal is.
<image>
Tags: constructive algorithms, implementation
Correct Solution:
```
from collections import defaultdict
if __name__ == "__main__":
#n, m = list(map(int, input().split()))
n, a = map(int, input().split())
A = list(map(int, input().split()))
ans, i = sum(A), 1
while a - 1 - i >= 0 and a - 1 + i <= n - 1:
if A[a - 1 - i] != A[a - 1 + i]:
ans -= 1
i += 1
print(ans)
```
| 92,207 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities in Bearland, numbered 1 through n. Cities are arranged in one long row. The distance between cities i and j is equal to |i - j|.
Limak is a police officer. He lives in a city a. His job is to catch criminals. It's hard because he doesn't know in which cities criminals are. Though, he knows that there is at most one criminal in each city.
Limak is going to use a BCD (Bear Criminal Detector). The BCD will tell Limak how many criminals there are for every distance from a city a. After that, Limak can catch a criminal in each city for which he is sure that there must be a criminal.
You know in which cities criminals are. Count the number of criminals Limak will catch, after he uses the BCD.
Input
The first line of the input contains two integers n and a (1 ≤ a ≤ n ≤ 100) — the number of cities and the index of city where Limak lives.
The second line contains n integers t1, t2, ..., tn (0 ≤ ti ≤ 1). There are ti criminals in the i-th city.
Output
Print the number of criminals Limak will catch.
Examples
Input
6 3
1 1 1 0 1 0
Output
3
Input
5 2
0 0 0 1 0
Output
1
Note
In the first sample, there are six cities and Limak lives in the third one (blue arrow below). Criminals are in cities marked red.
<image>
Using the BCD gives Limak the following information:
* There is one criminal at distance 0 from the third city — Limak is sure that this criminal is exactly in the third city.
* There is one criminal at distance 1 from the third city — Limak doesn't know if a criminal is in the second or fourth city.
* There are two criminals at distance 2 from the third city — Limak is sure that there is one criminal in the first city and one in the fifth city.
* There are zero criminals for every greater distance.
So, Limak will catch criminals in cities 1, 3 and 5, that is 3 criminals in total.
In the second sample (drawing below), the BCD gives Limak the information that there is one criminal at distance 2 from Limak's city. There is only one city at distance 2 so Limak is sure where a criminal is.
<image>
Tags: constructive algorithms, implementation
Correct Solution:
```
n,a=map(int,input().split());b=[]
t=list(map(int,input().split()))
for i in range(n):
if t[i]==1:
b.append(abs(i+1-a))
r=0
for j in b:
if b.count(j)==2 :
r+=1
elif b.count(j)==1 and (a-1-j<0 or a-1+j>n-1):
r+=1
elif j==0:
r+=1
print(r)
```
| 92,208 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities in Bearland, numbered 1 through n. Cities are arranged in one long row. The distance between cities i and j is equal to |i - j|.
Limak is a police officer. He lives in a city a. His job is to catch criminals. It's hard because he doesn't know in which cities criminals are. Though, he knows that there is at most one criminal in each city.
Limak is going to use a BCD (Bear Criminal Detector). The BCD will tell Limak how many criminals there are for every distance from a city a. After that, Limak can catch a criminal in each city for which he is sure that there must be a criminal.
You know in which cities criminals are. Count the number of criminals Limak will catch, after he uses the BCD.
Input
The first line of the input contains two integers n and a (1 ≤ a ≤ n ≤ 100) — the number of cities and the index of city where Limak lives.
The second line contains n integers t1, t2, ..., tn (0 ≤ ti ≤ 1). There are ti criminals in the i-th city.
Output
Print the number of criminals Limak will catch.
Examples
Input
6 3
1 1 1 0 1 0
Output
3
Input
5 2
0 0 0 1 0
Output
1
Note
In the first sample, there are six cities and Limak lives in the third one (blue arrow below). Criminals are in cities marked red.
<image>
Using the BCD gives Limak the following information:
* There is one criminal at distance 0 from the third city — Limak is sure that this criminal is exactly in the third city.
* There is one criminal at distance 1 from the third city — Limak doesn't know if a criminal is in the second or fourth city.
* There are two criminals at distance 2 from the third city — Limak is sure that there is one criminal in the first city and one in the fifth city.
* There are zero criminals for every greater distance.
So, Limak will catch criminals in cities 1, 3 and 5, that is 3 criminals in total.
In the second sample (drawing below), the BCD gives Limak the information that there is one criminal at distance 2 from Limak's city. There is only one city at distance 2 so Limak is sure where a criminal is.
<image>
Tags: constructive algorithms, implementation
Correct Solution:
```
n, a = map(int, input().split())
A = list(map(int, input().split()))
i = 1
cnt = A[a - 1]
while a - 1 - i >= 0 or a - 1 + i <= n - 1:
x = a - 1 - i
y = a - 1 + i
if x >= 0 and y <= n - 1:
if A[x] and A[y]:
cnt += 2
elif x >= 0:
cnt += A[x]
else:
cnt += A[y]
i += 1
print(cnt)
```
| 92,209 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities in Bearland, numbered 1 through n. Cities are arranged in one long row. The distance between cities i and j is equal to |i - j|.
Limak is a police officer. He lives in a city a. His job is to catch criminals. It's hard because he doesn't know in which cities criminals are. Though, he knows that there is at most one criminal in each city.
Limak is going to use a BCD (Bear Criminal Detector). The BCD will tell Limak how many criminals there are for every distance from a city a. After that, Limak can catch a criminal in each city for which he is sure that there must be a criminal.
You know in which cities criminals are. Count the number of criminals Limak will catch, after he uses the BCD.
Input
The first line of the input contains two integers n and a (1 ≤ a ≤ n ≤ 100) — the number of cities and the index of city where Limak lives.
The second line contains n integers t1, t2, ..., tn (0 ≤ ti ≤ 1). There are ti criminals in the i-th city.
Output
Print the number of criminals Limak will catch.
Examples
Input
6 3
1 1 1 0 1 0
Output
3
Input
5 2
0 0 0 1 0
Output
1
Note
In the first sample, there are six cities and Limak lives in the third one (blue arrow below). Criminals are in cities marked red.
<image>
Using the BCD gives Limak the following information:
* There is one criminal at distance 0 from the third city — Limak is sure that this criminal is exactly in the third city.
* There is one criminal at distance 1 from the third city — Limak doesn't know if a criminal is in the second or fourth city.
* There are two criminals at distance 2 from the third city — Limak is sure that there is one criminal in the first city and one in the fifth city.
* There are zero criminals for every greater distance.
So, Limak will catch criminals in cities 1, 3 and 5, that is 3 criminals in total.
In the second sample (drawing below), the BCD gives Limak the information that there is one criminal at distance 2 from Limak's city. There is only one city at distance 2 so Limak is sure where a criminal is.
<image>
Tags: constructive algorithms, implementation
Correct Solution:
```
import sys
input = sys.stdin.readline
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
x,y=invr()
z=inlt()
limakindex=y-1
a=1
crimescaught=0
limakpos=z[limakindex]
if z[limakindex]==1:
crimescaught+=1
while (limakindex-a)>=0 and (limakindex+a)<=(len(z)-1):
if z[limakindex-a]+z[limakindex+a]==2:
crimescaught+=2
a+=1
else:
a+=1
if (limakindex-a)<=0 and not (limakindex+a)>=(len(z)-1):
while (limakindex+a)<=(len(z)-1):
if z[limakindex+a]==1:
crimescaught+=1
a+=1
else:
a+=1
elif (limakindex+a)>=(len(z)-1) and not (limakindex-a)<=0:
while (limakindex-a)>=0:
if z[limakindex-a]==1:
crimescaught+=1
a+=1
else:
a+=1
if len(z)==2:
crimescaught=sum(z)
print(crimescaught)
```
| 92,210 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities in Bearland, numbered 1 through n. Cities are arranged in one long row. The distance between cities i and j is equal to |i - j|.
Limak is a police officer. He lives in a city a. His job is to catch criminals. It's hard because he doesn't know in which cities criminals are. Though, he knows that there is at most one criminal in each city.
Limak is going to use a BCD (Bear Criminal Detector). The BCD will tell Limak how many criminals there are for every distance from a city a. After that, Limak can catch a criminal in each city for which he is sure that there must be a criminal.
You know in which cities criminals are. Count the number of criminals Limak will catch, after he uses the BCD.
Input
The first line of the input contains two integers n and a (1 ≤ a ≤ n ≤ 100) — the number of cities and the index of city where Limak lives.
The second line contains n integers t1, t2, ..., tn (0 ≤ ti ≤ 1). There are ti criminals in the i-th city.
Output
Print the number of criminals Limak will catch.
Examples
Input
6 3
1 1 1 0 1 0
Output
3
Input
5 2
0 0 0 1 0
Output
1
Note
In the first sample, there are six cities and Limak lives in the third one (blue arrow below). Criminals are in cities marked red.
<image>
Using the BCD gives Limak the following information:
* There is one criminal at distance 0 from the third city — Limak is sure that this criminal is exactly in the third city.
* There is one criminal at distance 1 from the third city — Limak doesn't know if a criminal is in the second or fourth city.
* There are two criminals at distance 2 from the third city — Limak is sure that there is one criminal in the first city and one in the fifth city.
* There are zero criminals for every greater distance.
So, Limak will catch criminals in cities 1, 3 and 5, that is 3 criminals in total.
In the second sample (drawing below), the BCD gives Limak the information that there is one criminal at distance 2 from Limak's city. There is only one city at distance 2 so Limak is sure where a criminal is.
<image>
Submitted Solution:
```
#!/usr/bin/python3.5
n,k=map(int,input().split())
mas=[int(x) for x in input().split()]
k-=1
u=max(k,n-k-1)
u+=1
c=0
for i in range(u):
if i==0:
if mas[k]:
c+=1
else:
if k+i>=n:
if k-i>=0 and mas[k-i]:
c+=1
elif k-i<0:
if k+i<n and mas[k+i]:
c+=1
else:
if mas[k-i] and mas[k+i]:
c+=2
print(c)
```
Yes
| 92,211 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities in Bearland, numbered 1 through n. Cities are arranged in one long row. The distance between cities i and j is equal to |i - j|.
Limak is a police officer. He lives in a city a. His job is to catch criminals. It's hard because he doesn't know in which cities criminals are. Though, he knows that there is at most one criminal in each city.
Limak is going to use a BCD (Bear Criminal Detector). The BCD will tell Limak how many criminals there are for every distance from a city a. After that, Limak can catch a criminal in each city for which he is sure that there must be a criminal.
You know in which cities criminals are. Count the number of criminals Limak will catch, after he uses the BCD.
Input
The first line of the input contains two integers n and a (1 ≤ a ≤ n ≤ 100) — the number of cities and the index of city where Limak lives.
The second line contains n integers t1, t2, ..., tn (0 ≤ ti ≤ 1). There are ti criminals in the i-th city.
Output
Print the number of criminals Limak will catch.
Examples
Input
6 3
1 1 1 0 1 0
Output
3
Input
5 2
0 0 0 1 0
Output
1
Note
In the first sample, there are six cities and Limak lives in the third one (blue arrow below). Criminals are in cities marked red.
<image>
Using the BCD gives Limak the following information:
* There is one criminal at distance 0 from the third city — Limak is sure that this criminal is exactly in the third city.
* There is one criminal at distance 1 from the third city — Limak doesn't know if a criminal is in the second or fourth city.
* There are two criminals at distance 2 from the third city — Limak is sure that there is one criminal in the first city and one in the fifth city.
* There are zero criminals for every greater distance.
So, Limak will catch criminals in cities 1, 3 and 5, that is 3 criminals in total.
In the second sample (drawing below), the BCD gives Limak the information that there is one criminal at distance 2 from Limak's city. There is only one city at distance 2 so Limak is sure where a criminal is.
<image>
Submitted Solution:
```
def R(): return map(int, input().split())
def I(): return int(input())
def S(): return str(input())
def L(): return list(R())
from collections import Counter
import math
import sys
from itertools import permutations
import bisect
n,a=R()
ol=L()
cnt=0
for i in range(n):
if i>0 and a-i>=1 and a+i<=n:
cnt+=2*(ol[a-i-1]+ol[a+i-1]==2)
if i>0 and a-i<1 and a+i<=n:
cnt+=(ol[a+i-1]==1)
if i>0 and a-i>=1 and a+i>n:
cnt+=(ol[a-i-1]==1)
if i==0 and ol[a-1]==1:
cnt+=1
print(cnt)
```
Yes
| 92,212 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities in Bearland, numbered 1 through n. Cities are arranged in one long row. The distance between cities i and j is equal to |i - j|.
Limak is a police officer. He lives in a city a. His job is to catch criminals. It's hard because he doesn't know in which cities criminals are. Though, he knows that there is at most one criminal in each city.
Limak is going to use a BCD (Bear Criminal Detector). The BCD will tell Limak how many criminals there are for every distance from a city a. After that, Limak can catch a criminal in each city for which he is sure that there must be a criminal.
You know in which cities criminals are. Count the number of criminals Limak will catch, after he uses the BCD.
Input
The first line of the input contains two integers n and a (1 ≤ a ≤ n ≤ 100) — the number of cities and the index of city where Limak lives.
The second line contains n integers t1, t2, ..., tn (0 ≤ ti ≤ 1). There are ti criminals in the i-th city.
Output
Print the number of criminals Limak will catch.
Examples
Input
6 3
1 1 1 0 1 0
Output
3
Input
5 2
0 0 0 1 0
Output
1
Note
In the first sample, there are six cities and Limak lives in the third one (blue arrow below). Criminals are in cities marked red.
<image>
Using the BCD gives Limak the following information:
* There is one criminal at distance 0 from the third city — Limak is sure that this criminal is exactly in the third city.
* There is one criminal at distance 1 from the third city — Limak doesn't know if a criminal is in the second or fourth city.
* There are two criminals at distance 2 from the third city — Limak is sure that there is one criminal in the first city and one in the fifth city.
* There are zero criminals for every greater distance.
So, Limak will catch criminals in cities 1, 3 and 5, that is 3 criminals in total.
In the second sample (drawing below), the BCD gives Limak the information that there is one criminal at distance 2 from Limak's city. There is only one city at distance 2 so Limak is sure where a criminal is.
<image>
Submitted Solution:
```
n,a = [int(x) for x in input().split()]
t = [int(x) for x in input().split()]
a = a - 1
i,j = a - 1, a + 1
criminals = 0
if t[a] == 1:
criminals = 1
while(i > -1 and j < n ):
if t[i] == 1 and t[j] == 1:
criminals += 2
i -= 1
j += 1
while i > -1:
if t[i] == 1:
criminals += 1
i -= 1
while j < n:
if t[j] == 1:
criminals += 1
j += 1
print(criminals)
```
Yes
| 92,213 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities in Bearland, numbered 1 through n. Cities are arranged in one long row. The distance between cities i and j is equal to |i - j|.
Limak is a police officer. He lives in a city a. His job is to catch criminals. It's hard because he doesn't know in which cities criminals are. Though, he knows that there is at most one criminal in each city.
Limak is going to use a BCD (Bear Criminal Detector). The BCD will tell Limak how many criminals there are for every distance from a city a. After that, Limak can catch a criminal in each city for which he is sure that there must be a criminal.
You know in which cities criminals are. Count the number of criminals Limak will catch, after he uses the BCD.
Input
The first line of the input contains two integers n and a (1 ≤ a ≤ n ≤ 100) — the number of cities and the index of city where Limak lives.
The second line contains n integers t1, t2, ..., tn (0 ≤ ti ≤ 1). There are ti criminals in the i-th city.
Output
Print the number of criminals Limak will catch.
Examples
Input
6 3
1 1 1 0 1 0
Output
3
Input
5 2
0 0 0 1 0
Output
1
Note
In the first sample, there are six cities and Limak lives in the third one (blue arrow below). Criminals are in cities marked red.
<image>
Using the BCD gives Limak the following information:
* There is one criminal at distance 0 from the third city — Limak is sure that this criminal is exactly in the third city.
* There is one criminal at distance 1 from the third city — Limak doesn't know if a criminal is in the second or fourth city.
* There are two criminals at distance 2 from the third city — Limak is sure that there is one criminal in the first city and one in the fifth city.
* There are zero criminals for every greater distance.
So, Limak will catch criminals in cities 1, 3 and 5, that is 3 criminals in total.
In the second sample (drawing below), the BCD gives Limak the information that there is one criminal at distance 2 from Limak's city. There is only one city at distance 2 so Limak is sure where a criminal is.
<image>
Submitted Solution:
```
#n = int(input()[-2:])
n, m = map(int, input().split())
#s = input()
c = list(map(int, input().split()))
m -= 1
k = min(n - m, m + 1)
l = 0 + (c[m] == 1)
for i in range(1, k):
if c[m - i] == 1 and c[m + i] == 1:
l += 2
if k - 1 == m:
for i in range(m * 2 + 1, n):
if c[i] == 1:
l += 1
else:
for i in range(0, m - k + 1):
if c[i] == 1:
l += 1
print(l)
```
Yes
| 92,214 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities in Bearland, numbered 1 through n. Cities are arranged in one long row. The distance between cities i and j is equal to |i - j|.
Limak is a police officer. He lives in a city a. His job is to catch criminals. It's hard because he doesn't know in which cities criminals are. Though, he knows that there is at most one criminal in each city.
Limak is going to use a BCD (Bear Criminal Detector). The BCD will tell Limak how many criminals there are for every distance from a city a. After that, Limak can catch a criminal in each city for which he is sure that there must be a criminal.
You know in which cities criminals are. Count the number of criminals Limak will catch, after he uses the BCD.
Input
The first line of the input contains two integers n and a (1 ≤ a ≤ n ≤ 100) — the number of cities and the index of city where Limak lives.
The second line contains n integers t1, t2, ..., tn (0 ≤ ti ≤ 1). There are ti criminals in the i-th city.
Output
Print the number of criminals Limak will catch.
Examples
Input
6 3
1 1 1 0 1 0
Output
3
Input
5 2
0 0 0 1 0
Output
1
Note
In the first sample, there are six cities and Limak lives in the third one (blue arrow below). Criminals are in cities marked red.
<image>
Using the BCD gives Limak the following information:
* There is one criminal at distance 0 from the third city — Limak is sure that this criminal is exactly in the third city.
* There is one criminal at distance 1 from the third city — Limak doesn't know if a criminal is in the second or fourth city.
* There are two criminals at distance 2 from the third city — Limak is sure that there is one criminal in the first city and one in the fifth city.
* There are zero criminals for every greater distance.
So, Limak will catch criminals in cities 1, 3 and 5, that is 3 criminals in total.
In the second sample (drawing below), the BCD gives Limak the information that there is one criminal at distance 2 from Limak's city. There is only one city at distance 2 so Limak is sure where a criminal is.
<image>
Submitted Solution:
```
n1=input().split()
a=int(n1[1])-1
arr=input().split()
arr=map(int,arr)
arr=list(arr)
n=len(arr)
x=arr[:a+1]
x=len(x)
y=arr[a+1:]
y=len(y)
if len(arr)==1:
res =sum(arr)
else:
res=arr[a]
if x>y:
res=sum(arr[:a-y])
arr=arr[y:]
elif y>x:
res=sum(arr[abs(a + x):])
arr=arr[:n-x]
a=int(len(arr)/2 -1)
for i in range(1,a+1):
if arr[a-i]+arr[a+i]==2:
res +=2
print(res)
```
No
| 92,215 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities in Bearland, numbered 1 through n. Cities are arranged in one long row. The distance between cities i and j is equal to |i - j|.
Limak is a police officer. He lives in a city a. His job is to catch criminals. It's hard because he doesn't know in which cities criminals are. Though, he knows that there is at most one criminal in each city.
Limak is going to use a BCD (Bear Criminal Detector). The BCD will tell Limak how many criminals there are for every distance from a city a. After that, Limak can catch a criminal in each city for which he is sure that there must be a criminal.
You know in which cities criminals are. Count the number of criminals Limak will catch, after he uses the BCD.
Input
The first line of the input contains two integers n and a (1 ≤ a ≤ n ≤ 100) — the number of cities and the index of city where Limak lives.
The second line contains n integers t1, t2, ..., tn (0 ≤ ti ≤ 1). There are ti criminals in the i-th city.
Output
Print the number of criminals Limak will catch.
Examples
Input
6 3
1 1 1 0 1 0
Output
3
Input
5 2
0 0 0 1 0
Output
1
Note
In the first sample, there are six cities and Limak lives in the third one (blue arrow below). Criminals are in cities marked red.
<image>
Using the BCD gives Limak the following information:
* There is one criminal at distance 0 from the third city — Limak is sure that this criminal is exactly in the third city.
* There is one criminal at distance 1 from the third city — Limak doesn't know if a criminal is in the second or fourth city.
* There are two criminals at distance 2 from the third city — Limak is sure that there is one criminal in the first city and one in the fifth city.
* There are zero criminals for every greater distance.
So, Limak will catch criminals in cities 1, 3 and 5, that is 3 criminals in total.
In the second sample (drawing below), the BCD gives Limak the information that there is one criminal at distance 2 from Limak's city. There is only one city at distance 2 so Limak is sure where a criminal is.
<image>
Submitted Solution:
```
l=list(map(int,input().split()))
l1=list(map(int,input().split()))
k=l[1]-1
i=1
count=0
l=l[0]-1
if l1[k]==1:
count+=1
while k-i!=0 or k+i!=l:
if k-i<0 or k+i>l:
break
if l1[k-i]==1 and l1[k+i]==1:
count+=2
i+=1
if (k-i)>0:
count+=l1[:(k-i)+1].count(1)
if (k+i)<l:
count+=l1[k+i:].count(1)
print(count)
```
No
| 92,216 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities in Bearland, numbered 1 through n. Cities are arranged in one long row. The distance between cities i and j is equal to |i - j|.
Limak is a police officer. He lives in a city a. His job is to catch criminals. It's hard because he doesn't know in which cities criminals are. Though, he knows that there is at most one criminal in each city.
Limak is going to use a BCD (Bear Criminal Detector). The BCD will tell Limak how many criminals there are for every distance from a city a. After that, Limak can catch a criminal in each city for which he is sure that there must be a criminal.
You know in which cities criminals are. Count the number of criminals Limak will catch, after he uses the BCD.
Input
The first line of the input contains two integers n and a (1 ≤ a ≤ n ≤ 100) — the number of cities and the index of city where Limak lives.
The second line contains n integers t1, t2, ..., tn (0 ≤ ti ≤ 1). There are ti criminals in the i-th city.
Output
Print the number of criminals Limak will catch.
Examples
Input
6 3
1 1 1 0 1 0
Output
3
Input
5 2
0 0 0 1 0
Output
1
Note
In the first sample, there are six cities and Limak lives in the third one (blue arrow below). Criminals are in cities marked red.
<image>
Using the BCD gives Limak the following information:
* There is one criminal at distance 0 from the third city — Limak is sure that this criminal is exactly in the third city.
* There is one criminal at distance 1 from the third city — Limak doesn't know if a criminal is in the second or fourth city.
* There are two criminals at distance 2 from the third city — Limak is sure that there is one criminal in the first city and one in the fifth city.
* There are zero criminals for every greater distance.
So, Limak will catch criminals in cities 1, 3 and 5, that is 3 criminals in total.
In the second sample (drawing below), the BCD gives Limak the information that there is one criminal at distance 2 from Limak's city. There is only one city at distance 2 so Limak is sure where a criminal is.
<image>
Submitted Solution:
```
buff = input().split(" ")
n = int(buff[0])
a = int(buff[1])
t = input().split(" ")
res = 0
if n-a > a-1:
for i in range(n-a+1):
if t[(a+i-1)%n] == "1" and t[(a-i-1)%n] == "1":
if i == 0:
res += 1
else:
res += 2
else:
for i in range(a):
if t[(a+i-1)%n] == "1" and t[(a-i-1)%n] == "1":
if i == 0:
res+=1
else:
res+=2
print(res)
```
No
| 92,217 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities in Bearland, numbered 1 through n. Cities are arranged in one long row. The distance between cities i and j is equal to |i - j|.
Limak is a police officer. He lives in a city a. His job is to catch criminals. It's hard because he doesn't know in which cities criminals are. Though, he knows that there is at most one criminal in each city.
Limak is going to use a BCD (Bear Criminal Detector). The BCD will tell Limak how many criminals there are for every distance from a city a. After that, Limak can catch a criminal in each city for which he is sure that there must be a criminal.
You know in which cities criminals are. Count the number of criminals Limak will catch, after he uses the BCD.
Input
The first line of the input contains two integers n and a (1 ≤ a ≤ n ≤ 100) — the number of cities and the index of city where Limak lives.
The second line contains n integers t1, t2, ..., tn (0 ≤ ti ≤ 1). There are ti criminals in the i-th city.
Output
Print the number of criminals Limak will catch.
Examples
Input
6 3
1 1 1 0 1 0
Output
3
Input
5 2
0 0 0 1 0
Output
1
Note
In the first sample, there are six cities and Limak lives in the third one (blue arrow below). Criminals are in cities marked red.
<image>
Using the BCD gives Limak the following information:
* There is one criminal at distance 0 from the third city — Limak is sure that this criminal is exactly in the third city.
* There is one criminal at distance 1 from the third city — Limak doesn't know if a criminal is in the second or fourth city.
* There are two criminals at distance 2 from the third city — Limak is sure that there is one criminal in the first city and one in the fifth city.
* There are zero criminals for every greater distance.
So, Limak will catch criminals in cities 1, 3 and 5, that is 3 criminals in total.
In the second sample (drawing below), the BCD gives Limak the information that there is one criminal at distance 2 from Limak's city. There is only one city at distance 2 so Limak is sure where a criminal is.
<image>
Submitted Solution:
```
n, a = map(int, input().split())
ar = list(map(int, input().split()))
a = a - 1
c = ar[a]
if n == 1:
print(ar[0])
exit(0)
b = min(n - a, a)
for i in range(1,b):
c += ((ar[a - i] & ar[a + i]) << 1)
for i in range(a - b):
c += ar[i]
for i in range(a + b, n):
c += ar[i]
print(c)
```
No
| 92,218 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game.
Rules of the game are very simple: at first number of rounds n is defined. In every round each of the players throws a cubical dice with distinct numbers from 1 to 6 written on its faces. Player, whose value after throwing the dice is greater, wins the round. In case if player dice values are equal, no one of them is a winner.
In average, player, who won most of the rounds, is the winner of the game. In case if two players won the same number of rounds, the result of the game is draw.
Mishka is still very little and can't count wins and losses, so she asked you to watch their game and determine its result. Please help her!
Input
The first line of the input contains single integer n n (1 ≤ n ≤ 100) — the number of game rounds.
The next n lines contains rounds description. i-th of them contains pair of integers mi and ci (1 ≤ mi, ci ≤ 6) — values on dice upper face after Mishka's and Chris' throws in i-th round respectively.
Output
If Mishka is the winner of the game, print "Mishka" (without quotes) in the only line.
If Chris is the winner of the game, print "Chris" (without quotes) in the only line.
If the result of the game is draw, print "Friendship is magic!^^" (without quotes) in the only line.
Examples
Input
3
3 5
2 1
4 2
Output
Mishka
Input
2
6 1
1 6
Output
Friendship is magic!^^
Input
3
1 5
3 3
2 2
Output
Chris
Note
In the first sample case Mishka loses the first round, but wins second and third rounds and thus she is the winner of the game.
In the second sample case Mishka wins the first round, Chris wins the second round, and the game ends with draw with score 1:1.
In the third sample case Chris wins the first round, but there is no winner of the next two rounds. The winner of the game is Chris.
Tags: implementation
Correct Solution:
```
n = int(input())
y = 0
x = 0
for i in range(n):
dice1, dice2 = map(int, input().split())
if dice1 > dice2:
y += 1
elif dice1 < dice2:
x += 1
else:
x += 0
if x < y:
print('Mishka')
if x > y:
print('Chris')###CF703A
##n = int(input())
##a = 0
##b = 0
##for i in range(n):
## m, c = map(int, input().split())
## if m >= c:
## a += 1
## else:
## b += 1
##if a > b:
## print('Mishka')
##elif a < b:
## print('Chris')
##elif a == b:
## print("Friendship is magic!^^")
if x == y:
print('Friendship is magic!^^')
```
| 92,219 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game.
Rules of the game are very simple: at first number of rounds n is defined. In every round each of the players throws a cubical dice with distinct numbers from 1 to 6 written on its faces. Player, whose value after throwing the dice is greater, wins the round. In case if player dice values are equal, no one of them is a winner.
In average, player, who won most of the rounds, is the winner of the game. In case if two players won the same number of rounds, the result of the game is draw.
Mishka is still very little and can't count wins and losses, so she asked you to watch their game and determine its result. Please help her!
Input
The first line of the input contains single integer n n (1 ≤ n ≤ 100) — the number of game rounds.
The next n lines contains rounds description. i-th of them contains pair of integers mi and ci (1 ≤ mi, ci ≤ 6) — values on dice upper face after Mishka's and Chris' throws in i-th round respectively.
Output
If Mishka is the winner of the game, print "Mishka" (without quotes) in the only line.
If Chris is the winner of the game, print "Chris" (without quotes) in the only line.
If the result of the game is draw, print "Friendship is magic!^^" (without quotes) in the only line.
Examples
Input
3
3 5
2 1
4 2
Output
Mishka
Input
2
6 1
1 6
Output
Friendship is magic!^^
Input
3
1 5
3 3
2 2
Output
Chris
Note
In the first sample case Mishka loses the first round, but wins second and third rounds and thus she is the winner of the game.
In the second sample case Mishka wins the first round, Chris wins the second round, and the game ends with draw with score 1:1.
In the third sample case Chris wins the first round, but there is no winner of the next two rounds. The winner of the game is Chris.
Tags: implementation
Correct Solution:
```
a=int(input())
m=0
c=0
for i in range(a):
x,y=map(int,input().split())
if(x>y):
c+=1
elif(x<y):
m+=1
else:
pass
if(m>c):
print("Chris")
elif(c>m):
print("Mishka")
else:
print("Friendship is magic!^^")
```
| 92,220 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game.
Rules of the game are very simple: at first number of rounds n is defined. In every round each of the players throws a cubical dice with distinct numbers from 1 to 6 written on its faces. Player, whose value after throwing the dice is greater, wins the round. In case if player dice values are equal, no one of them is a winner.
In average, player, who won most of the rounds, is the winner of the game. In case if two players won the same number of rounds, the result of the game is draw.
Mishka is still very little and can't count wins and losses, so she asked you to watch their game and determine its result. Please help her!
Input
The first line of the input contains single integer n n (1 ≤ n ≤ 100) — the number of game rounds.
The next n lines contains rounds description. i-th of them contains pair of integers mi and ci (1 ≤ mi, ci ≤ 6) — values on dice upper face after Mishka's and Chris' throws in i-th round respectively.
Output
If Mishka is the winner of the game, print "Mishka" (without quotes) in the only line.
If Chris is the winner of the game, print "Chris" (without quotes) in the only line.
If the result of the game is draw, print "Friendship is magic!^^" (without quotes) in the only line.
Examples
Input
3
3 5
2 1
4 2
Output
Mishka
Input
2
6 1
1 6
Output
Friendship is magic!^^
Input
3
1 5
3 3
2 2
Output
Chris
Note
In the first sample case Mishka loses the first round, but wins second and third rounds and thus she is the winner of the game.
In the second sample case Mishka wins the first round, Chris wins the second round, and the game ends with draw with score 1:1.
In the third sample case Chris wins the first round, but there is no winner of the next two rounds. The winner of the game is Chris.
Tags: implementation
Correct Solution:
```
n=int(input())
cm=cc=0
for i in range(n):
x=[]
x=input().split()
if(x[0]>x[1]):
cm+=1
elif(x[0]<x[1]):
cc+=1
else:
cm+=1
cc+=1
if(cm>cc):
print('Mishka')
elif(cm==cc):
print('Friendship is magic!^^')
else:
print('Chris')
```
| 92,221 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game.
Rules of the game are very simple: at first number of rounds n is defined. In every round each of the players throws a cubical dice with distinct numbers from 1 to 6 written on its faces. Player, whose value after throwing the dice is greater, wins the round. In case if player dice values are equal, no one of them is a winner.
In average, player, who won most of the rounds, is the winner of the game. In case if two players won the same number of rounds, the result of the game is draw.
Mishka is still very little and can't count wins and losses, so she asked you to watch their game and determine its result. Please help her!
Input
The first line of the input contains single integer n n (1 ≤ n ≤ 100) — the number of game rounds.
The next n lines contains rounds description. i-th of them contains pair of integers mi and ci (1 ≤ mi, ci ≤ 6) — values on dice upper face after Mishka's and Chris' throws in i-th round respectively.
Output
If Mishka is the winner of the game, print "Mishka" (without quotes) in the only line.
If Chris is the winner of the game, print "Chris" (without quotes) in the only line.
If the result of the game is draw, print "Friendship is magic!^^" (without quotes) in the only line.
Examples
Input
3
3 5
2 1
4 2
Output
Mishka
Input
2
6 1
1 6
Output
Friendship is magic!^^
Input
3
1 5
3 3
2 2
Output
Chris
Note
In the first sample case Mishka loses the first round, but wins second and third rounds and thus she is the winner of the game.
In the second sample case Mishka wins the first round, Chris wins the second round, and the game ends with draw with score 1:1.
In the third sample case Chris wins the first round, but there is no winner of the next two rounds. The winner of the game is Chris.
Tags: implementation
Correct Solution:
```
n = int(input())
msh = cr = 0
for i in range(n):
m,c = list(map(int,input().split()))
if m==c:
continue
if max(m,c)==m:
msh+=1
if max(m,c)==c:
cr+=1
if msh<cr:
print("Chris")
elif cr<msh:
print("Mishka")
else:
print("Friendship is magic!^^")
```
| 92,222 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game.
Rules of the game are very simple: at first number of rounds n is defined. In every round each of the players throws a cubical dice with distinct numbers from 1 to 6 written on its faces. Player, whose value after throwing the dice is greater, wins the round. In case if player dice values are equal, no one of them is a winner.
In average, player, who won most of the rounds, is the winner of the game. In case if two players won the same number of rounds, the result of the game is draw.
Mishka is still very little and can't count wins and losses, so she asked you to watch their game and determine its result. Please help her!
Input
The first line of the input contains single integer n n (1 ≤ n ≤ 100) — the number of game rounds.
The next n lines contains rounds description. i-th of them contains pair of integers mi and ci (1 ≤ mi, ci ≤ 6) — values on dice upper face after Mishka's and Chris' throws in i-th round respectively.
Output
If Mishka is the winner of the game, print "Mishka" (without quotes) in the only line.
If Chris is the winner of the game, print "Chris" (without quotes) in the only line.
If the result of the game is draw, print "Friendship is magic!^^" (without quotes) in the only line.
Examples
Input
3
3 5
2 1
4 2
Output
Mishka
Input
2
6 1
1 6
Output
Friendship is magic!^^
Input
3
1 5
3 3
2 2
Output
Chris
Note
In the first sample case Mishka loses the first round, but wins second and third rounds and thus she is the winner of the game.
In the second sample case Mishka wins the first round, Chris wins the second round, and the game ends with draw with score 1:1.
In the third sample case Chris wins the first round, but there is no winner of the next two rounds. The winner of the game is Chris.
Tags: implementation
Correct Solution:
```
c,m=0,0
for _ in range(int(input())):
a,b=map(int,input().split())
if a>b:
m+=1
elif b>a:
c+=1
if m>c:
print('Mishka')
elif c>m:
print('Chris')
else:
print('Friendship is magic!^^')
```
| 92,223 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game.
Rules of the game are very simple: at first number of rounds n is defined. In every round each of the players throws a cubical dice with distinct numbers from 1 to 6 written on its faces. Player, whose value after throwing the dice is greater, wins the round. In case if player dice values are equal, no one of them is a winner.
In average, player, who won most of the rounds, is the winner of the game. In case if two players won the same number of rounds, the result of the game is draw.
Mishka is still very little and can't count wins and losses, so she asked you to watch their game and determine its result. Please help her!
Input
The first line of the input contains single integer n n (1 ≤ n ≤ 100) — the number of game rounds.
The next n lines contains rounds description. i-th of them contains pair of integers mi and ci (1 ≤ mi, ci ≤ 6) — values on dice upper face after Mishka's and Chris' throws in i-th round respectively.
Output
If Mishka is the winner of the game, print "Mishka" (without quotes) in the only line.
If Chris is the winner of the game, print "Chris" (without quotes) in the only line.
If the result of the game is draw, print "Friendship is magic!^^" (without quotes) in the only line.
Examples
Input
3
3 5
2 1
4 2
Output
Mishka
Input
2
6 1
1 6
Output
Friendship is magic!^^
Input
3
1 5
3 3
2 2
Output
Chris
Note
In the first sample case Mishka loses the first round, but wins second and third rounds and thus she is the winner of the game.
In the second sample case Mishka wins the first round, Chris wins the second round, and the game ends with draw with score 1:1.
In the third sample case Chris wins the first round, but there is no winner of the next two rounds. The winner of the game is Chris.
Tags: implementation
Correct Solution:
```
n = int(input())
k = []
for i in range(n):
j = input()
j = j.split()
k.append(int(j[0]))
k.append(int(j[1]))
#print(k)
m = 0
c = 0
for i in range(0,n):
#print(i)
if k[i*2]>k[i*2+1]:
m+=1
elif k[i*2]<k[i*2+1]:
c+=1
if m>c:
print("Mishka")
elif m<c:
print("Chris")
else:
print("Friendship is magic!^^")
```
| 92,224 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game.
Rules of the game are very simple: at first number of rounds n is defined. In every round each of the players throws a cubical dice with distinct numbers from 1 to 6 written on its faces. Player, whose value after throwing the dice is greater, wins the round. In case if player dice values are equal, no one of them is a winner.
In average, player, who won most of the rounds, is the winner of the game. In case if two players won the same number of rounds, the result of the game is draw.
Mishka is still very little and can't count wins and losses, so she asked you to watch their game and determine its result. Please help her!
Input
The first line of the input contains single integer n n (1 ≤ n ≤ 100) — the number of game rounds.
The next n lines contains rounds description. i-th of them contains pair of integers mi and ci (1 ≤ mi, ci ≤ 6) — values on dice upper face after Mishka's and Chris' throws in i-th round respectively.
Output
If Mishka is the winner of the game, print "Mishka" (without quotes) in the only line.
If Chris is the winner of the game, print "Chris" (without quotes) in the only line.
If the result of the game is draw, print "Friendship is magic!^^" (without quotes) in the only line.
Examples
Input
3
3 5
2 1
4 2
Output
Mishka
Input
2
6 1
1 6
Output
Friendship is magic!^^
Input
3
1 5
3 3
2 2
Output
Chris
Note
In the first sample case Mishka loses the first round, but wins second and third rounds and thus she is the winner of the game.
In the second sample case Mishka wins the first round, Chris wins the second round, and the game ends with draw with score 1:1.
In the third sample case Chris wins the first round, but there is no winner of the next two rounds. The winner of the game is Chris.
Tags: implementation
Correct Solution:
```
n = int(input())
m,c=[0,0]
for i in range(n):
x,y=map(int, input().split())
if x>y:
m+=1
elif y>x:
c+=1
if m>c:
print ('Mishka')
elif c>m:
print ('Chris')
else:
print ('Friendship is magic!^^')
```
| 92,225 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game.
Rules of the game are very simple: at first number of rounds n is defined. In every round each of the players throws a cubical dice with distinct numbers from 1 to 6 written on its faces. Player, whose value after throwing the dice is greater, wins the round. In case if player dice values are equal, no one of them is a winner.
In average, player, who won most of the rounds, is the winner of the game. In case if two players won the same number of rounds, the result of the game is draw.
Mishka is still very little and can't count wins and losses, so she asked you to watch their game and determine its result. Please help her!
Input
The first line of the input contains single integer n n (1 ≤ n ≤ 100) — the number of game rounds.
The next n lines contains rounds description. i-th of them contains pair of integers mi and ci (1 ≤ mi, ci ≤ 6) — values on dice upper face after Mishka's and Chris' throws in i-th round respectively.
Output
If Mishka is the winner of the game, print "Mishka" (without quotes) in the only line.
If Chris is the winner of the game, print "Chris" (without quotes) in the only line.
If the result of the game is draw, print "Friendship is magic!^^" (without quotes) in the only line.
Examples
Input
3
3 5
2 1
4 2
Output
Mishka
Input
2
6 1
1 6
Output
Friendship is magic!^^
Input
3
1 5
3 3
2 2
Output
Chris
Note
In the first sample case Mishka loses the first round, but wins second and third rounds and thus she is the winner of the game.
In the second sample case Mishka wins the first round, Chris wins the second round, and the game ends with draw with score 1:1.
In the third sample case Chris wins the first round, but there is no winner of the next two rounds. The winner of the game is Chris.
Tags: implementation
Correct Solution:
```
n = int(input())
s = []
for i in range(n):
m, c = map(int,input().split())
if m>c:
s.append('m')
if c>m:
s.append('c')
m = s.count('m')
c = s.count('c')
if m>c:
print('Mishka')
elif c>m:
print('Chris')
else:
print('Friendship is magic!^^')
```
| 92,226 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game.
Rules of the game are very simple: at first number of rounds n is defined. In every round each of the players throws a cubical dice with distinct numbers from 1 to 6 written on its faces. Player, whose value after throwing the dice is greater, wins the round. In case if player dice values are equal, no one of them is a winner.
In average, player, who won most of the rounds, is the winner of the game. In case if two players won the same number of rounds, the result of the game is draw.
Mishka is still very little and can't count wins and losses, so she asked you to watch their game and determine its result. Please help her!
Input
The first line of the input contains single integer n n (1 ≤ n ≤ 100) — the number of game rounds.
The next n lines contains rounds description. i-th of them contains pair of integers mi and ci (1 ≤ mi, ci ≤ 6) — values on dice upper face after Mishka's and Chris' throws in i-th round respectively.
Output
If Mishka is the winner of the game, print "Mishka" (without quotes) in the only line.
If Chris is the winner of the game, print "Chris" (without quotes) in the only line.
If the result of the game is draw, print "Friendship is magic!^^" (without quotes) in the only line.
Examples
Input
3
3 5
2 1
4 2
Output
Mishka
Input
2
6 1
1 6
Output
Friendship is magic!^^
Input
3
1 5
3 3
2 2
Output
Chris
Note
In the first sample case Mishka loses the first round, but wins second and third rounds and thus she is the winner of the game.
In the second sample case Mishka wins the first round, Chris wins the second round, and the game ends with draw with score 1:1.
In the third sample case Chris wins the first round, but there is no winner of the next two rounds. The winner of the game is Chris.
Submitted Solution:
```
b1 = 0
b2 = 0
for i in range(int(input())):
a, b = map(int, input().split())
if a > b:
b1 += 1
elif b > a:
b2 += 1
if b1 > b2:
print('Mishka')
elif b2 > b1:
print('Chris')
else:
print('Friendship is magic!^^')
```
Yes
| 92,227 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game.
Rules of the game are very simple: at first number of rounds n is defined. In every round each of the players throws a cubical dice with distinct numbers from 1 to 6 written on its faces. Player, whose value after throwing the dice is greater, wins the round. In case if player dice values are equal, no one of them is a winner.
In average, player, who won most of the rounds, is the winner of the game. In case if two players won the same number of rounds, the result of the game is draw.
Mishka is still very little and can't count wins and losses, so she asked you to watch their game and determine its result. Please help her!
Input
The first line of the input contains single integer n n (1 ≤ n ≤ 100) — the number of game rounds.
The next n lines contains rounds description. i-th of them contains pair of integers mi and ci (1 ≤ mi, ci ≤ 6) — values on dice upper face after Mishka's and Chris' throws in i-th round respectively.
Output
If Mishka is the winner of the game, print "Mishka" (without quotes) in the only line.
If Chris is the winner of the game, print "Chris" (without quotes) in the only line.
If the result of the game is draw, print "Friendship is magic!^^" (without quotes) in the only line.
Examples
Input
3
3 5
2 1
4 2
Output
Mishka
Input
2
6 1
1 6
Output
Friendship is magic!^^
Input
3
1 5
3 3
2 2
Output
Chris
Note
In the first sample case Mishka loses the first round, but wins second and third rounds and thus she is the winner of the game.
In the second sample case Mishka wins the first round, Chris wins the second round, and the game ends with draw with score 1:1.
In the third sample case Chris wins the first round, but there is no winner of the next two rounds. The winner of the game is Chris.
Submitted Solution:
```
mi = 0
ch = 0
for _ in range(int(input())):
m , c = [int(x) for x in input().split()]
if m > c:
mi += 1
elif m < c:
ch += 1
else:
mi += 1
ch += 1
if mi > ch:
print("Mishka")
elif mi < ch:
print("Chris")
else:
print("Friendship is magic!^^")
```
Yes
| 92,228 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game.
Rules of the game are very simple: at first number of rounds n is defined. In every round each of the players throws a cubical dice with distinct numbers from 1 to 6 written on its faces. Player, whose value after throwing the dice is greater, wins the round. In case if player dice values are equal, no one of them is a winner.
In average, player, who won most of the rounds, is the winner of the game. In case if two players won the same number of rounds, the result of the game is draw.
Mishka is still very little and can't count wins and losses, so she asked you to watch their game and determine its result. Please help her!
Input
The first line of the input contains single integer n n (1 ≤ n ≤ 100) — the number of game rounds.
The next n lines contains rounds description. i-th of them contains pair of integers mi and ci (1 ≤ mi, ci ≤ 6) — values on dice upper face after Mishka's and Chris' throws in i-th round respectively.
Output
If Mishka is the winner of the game, print "Mishka" (without quotes) in the only line.
If Chris is the winner of the game, print "Chris" (without quotes) in the only line.
If the result of the game is draw, print "Friendship is magic!^^" (without quotes) in the only line.
Examples
Input
3
3 5
2 1
4 2
Output
Mishka
Input
2
6 1
1 6
Output
Friendship is magic!^^
Input
3
1 5
3 3
2 2
Output
Chris
Note
In the first sample case Mishka loses the first round, but wins second and third rounds and thus she is the winner of the game.
In the second sample case Mishka wins the first round, Chris wins the second round, and the game ends with draw with score 1:1.
In the third sample case Chris wins the first round, but there is no winner of the next two rounds. The winner of the game is Chris.
Submitted Solution:
```
m,c=0,0
for _ in range(int(input())):
a,b=map(int,input().split())
if a!=b:
if a>b:
m+=1
else:
c+=1
if m>c:
print("Mishka")
elif m==c:
print("Friendship is magic!^^")
else:
print("Chris")
```
Yes
| 92,229 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game.
Rules of the game are very simple: at first number of rounds n is defined. In every round each of the players throws a cubical dice with distinct numbers from 1 to 6 written on its faces. Player, whose value after throwing the dice is greater, wins the round. In case if player dice values are equal, no one of them is a winner.
In average, player, who won most of the rounds, is the winner of the game. In case if two players won the same number of rounds, the result of the game is draw.
Mishka is still very little and can't count wins and losses, so she asked you to watch their game and determine its result. Please help her!
Input
The first line of the input contains single integer n n (1 ≤ n ≤ 100) — the number of game rounds.
The next n lines contains rounds description. i-th of them contains pair of integers mi and ci (1 ≤ mi, ci ≤ 6) — values on dice upper face after Mishka's and Chris' throws in i-th round respectively.
Output
If Mishka is the winner of the game, print "Mishka" (without quotes) in the only line.
If Chris is the winner of the game, print "Chris" (without quotes) in the only line.
If the result of the game is draw, print "Friendship is magic!^^" (without quotes) in the only line.
Examples
Input
3
3 5
2 1
4 2
Output
Mishka
Input
2
6 1
1 6
Output
Friendship is magic!^^
Input
3
1 5
3 3
2 2
Output
Chris
Note
In the first sample case Mishka loses the first round, but wins second and third rounds and thus she is the winner of the game.
In the second sample case Mishka wins the first round, Chris wins the second round, and the game ends with draw with score 1:1.
In the third sample case Chris wins the first round, but there is no winner of the next two rounds. The winner of the game is Chris.
Submitted Solution:
```
n = int(input())
a, b = 0, 0
for _ in range(n):
u, v = map(int, input().split())
if u > v:
a += 1
elif u < v:
b += 1
if a > b:
print('Mishka')
elif a < b:
print('Chris')
else:
print('Friendship is magic!^^')
```
Yes
| 92,230 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game.
Rules of the game are very simple: at first number of rounds n is defined. In every round each of the players throws a cubical dice with distinct numbers from 1 to 6 written on its faces. Player, whose value after throwing the dice is greater, wins the round. In case if player dice values are equal, no one of them is a winner.
In average, player, who won most of the rounds, is the winner of the game. In case if two players won the same number of rounds, the result of the game is draw.
Mishka is still very little and can't count wins and losses, so she asked you to watch their game and determine its result. Please help her!
Input
The first line of the input contains single integer n n (1 ≤ n ≤ 100) — the number of game rounds.
The next n lines contains rounds description. i-th of them contains pair of integers mi and ci (1 ≤ mi, ci ≤ 6) — values on dice upper face after Mishka's and Chris' throws in i-th round respectively.
Output
If Mishka is the winner of the game, print "Mishka" (without quotes) in the only line.
If Chris is the winner of the game, print "Chris" (without quotes) in the only line.
If the result of the game is draw, print "Friendship is magic!^^" (without quotes) in the only line.
Examples
Input
3
3 5
2 1
4 2
Output
Mishka
Input
2
6 1
1 6
Output
Friendship is magic!^^
Input
3
1 5
3 3
2 2
Output
Chris
Note
In the first sample case Mishka loses the first round, but wins second and third rounds and thus she is the winner of the game.
In the second sample case Mishka wins the first round, Chris wins the second round, and the game ends with draw with score 1:1.
In the third sample case Chris wins the first round, but there is no winner of the next two rounds. The winner of the game is Chris.
Submitted Solution:
```
n = int(input())
mishka = 0
chris = 0
for _ in range(n):
m, c = [int(x) for x in input().split()]
mishka += m
chris += c
if mishka > chris:
print('Mishka')
elif chris > mishka:
print('Chris')
else:
print('Friendship is magic!^^')
```
No
| 92,231 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game.
Rules of the game are very simple: at first number of rounds n is defined. In every round each of the players throws a cubical dice with distinct numbers from 1 to 6 written on its faces. Player, whose value after throwing the dice is greater, wins the round. In case if player dice values are equal, no one of them is a winner.
In average, player, who won most of the rounds, is the winner of the game. In case if two players won the same number of rounds, the result of the game is draw.
Mishka is still very little and can't count wins and losses, so she asked you to watch their game and determine its result. Please help her!
Input
The first line of the input contains single integer n n (1 ≤ n ≤ 100) — the number of game rounds.
The next n lines contains rounds description. i-th of them contains pair of integers mi and ci (1 ≤ mi, ci ≤ 6) — values on dice upper face after Mishka's and Chris' throws in i-th round respectively.
Output
If Mishka is the winner of the game, print "Mishka" (without quotes) in the only line.
If Chris is the winner of the game, print "Chris" (without quotes) in the only line.
If the result of the game is draw, print "Friendship is magic!^^" (without quotes) in the only line.
Examples
Input
3
3 5
2 1
4 2
Output
Mishka
Input
2
6 1
1 6
Output
Friendship is magic!^^
Input
3
1 5
3 3
2 2
Output
Chris
Note
In the first sample case Mishka loses the first round, but wins second and third rounds and thus she is the winner of the game.
In the second sample case Mishka wins the first round, Chris wins the second round, and the game ends with draw with score 1:1.
In the third sample case Chris wins the first round, but there is no winner of the next two rounds. The winner of the game is Chris.
Submitted Solution:
```
n = int(input())
m = 0
c = 0
for f in range(n):
a , b = map(int,input().split())
if a > b : m += 1
elif a < b : c += 1
if m > n : print("Mishka")
elif m < n : print("Chris")
else : print("Friendship")
```
No
| 92,232 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game.
Rules of the game are very simple: at first number of rounds n is defined. In every round each of the players throws a cubical dice with distinct numbers from 1 to 6 written on its faces. Player, whose value after throwing the dice is greater, wins the round. In case if player dice values are equal, no one of them is a winner.
In average, player, who won most of the rounds, is the winner of the game. In case if two players won the same number of rounds, the result of the game is draw.
Mishka is still very little and can't count wins and losses, so she asked you to watch their game and determine its result. Please help her!
Input
The first line of the input contains single integer n n (1 ≤ n ≤ 100) — the number of game rounds.
The next n lines contains rounds description. i-th of them contains pair of integers mi and ci (1 ≤ mi, ci ≤ 6) — values on dice upper face after Mishka's and Chris' throws in i-th round respectively.
Output
If Mishka is the winner of the game, print "Mishka" (without quotes) in the only line.
If Chris is the winner of the game, print "Chris" (without quotes) in the only line.
If the result of the game is draw, print "Friendship is magic!^^" (without quotes) in the only line.
Examples
Input
3
3 5
2 1
4 2
Output
Mishka
Input
2
6 1
1 6
Output
Friendship is magic!^^
Input
3
1 5
3 3
2 2
Output
Chris
Note
In the first sample case Mishka loses the first round, but wins second and third rounds and thus she is the winner of the game.
In the second sample case Mishka wins the first round, Chris wins the second round, and the game ends with draw with score 1:1.
In the third sample case Chris wins the first round, but there is no winner of the next two rounds. The winner of the game is Chris.
Submitted Solution:
```
m,c = 0,0
for _ in range(int(input())):
t1,t2 = map(int, input().split())
if t1 > t2:
m +=1
elif t1<t2:
c +=1
print(['Mishika', 'Chris'][m<c] if (m or c) else 'Friendship is magic!^^')
```
No
| 92,233 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game.
Rules of the game are very simple: at first number of rounds n is defined. In every round each of the players throws a cubical dice with distinct numbers from 1 to 6 written on its faces. Player, whose value after throwing the dice is greater, wins the round. In case if player dice values are equal, no one of them is a winner.
In average, player, who won most of the rounds, is the winner of the game. In case if two players won the same number of rounds, the result of the game is draw.
Mishka is still very little and can't count wins and losses, so she asked you to watch their game and determine its result. Please help her!
Input
The first line of the input contains single integer n n (1 ≤ n ≤ 100) — the number of game rounds.
The next n lines contains rounds description. i-th of them contains pair of integers mi and ci (1 ≤ mi, ci ≤ 6) — values on dice upper face after Mishka's and Chris' throws in i-th round respectively.
Output
If Mishka is the winner of the game, print "Mishka" (without quotes) in the only line.
If Chris is the winner of the game, print "Chris" (without quotes) in the only line.
If the result of the game is draw, print "Friendship is magic!^^" (without quotes) in the only line.
Examples
Input
3
3 5
2 1
4 2
Output
Mishka
Input
2
6 1
1 6
Output
Friendship is magic!^^
Input
3
1 5
3 3
2 2
Output
Chris
Note
In the first sample case Mishka loses the first round, but wins second and third rounds and thus she is the winner of the game.
In the second sample case Mishka wins the first round, Chris wins the second round, and the game ends with draw with score 1:1.
In the third sample case Chris wins the first round, but there is no winner of the next two rounds. The winner of the game is Chris.
Submitted Solution:
```
import sys
n = int(input())
mr = 0
cr = 0
for i in range(n):
m, c = map(int, sys.stdin.readline().split())
if m > c:
mr += 1
elif c > m:
mr += 1
if mr > cr:
print("Mishka")
elif cr > mr:
print("Chris")
else:
print("Friendship is magic!^^")
```
No
| 92,234 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a new version of the famous Pinball game, one of the most important parts of the game field is a sequence of n bumpers. The bumpers are numbered with integers from 1 to n from left to right. There are two types of bumpers. They are denoted by the characters '<' and '>'. When the ball hits the bumper at position i it goes one position to the right (to the position i + 1) if the type of this bumper is '>', or one position to the left (to i - 1) if the type of the bumper at position i is '<'. If there is no such position, in other words if i - 1 < 1 or i + 1 > n, the ball falls from the game field.
Depending on the ball's starting position, the ball may eventually fall from the game field or it may stay there forever. You are given a string representing the bumpers' types. Calculate the number of positions such that the ball will eventually fall from the game field if it starts at that position.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the sequence of bumpers. The second line contains the string, which consists of the characters '<' and '>'. The character at the i-th position of this string corresponds to the type of the i-th bumper.
Output
Print one integer — the number of positions in the sequence such that the ball will eventually fall from the game field if it starts at that position.
Examples
Input
4
<<><
Output
2
Input
5
>>>>>
Output
5
Input
4
>><<
Output
0
Note
In the first sample, the ball will fall from the field if starts at position 1 or position 2.
In the second sample, any starting position will result in the ball falling from the field.
Tags: implementation
Correct Solution:
```
n = int(input())
s = input()
s1 = 0
for i in s:
if i=="<":
s1+=1
else:
break
for i in range(n-1,-1,-1):
if s[i]==">":
s1+=1
else:
break
print(s1)
```
| 92,235 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a new version of the famous Pinball game, one of the most important parts of the game field is a sequence of n bumpers. The bumpers are numbered with integers from 1 to n from left to right. There are two types of bumpers. They are denoted by the characters '<' and '>'. When the ball hits the bumper at position i it goes one position to the right (to the position i + 1) if the type of this bumper is '>', or one position to the left (to i - 1) if the type of the bumper at position i is '<'. If there is no such position, in other words if i - 1 < 1 or i + 1 > n, the ball falls from the game field.
Depending on the ball's starting position, the ball may eventually fall from the game field or it may stay there forever. You are given a string representing the bumpers' types. Calculate the number of positions such that the ball will eventually fall from the game field if it starts at that position.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the sequence of bumpers. The second line contains the string, which consists of the characters '<' and '>'. The character at the i-th position of this string corresponds to the type of the i-th bumper.
Output
Print one integer — the number of positions in the sequence such that the ball will eventually fall from the game field if it starts at that position.
Examples
Input
4
<<><
Output
2
Input
5
>>>>>
Output
5
Input
4
>><<
Output
0
Note
In the first sample, the ball will fall from the field if starts at position 1 or position 2.
In the second sample, any starting position will result in the ball falling from the field.
Tags: implementation
Correct Solution:
```
input()
s = input()
n = len(s)
rs = 0
for i in range(n):
if s[i] == '<':
rs+=1
else:
break
for i in range(n - 1,-1,-1):
if s[i] =='>':
rs+=1
else:
break
print(rs)
```
| 92,236 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a new version of the famous Pinball game, one of the most important parts of the game field is a sequence of n bumpers. The bumpers are numbered with integers from 1 to n from left to right. There are two types of bumpers. They are denoted by the characters '<' and '>'. When the ball hits the bumper at position i it goes one position to the right (to the position i + 1) if the type of this bumper is '>', or one position to the left (to i - 1) if the type of the bumper at position i is '<'. If there is no such position, in other words if i - 1 < 1 or i + 1 > n, the ball falls from the game field.
Depending on the ball's starting position, the ball may eventually fall from the game field or it may stay there forever. You are given a string representing the bumpers' types. Calculate the number of positions such that the ball will eventually fall from the game field if it starts at that position.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the sequence of bumpers. The second line contains the string, which consists of the characters '<' and '>'. The character at the i-th position of this string corresponds to the type of the i-th bumper.
Output
Print one integer — the number of positions in the sequence such that the ball will eventually fall from the game field if it starts at that position.
Examples
Input
4
<<><
Output
2
Input
5
>>>>>
Output
5
Input
4
>><<
Output
0
Note
In the first sample, the ball will fall from the field if starts at position 1 or position 2.
In the second sample, any starting position will result in the ball falling from the field.
Tags: implementation
Correct Solution:
```
n = int(input())
s = input()
print(n - len(s.lstrip("<").rstrip(">")))
```
| 92,237 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a new version of the famous Pinball game, one of the most important parts of the game field is a sequence of n bumpers. The bumpers are numbered with integers from 1 to n from left to right. There are two types of bumpers. They are denoted by the characters '<' and '>'. When the ball hits the bumper at position i it goes one position to the right (to the position i + 1) if the type of this bumper is '>', or one position to the left (to i - 1) if the type of the bumper at position i is '<'. If there is no such position, in other words if i - 1 < 1 or i + 1 > n, the ball falls from the game field.
Depending on the ball's starting position, the ball may eventually fall from the game field or it may stay there forever. You are given a string representing the bumpers' types. Calculate the number of positions such that the ball will eventually fall from the game field if it starts at that position.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the sequence of bumpers. The second line contains the string, which consists of the characters '<' and '>'. The character at the i-th position of this string corresponds to the type of the i-th bumper.
Output
Print one integer — the number of positions in the sequence such that the ball will eventually fall from the game field if it starts at that position.
Examples
Input
4
<<><
Output
2
Input
5
>>>>>
Output
5
Input
4
>><<
Output
0
Note
In the first sample, the ball will fall from the field if starts at position 1 or position 2.
In the second sample, any starting position will result in the ball falling from the field.
Tags: implementation
Correct Solution:
```
if __name__ == "__main__":
nr_of_bumpers = int(input())
bumper_types = list(input())
fall_bumpers = 0
bumper_index = 0
while bumper_index < nr_of_bumpers and bumper_types[bumper_index] == '<':
fall_bumpers += 1
bumper_index += 1
bumper_index = nr_of_bumpers - 1
while bumper_index >= 0 and bumper_types[bumper_index] == '>':
fall_bumpers += 1
bumper_index -= 1
print(fall_bumpers)
```
| 92,238 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a new version of the famous Pinball game, one of the most important parts of the game field is a sequence of n bumpers. The bumpers are numbered with integers from 1 to n from left to right. There are two types of bumpers. They are denoted by the characters '<' and '>'. When the ball hits the bumper at position i it goes one position to the right (to the position i + 1) if the type of this bumper is '>', or one position to the left (to i - 1) if the type of the bumper at position i is '<'. If there is no such position, in other words if i - 1 < 1 or i + 1 > n, the ball falls from the game field.
Depending on the ball's starting position, the ball may eventually fall from the game field or it may stay there forever. You are given a string representing the bumpers' types. Calculate the number of positions such that the ball will eventually fall from the game field if it starts at that position.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the sequence of bumpers. The second line contains the string, which consists of the characters '<' and '>'. The character at the i-th position of this string corresponds to the type of the i-th bumper.
Output
Print one integer — the number of positions in the sequence such that the ball will eventually fall from the game field if it starts at that position.
Examples
Input
4
<<><
Output
2
Input
5
>>>>>
Output
5
Input
4
>><<
Output
0
Note
In the first sample, the ball will fall from the field if starts at position 1 or position 2.
In the second sample, any starting position will result in the ball falling from the field.
Tags: implementation
Correct Solution:
```
input()
s=input()
ans=0
for i in s:
if i=='<':ans+=1
else:break
for i in s[::-1]:
if i=='>':ans+=1
else:break
print(ans)
```
| 92,239 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a new version of the famous Pinball game, one of the most important parts of the game field is a sequence of n bumpers. The bumpers are numbered with integers from 1 to n from left to right. There are two types of bumpers. They are denoted by the characters '<' and '>'. When the ball hits the bumper at position i it goes one position to the right (to the position i + 1) if the type of this bumper is '>', or one position to the left (to i - 1) if the type of the bumper at position i is '<'. If there is no such position, in other words if i - 1 < 1 or i + 1 > n, the ball falls from the game field.
Depending on the ball's starting position, the ball may eventually fall from the game field or it may stay there forever. You are given a string representing the bumpers' types. Calculate the number of positions such that the ball will eventually fall from the game field if it starts at that position.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the sequence of bumpers. The second line contains the string, which consists of the characters '<' and '>'. The character at the i-th position of this string corresponds to the type of the i-th bumper.
Output
Print one integer — the number of positions in the sequence such that the ball will eventually fall from the game field if it starts at that position.
Examples
Input
4
<<><
Output
2
Input
5
>>>>>
Output
5
Input
4
>><<
Output
0
Note
In the first sample, the ball will fall from the field if starts at position 1 or position 2.
In the second sample, any starting position will result in the ball falling from the field.
Tags: implementation
Correct Solution:
```
import sys
import math
import bisect
def solve(s):
n = len(s)
ans = 0
for i in range(n):
if s[i] == '<':
ans += 1
else:
break
for i in range(n - 1, -1, -1):
if s[i] == '>':
ans += 1
else:
break
return ans
def main():
n = int(input())
s = input()
ans = solve(s)
print(ans)
if __name__ == "__main__":
main()
```
| 92,240 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a new version of the famous Pinball game, one of the most important parts of the game field is a sequence of n bumpers. The bumpers are numbered with integers from 1 to n from left to right. There are two types of bumpers. They are denoted by the characters '<' and '>'. When the ball hits the bumper at position i it goes one position to the right (to the position i + 1) if the type of this bumper is '>', or one position to the left (to i - 1) if the type of the bumper at position i is '<'. If there is no such position, in other words if i - 1 < 1 or i + 1 > n, the ball falls from the game field.
Depending on the ball's starting position, the ball may eventually fall from the game field or it may stay there forever. You are given a string representing the bumpers' types. Calculate the number of positions such that the ball will eventually fall from the game field if it starts at that position.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the sequence of bumpers. The second line contains the string, which consists of the characters '<' and '>'. The character at the i-th position of this string corresponds to the type of the i-th bumper.
Output
Print one integer — the number of positions in the sequence such that the ball will eventually fall from the game field if it starts at that position.
Examples
Input
4
<<><
Output
2
Input
5
>>>>>
Output
5
Input
4
>><<
Output
0
Note
In the first sample, the ball will fall from the field if starts at position 1 or position 2.
In the second sample, any starting position will result in the ball falling from the field.
Tags: implementation
Correct Solution:
```
n = int(input())
v = input()
count = 0
right = 0
left = 0
second = 0
for i in range(0,len(v)):
if v[i]=='<' and right==0:
count+=1
if v[i] == '<' and right == 1:
second = 0
if v[i]=='>' :
second+=1
right=1
print(max(count+second,0))
```
| 92,241 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a new version of the famous Pinball game, one of the most important parts of the game field is a sequence of n bumpers. The bumpers are numbered with integers from 1 to n from left to right. There are two types of bumpers. They are denoted by the characters '<' and '>'. When the ball hits the bumper at position i it goes one position to the right (to the position i + 1) if the type of this bumper is '>', or one position to the left (to i - 1) if the type of the bumper at position i is '<'. If there is no such position, in other words if i - 1 < 1 or i + 1 > n, the ball falls from the game field.
Depending on the ball's starting position, the ball may eventually fall from the game field or it may stay there forever. You are given a string representing the bumpers' types. Calculate the number of positions such that the ball will eventually fall from the game field if it starts at that position.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the sequence of bumpers. The second line contains the string, which consists of the characters '<' and '>'. The character at the i-th position of this string corresponds to the type of the i-th bumper.
Output
Print one integer — the number of positions in the sequence such that the ball will eventually fall from the game field if it starts at that position.
Examples
Input
4
<<><
Output
2
Input
5
>>>>>
Output
5
Input
4
>><<
Output
0
Note
In the first sample, the ball will fall from the field if starts at position 1 or position 2.
In the second sample, any starting position will result in the ball falling from the field.
Tags: implementation
Correct Solution:
```
n = int(input())
s = input()
i = 0
while i < n and s[i] == '<':
i += 1
ans = i
i = n - 1
while i >= 0 and s[i] == '>':
i -= 1
ans += n - 1 - i
print(ans)
```
| 92,242 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a new version of the famous Pinball game, one of the most important parts of the game field is a sequence of n bumpers. The bumpers are numbered with integers from 1 to n from left to right. There are two types of bumpers. They are denoted by the characters '<' and '>'. When the ball hits the bumper at position i it goes one position to the right (to the position i + 1) if the type of this bumper is '>', or one position to the left (to i - 1) if the type of the bumper at position i is '<'. If there is no such position, in other words if i - 1 < 1 or i + 1 > n, the ball falls from the game field.
Depending on the ball's starting position, the ball may eventually fall from the game field or it may stay there forever. You are given a string representing the bumpers' types. Calculate the number of positions such that the ball will eventually fall from the game field if it starts at that position.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the sequence of bumpers. The second line contains the string, which consists of the characters '<' and '>'. The character at the i-th position of this string corresponds to the type of the i-th bumper.
Output
Print one integer — the number of positions in the sequence such that the ball will eventually fall from the game field if it starts at that position.
Examples
Input
4
<<><
Output
2
Input
5
>>>>>
Output
5
Input
4
>><<
Output
0
Note
In the first sample, the ball will fall from the field if starts at position 1 or position 2.
In the second sample, any starting position will result in the ball falling from the field.
Submitted Solution:
```
'''input
6
<<><>>
'''
n = int(input())
s = input()
def solve():
off = 0
for i, c in enumerate(s):
if c == '>':
off = i
break
else:
return len(s)
for i, c in enumerate(reversed(s)):
if c == '<':
off += i
break
else:
return len(s)
return off
print(solve())
```
Yes
| 92,243 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a new version of the famous Pinball game, one of the most important parts of the game field is a sequence of n bumpers. The bumpers are numbered with integers from 1 to n from left to right. There are two types of bumpers. They are denoted by the characters '<' and '>'. When the ball hits the bumper at position i it goes one position to the right (to the position i + 1) if the type of this bumper is '>', or one position to the left (to i - 1) if the type of the bumper at position i is '<'. If there is no such position, in other words if i - 1 < 1 or i + 1 > n, the ball falls from the game field.
Depending on the ball's starting position, the ball may eventually fall from the game field or it may stay there forever. You are given a string representing the bumpers' types. Calculate the number of positions such that the ball will eventually fall from the game field if it starts at that position.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the sequence of bumpers. The second line contains the string, which consists of the characters '<' and '>'. The character at the i-th position of this string corresponds to the type of the i-th bumper.
Output
Print one integer — the number of positions in the sequence such that the ball will eventually fall from the game field if it starts at that position.
Examples
Input
4
<<><
Output
2
Input
5
>>>>>
Output
5
Input
4
>><<
Output
0
Note
In the first sample, the ball will fall from the field if starts at position 1 or position 2.
In the second sample, any starting position will result in the ball falling from the field.
Submitted Solution:
```
n = int(input());
s = input();
i = 0;
ans = 0;
while i < n and s[i] == "<":
ans += 1;
i += 1;
i = n - 1;
while i >= 0 and s[i] == ">":
ans += 1;
i -= 1;
print(ans);
```
Yes
| 92,244 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a new version of the famous Pinball game, one of the most important parts of the game field is a sequence of n bumpers. The bumpers are numbered with integers from 1 to n from left to right. There are two types of bumpers. They are denoted by the characters '<' and '>'. When the ball hits the bumper at position i it goes one position to the right (to the position i + 1) if the type of this bumper is '>', or one position to the left (to i - 1) if the type of the bumper at position i is '<'. If there is no such position, in other words if i - 1 < 1 or i + 1 > n, the ball falls from the game field.
Depending on the ball's starting position, the ball may eventually fall from the game field or it may stay there forever. You are given a string representing the bumpers' types. Calculate the number of positions such that the ball will eventually fall from the game field if it starts at that position.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the sequence of bumpers. The second line contains the string, which consists of the characters '<' and '>'. The character at the i-th position of this string corresponds to the type of the i-th bumper.
Output
Print one integer — the number of positions in the sequence such that the ball will eventually fall from the game field if it starts at that position.
Examples
Input
4
<<><
Output
2
Input
5
>>>>>
Output
5
Input
4
>><<
Output
0
Note
In the first sample, the ball will fall from the field if starts at position 1 or position 2.
In the second sample, any starting position will result in the ball falling from the field.
Submitted Solution:
```
from collections import deque
numLines = input()
bumperString = deque(input().strip())
numSolutions = 0
numPossibleSolutions = 0
lastBumper = '<'
foundBlackHole = False
while len(bumperString) > 0:
bumper = bumperString.popleft()
if bumper == '<':
if lastBumper == '<':
if foundBlackHole is False:
numSolutions += 1
elif lastBumper == '>':
numPossibleSolutions = 0
foundBlackHole = True
lastBumper = '<'
elif bumper == '>':
if lastBumper == '<':
numPossibleSolutions = 0 + numSolutions + 1
elif lastBumper == '>':
numPossibleSolutions += 1
lastBumper = '>'
if numPossibleSolutions > 0:
print(numPossibleSolutions)
else:
print(numSolutions)
```
Yes
| 92,245 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a new version of the famous Pinball game, one of the most important parts of the game field is a sequence of n bumpers. The bumpers are numbered with integers from 1 to n from left to right. There are two types of bumpers. They are denoted by the characters '<' and '>'. When the ball hits the bumper at position i it goes one position to the right (to the position i + 1) if the type of this bumper is '>', or one position to the left (to i - 1) if the type of the bumper at position i is '<'. If there is no such position, in other words if i - 1 < 1 or i + 1 > n, the ball falls from the game field.
Depending on the ball's starting position, the ball may eventually fall from the game field or it may stay there forever. You are given a string representing the bumpers' types. Calculate the number of positions such that the ball will eventually fall from the game field if it starts at that position.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the sequence of bumpers. The second line contains the string, which consists of the characters '<' and '>'. The character at the i-th position of this string corresponds to the type of the i-th bumper.
Output
Print one integer — the number of positions in the sequence such that the ball will eventually fall from the game field if it starts at that position.
Examples
Input
4
<<><
Output
2
Input
5
>>>>>
Output
5
Input
4
>><<
Output
0
Note
In the first sample, the ball will fall from the field if starts at position 1 or position 2.
In the second sample, any starting position will result in the ball falling from the field.
Submitted Solution:
```
a=input()
bumpers = input()
counter = 0
for i in range(len(bumpers)):
if bumpers[i]=='<':
counter+=1
else:
break
for i in range(1,len(bumpers)+1):
if bumpers[-i]=='>':
counter+=1
else:
break
print(counter)
```
Yes
| 92,246 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a new version of the famous Pinball game, one of the most important parts of the game field is a sequence of n bumpers. The bumpers are numbered with integers from 1 to n from left to right. There are two types of bumpers. They are denoted by the characters '<' and '>'. When the ball hits the bumper at position i it goes one position to the right (to the position i + 1) if the type of this bumper is '>', or one position to the left (to i - 1) if the type of the bumper at position i is '<'. If there is no such position, in other words if i - 1 < 1 or i + 1 > n, the ball falls from the game field.
Depending on the ball's starting position, the ball may eventually fall from the game field or it may stay there forever. You are given a string representing the bumpers' types. Calculate the number of positions such that the ball will eventually fall from the game field if it starts at that position.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the sequence of bumpers. The second line contains the string, which consists of the characters '<' and '>'. The character at the i-th position of this string corresponds to the type of the i-th bumper.
Output
Print one integer — the number of positions in the sequence such that the ball will eventually fall from the game field if it starts at that position.
Examples
Input
4
<<><
Output
2
Input
5
>>>>>
Output
5
Input
4
>><<
Output
0
Note
In the first sample, the ball will fall from the field if starts at position 1 or position 2.
In the second sample, any starting position will result in the ball falling from the field.
Submitted Solution:
```
n = int(input())
k = n
s = input()
i = 0
j = n - 1
while s[i] != ">" and i < n:
i+=1
n-= 1
while s[j] != "<" and j > -1:
j-=1
n-=1
print(k - n)
```
No
| 92,247 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a new version of the famous Pinball game, one of the most important parts of the game field is a sequence of n bumpers. The bumpers are numbered with integers from 1 to n from left to right. There are two types of bumpers. They are denoted by the characters '<' and '>'. When the ball hits the bumper at position i it goes one position to the right (to the position i + 1) if the type of this bumper is '>', or one position to the left (to i - 1) if the type of the bumper at position i is '<'. If there is no such position, in other words if i - 1 < 1 or i + 1 > n, the ball falls from the game field.
Depending on the ball's starting position, the ball may eventually fall from the game field or it may stay there forever. You are given a string representing the bumpers' types. Calculate the number of positions such that the ball will eventually fall from the game field if it starts at that position.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the sequence of bumpers. The second line contains the string, which consists of the characters '<' and '>'. The character at the i-th position of this string corresponds to the type of the i-th bumper.
Output
Print one integer — the number of positions in the sequence such that the ball will eventually fall from the game field if it starts at that position.
Examples
Input
4
<<><
Output
2
Input
5
>>>>>
Output
5
Input
4
>><<
Output
0
Note
In the first sample, the ball will fall from the field if starts at position 1 or position 2.
In the second sample, any starting position will result in the ball falling from the field.
Submitted Solution:
```
k=input()
s=input()
print(abs(s.count('<')-s.count('>')))
#this is the solution of this problem
```
No
| 92,248 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a new version of the famous Pinball game, one of the most important parts of the game field is a sequence of n bumpers. The bumpers are numbered with integers from 1 to n from left to right. There are two types of bumpers. They are denoted by the characters '<' and '>'. When the ball hits the bumper at position i it goes one position to the right (to the position i + 1) if the type of this bumper is '>', or one position to the left (to i - 1) if the type of the bumper at position i is '<'. If there is no such position, in other words if i - 1 < 1 or i + 1 > n, the ball falls from the game field.
Depending on the ball's starting position, the ball may eventually fall from the game field or it may stay there forever. You are given a string representing the bumpers' types. Calculate the number of positions such that the ball will eventually fall from the game field if it starts at that position.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the sequence of bumpers. The second line contains the string, which consists of the characters '<' and '>'. The character at the i-th position of this string corresponds to the type of the i-th bumper.
Output
Print one integer — the number of positions in the sequence such that the ball will eventually fall from the game field if it starts at that position.
Examples
Input
4
<<><
Output
2
Input
5
>>>>>
Output
5
Input
4
>><<
Output
0
Note
In the first sample, the ball will fall from the field if starts at position 1 or position 2.
In the second sample, any starting position will result in the ball falling from the field.
Submitted Solution:
```
n = int(input())
a = list(input())
b = []
for i in range(0,n):
if a[i] == '<':
if i == 0:
b.append(1)
else:
b.append(b[i-1])
else:
try:
x = b[i]
except:
if i == n-1:
b.append(0)
else:
if '<' not in b[i+1:]:
break
else:
ind = b[i+1:].index('<')
for j in range(ind):
b.append(0)
print(sum(b))
```
No
| 92,249 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a new version of the famous Pinball game, one of the most important parts of the game field is a sequence of n bumpers. The bumpers are numbered with integers from 1 to n from left to right. There are two types of bumpers. They are denoted by the characters '<' and '>'. When the ball hits the bumper at position i it goes one position to the right (to the position i + 1) if the type of this bumper is '>', or one position to the left (to i - 1) if the type of the bumper at position i is '<'. If there is no such position, in other words if i - 1 < 1 or i + 1 > n, the ball falls from the game field.
Depending on the ball's starting position, the ball may eventually fall from the game field or it may stay there forever. You are given a string representing the bumpers' types. Calculate the number of positions such that the ball will eventually fall from the game field if it starts at that position.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the sequence of bumpers. The second line contains the string, which consists of the characters '<' and '>'. The character at the i-th position of this string corresponds to the type of the i-th bumper.
Output
Print one integer — the number of positions in the sequence such that the ball will eventually fall from the game field if it starts at that position.
Examples
Input
4
<<><
Output
2
Input
5
>>>>>
Output
5
Input
4
>><<
Output
0
Note
In the first sample, the ball will fall from the field if starts at position 1 or position 2.
In the second sample, any starting position will result in the ball falling from the field.
Submitted Solution:
```
from sys import stdin
def solve(bumpers):
left = 0
right = 0
for bumper in bumpers:
if bumper == '<':
if right == 0:
left += 1
else:
right -= 1
else:
if left == 0:
right += 1
else:
left -= 1
return right + left
if __name__ == "__main__":
if True:
next(stdin)
print(str(solve(next(stdin).strip("\r\n"))))
else:
bumpers = [
"<<><",
">>>>>",
">><<"
]
for test_word in bumpers:
print(str(solve(test_word)))
```
No
| 92,250 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Tags: brute force, math
Correct Solution:
```
from math import sqrt
def div(n):
i = 1
list = []
while i <= n:
if n % i == 0:
list.append(i)
i = i + 1
return list
n=int(input())
root=sqrt(n)
divs=div(n)
#print(divs)
listy=[abs(root-x) for x in divs]
min_index=listy.index(min(listy))
print("{} {}".format(int(divs[min_index]),int(n/divs[min_index])))
```
| 92,251 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Tags: brute force, math
Correct Solution:
```
n = int(input())
for i in range(1,n+1):
if (n%i==0):
if (i>n//i):
break
a= i
b= n//i
print(a, b)
```
| 92,252 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Tags: brute force, math
Correct Solution:
```
n = int(input())
res = 1
for i in range(2, int(n**0.5)+1):
if n%i == 0:
res = i
print(res, n//res)
```
| 92,253 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Tags: brute force, math
Correct Solution:
```
from math import sqrt
n=int(input())
q=int(sqrt(n))
k=t=1
for i in range(1,q+1):
if n%i==0:
t=i
k=max(k,t)
print(k,n//k)
```
| 92,254 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Tags: brute force, math
Correct Solution:
```
def isPrime(n):
if(n<=2):
return 1
for i in range(2,n):
if(n%i==0):
return 0
return 1
n=int(input().strip())
s=n**0.5
if(isPrime(n)):
print(1,n)
elif(s==int(s)):
print(int(s),int(s))
else:
s=int(s)
# print(s)
for i in range(s,n//2 + 1):
if(n%i==0):
print(int(min(n//i,i)),int(max(n//i,i)))
break
```
| 92,255 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Tags: brute force, math
Correct Solution:
```
n = int(input())
res = 10000000
a = 0
b = 0
i = 1
while i * i <= n:
if n % i == 0:
a = i
b = n // i
i += 1
print(a, b)
```
| 92,256 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Tags: brute force, math
Correct Solution:
```
import sys
noOfPixels = int(input())
if noOfPixels == 1:
print("1 1")
else:
row=1
mini = sys.maxsize
ans = []
while True:
if noOfPixels%row==0:
col = noOfPixels//row
if row > col:
break
mini = min(mini,(col-row))
ans[:] = []
ans.append(row)
ans.append(col)
row = row+1
print(ans[0],ans[1])
```
| 92,257 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Tags: brute force, math
Correct Solution:
```
num = int(input())
mn = float("inf")
ans = []
for i in range(1, int(num**0.5)+1):
if num % i == 0:
ans = [i, num//i]
print(*ans)
```
| 92,258 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Submitted Solution:
```
#!/bin/python3
# challenge-url: http://codeforces.com/contest/747/problem/A
# username: hudson
# n: number of pixels
# a: number of rows of pixels
# b: number of pixel columns
import math
n = int(input())
div = int( math.sqrt(n) )
while n % div != 0 and div != 1:
div -= 1
print( div, n // div)
```
Yes
| 92,259 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Submitted Solution:
```
n = int(input())
a = 1
b = n
for i in range(2, int(n**.5)+1):
if n % i == 0:
a = i
b = n//i
print(a,b)
```
Yes
| 92,260 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Submitted Solution:
```
n=int(input())
b,a=n,1
while(b>0 and b>=int(n/b)):
if(n%b==0):
small=b
b-=1
print(int(n/small),small)
```
Yes
| 92,261 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Submitted Solution:
```
n=int(input())
a=1
for i in range(2,int(n**0.5)+2):
if n%i==0:
a=i
print(min(a,n//a),max(a,n//a))
```
Yes
| 92,262 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Submitted Solution:
```
import math
n = int(input())
for i in range(math.ceil(math.sqrt(n)), 0, -1):
if n % i == 0:
print(str(i) + " " + str(int(n/i)))
break
```
No
| 92,263 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Submitted Solution:
```
import math
n=int(input())
a=1
b=n
sq=math.sqrt(n)
sq=int(sq)
for i in range (sq+1, 1, -1):
if n%i==0:
a=i
b=n/i
break
b=int(b)
a=int(a)
print(a,b)
```
No
| 92,264 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Submitted Solution:
```
n = int(input())
def rows_columns(num):
lis = []
for i in range(1, num+1):
if num%i == 0:
lis.append(i)
size = len(lis)
mid = size//2
if size%2 == 0:
return lis[mid-1], lis[mid]
else:
return lis[mid-1], lis[mid+1]
a, b = rows_columns(n)
```
No
| 92,265 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A big company decided to launch a new series of rectangular displays, and decided that the display must have exactly n pixels.
Your task is to determine the size of the rectangular display — the number of lines (rows) of pixels a and the number of columns of pixels b, so that:
* there are exactly n pixels on the display;
* the number of rows does not exceed the number of columns, it means a ≤ b;
* the difference b - a is as small as possible.
Input
The first line contains the positive integer n (1 ≤ n ≤ 106) — the number of pixels display should have.
Output
Print two integers — the number of rows and columns on the display.
Examples
Input
8
Output
2 4
Input
64
Output
8 8
Input
5
Output
1 5
Input
999999
Output
999 1001
Note
In the first example the minimum possible difference equals 2, so on the display should be 2 rows of 4 pixels.
In the second example the minimum possible difference equals 0, so on the display should be 8 rows of 8 pixels.
In the third example the minimum possible difference equals 4, so on the display should be 1 row of 5 pixels.
Submitted Solution:
```
n = int(input())
for i in range(int(n ** .5), 1, -1):
if n == 5:
exit(print(1, 5))
if n == 1:
exit(print(1, 1))
if n % i == 0:
exit(print(i, n // i))
# هوفففف
# خیلی نگران بودم
# امیدوارم اوکی بشه
# استرس همراه با نگرانی چیز عجیبیه
# k0P MzMMSFp
```
No
| 92,266 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bitwise exclusive OR (or bitwise addition modulo two) is a binary operation which is equivalent to applying logical exclusive OR to every pair of bits located on the same positions in binary notation of operands. In other words, a binary digit of the result is equal to 1 if and only if bits on the respective positions in the operands are different.
For example, if X = 10910 = 11011012, Y = 4110 = 1010012, then:
X xor Y = 6810 = 10001002.
Write a program, which takes two non-negative integers A and B as an input and finds two non-negative integers X and Y, which satisfy the following conditions:
* A = X + Y
* B = X xor Y, where xor is bitwise exclusive or.
* X is the smallest number among all numbers for which the first two conditions are true.
Input
The first line contains integer number A and the second line contains integer number B (0 ≤ A, B ≤ 264 - 1).
Output
The only output line should contain two integer non-negative numbers X and Y. Print the only number -1 if there is no answer.
Examples
Input
142
76
Output
33 109
Tags: dp, greedy, math
Correct Solution:
```
a=int(input())
b=int(input())
if(a>=b):
if((a-b)%2==1):
print(-1)
exit(0)
f=b
s=(a-b)//2
t=s
if((f^s)==f+s):
print(t,end=" ")
print(f+s)
exit(0)
if((f^t)==f+t):
print(s,end=" ")
print(f+t)
exit(0)
if((t^s)==t+s):
print(f,end=" ")
print(t+s)
exit(0)
print(-1)
```
| 92,267 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bitwise exclusive OR (or bitwise addition modulo two) is a binary operation which is equivalent to applying logical exclusive OR to every pair of bits located on the same positions in binary notation of operands. In other words, a binary digit of the result is equal to 1 if and only if bits on the respective positions in the operands are different.
For example, if X = 10910 = 11011012, Y = 4110 = 1010012, then:
X xor Y = 6810 = 10001002.
Write a program, which takes two non-negative integers A and B as an input and finds two non-negative integers X and Y, which satisfy the following conditions:
* A = X + Y
* B = X xor Y, where xor is bitwise exclusive or.
* X is the smallest number among all numbers for which the first two conditions are true.
Input
The first line contains integer number A and the second line contains integer number B (0 ≤ A, B ≤ 264 - 1).
Output
The only output line should contain two integer non-negative numbers X and Y. Print the only number -1 if there is no answer.
Examples
Input
142
76
Output
33 109
Tags: dp, greedy, math
Correct Solution:
```
A = int(input())
B = int(input())
x = (A - B)//2
y = x ^ B
if x + y == A and x ^ y == B:
print(x,y)
else:
print(-1)
```
| 92,268 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bitwise exclusive OR (or bitwise addition modulo two) is a binary operation which is equivalent to applying logical exclusive OR to every pair of bits located on the same positions in binary notation of operands. In other words, a binary digit of the result is equal to 1 if and only if bits on the respective positions in the operands are different.
For example, if X = 10910 = 11011012, Y = 4110 = 1010012, then:
X xor Y = 6810 = 10001002.
Write a program, which takes two non-negative integers A and B as an input and finds two non-negative integers X and Y, which satisfy the following conditions:
* A = X + Y
* B = X xor Y, where xor is bitwise exclusive or.
* X is the smallest number among all numbers for which the first two conditions are true.
Input
The first line contains integer number A and the second line contains integer number B (0 ≤ A, B ≤ 264 - 1).
Output
The only output line should contain two integer non-negative numbers X and Y. Print the only number -1 if there is no answer.
Examples
Input
142
76
Output
33 109
Tags: dp, greedy, math
Correct Solution:
```
A = int(input())
B = int(input())
if A < B:
print(-1)
else:
v = A - B
if v%2 :
print(-1)
else:
v //=2
if B&v:
print(-1)
else:
print(f'{v} {v+B}')
```
| 92,269 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bitwise exclusive OR (or bitwise addition modulo two) is a binary operation which is equivalent to applying logical exclusive OR to every pair of bits located on the same positions in binary notation of operands. In other words, a binary digit of the result is equal to 1 if and only if bits on the respective positions in the operands are different.
For example, if X = 10910 = 11011012, Y = 4110 = 1010012, then:
X xor Y = 6810 = 10001002.
Write a program, which takes two non-negative integers A and B as an input and finds two non-negative integers X and Y, which satisfy the following conditions:
* A = X + Y
* B = X xor Y, where xor is bitwise exclusive or.
* X is the smallest number among all numbers for which the first two conditions are true.
Input
The first line contains integer number A and the second line contains integer number B (0 ≤ A, B ≤ 264 - 1).
Output
The only output line should contain two integer non-negative numbers X and Y. Print the only number -1 if there is no answer.
Examples
Input
142
76
Output
33 109
Tags: dp, greedy, math
Correct Solution:
```
a, b = int(input()), int(input())
x, y = (a - b) >> 1, (a - b) // 2 + b
if a < b or (a + b) & 1 or x & (a - x) != x:
print("-1")
else: print(x, y)
```
| 92,270 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bitwise exclusive OR (or bitwise addition modulo two) is a binary operation which is equivalent to applying logical exclusive OR to every pair of bits located on the same positions in binary notation of operands. In other words, a binary digit of the result is equal to 1 if and only if bits on the respective positions in the operands are different.
For example, if X = 10910 = 11011012, Y = 4110 = 1010012, then:
X xor Y = 6810 = 10001002.
Write a program, which takes two non-negative integers A and B as an input and finds two non-negative integers X and Y, which satisfy the following conditions:
* A = X + Y
* B = X xor Y, where xor is bitwise exclusive or.
* X is the smallest number among all numbers for which the first two conditions are true.
Input
The first line contains integer number A and the second line contains integer number B (0 ≤ A, B ≤ 264 - 1).
Output
The only output line should contain two integer non-negative numbers X and Y. Print the only number -1 if there is no answer.
Examples
Input
142
76
Output
33 109
Tags: dp, greedy, math
Correct Solution:
```
_a = int(input())
_b = int(input())
A = bin(_a)[2:]
B = bin(_b)[2:]
if len(A) < len(B):
A,B = B,A
B = "0"*(len(A) - len(B)) + B
X = ""
Y = ""
need_carry = False
for a,b in zip(A,B):
if a + b == "11":
X += "0"
Y += "1"
elif a + b == "10":
if need_carry:
X += "1"
Y += "1"
need_carry = True
else:
X += "0"
Y += "0"
need_carry = True
elif a + b == "01":
X += "0"
Y += "1"
elif a + b == "00":
if need_carry:
X += "1"
Y += "1"
need_carry = False
else:
X += "0"
Y += "0"
need_carry = False
x = int(X, base=2)
y = int(Y, base=2)
if x+y == _a and x^y == _b:
print (x,y)
else:
print ("-1")
```
| 92,271 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bitwise exclusive OR (or bitwise addition modulo two) is a binary operation which is equivalent to applying logical exclusive OR to every pair of bits located on the same positions in binary notation of operands. In other words, a binary digit of the result is equal to 1 if and only if bits on the respective positions in the operands are different.
For example, if X = 10910 = 11011012, Y = 4110 = 1010012, then:
X xor Y = 6810 = 10001002.
Write a program, which takes two non-negative integers A and B as an input and finds two non-negative integers X and Y, which satisfy the following conditions:
* A = X + Y
* B = X xor Y, where xor is bitwise exclusive or.
* X is the smallest number among all numbers for which the first two conditions are true.
Input
The first line contains integer number A and the second line contains integer number B (0 ≤ A, B ≤ 264 - 1).
Output
The only output line should contain two integer non-negative numbers X and Y. Print the only number -1 if there is no answer.
Examples
Input
142
76
Output
33 109
Tags: dp, greedy, math
Correct Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
from collections import defaultdict
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")
#-------------------game starts now-----------------------------------------------------
a=int(input())
b=int(input())
x=(a-b)//2
y=x+b
if a<b or a%2!=b%2 or x&(a-x)!=x:
print(-1)
else:
print(x,y)
```
| 92,272 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bitwise exclusive OR (or bitwise addition modulo two) is a binary operation which is equivalent to applying logical exclusive OR to every pair of bits located on the same positions in binary notation of operands. In other words, a binary digit of the result is equal to 1 if and only if bits on the respective positions in the operands are different.
For example, if X = 10910 = 11011012, Y = 4110 = 1010012, then:
X xor Y = 6810 = 10001002.
Write a program, which takes two non-negative integers A and B as an input and finds two non-negative integers X and Y, which satisfy the following conditions:
* A = X + Y
* B = X xor Y, where xor is bitwise exclusive or.
* X is the smallest number among all numbers for which the first two conditions are true.
Input
The first line contains integer number A and the second line contains integer number B (0 ≤ A, B ≤ 264 - 1).
Output
The only output line should contain two integer non-negative numbers X and Y. Print the only number -1 if there is no answer.
Examples
Input
142
76
Output
33 109
Tags: dp, greedy, math
Correct Solution:
```
A, B = int(input()), int(input())
if A < B:
print(-1)
X = (A - B) // 2
Y = X + B
if X + Y != A or X^Y != B:
print(-1)
else:
print(X, Y)
```
| 92,273 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bitwise exclusive OR (or bitwise addition modulo two) is a binary operation which is equivalent to applying logical exclusive OR to every pair of bits located on the same positions in binary notation of operands. In other words, a binary digit of the result is equal to 1 if and only if bits on the respective positions in the operands are different.
For example, if X = 10910 = 11011012, Y = 4110 = 1010012, then:
X xor Y = 6810 = 10001002.
Write a program, which takes two non-negative integers A and B as an input and finds two non-negative integers X and Y, which satisfy the following conditions:
* A = X + Y
* B = X xor Y, where xor is bitwise exclusive or.
* X is the smallest number among all numbers for which the first two conditions are true.
Input
The first line contains integer number A and the second line contains integer number B (0 ≤ A, B ≤ 264 - 1).
Output
The only output line should contain two integer non-negative numbers X and Y. Print the only number -1 if there is no answer.
Examples
Input
142
76
Output
33 109
Tags: dp, greedy, math
Correct Solution:
```
A, B = int(input()), int(input())
#print(*[(A - B) // 2, (A + B) // 2] if A >= B and (A - B) % 2 == 0 else -1)
if A >= B and (A - B) % 2 == 0:
print((A - B) // 2, (A + B) // 2)
else:
print(-1)
```
| 92,274 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bitwise exclusive OR (or bitwise addition modulo two) is a binary operation which is equivalent to applying logical exclusive OR to every pair of bits located on the same positions in binary notation of operands. In other words, a binary digit of the result is equal to 1 if and only if bits on the respective positions in the operands are different.
For example, if X = 10910 = 11011012, Y = 4110 = 1010012, then:
X xor Y = 6810 = 10001002.
Write a program, which takes two non-negative integers A and B as an input and finds two non-negative integers X and Y, which satisfy the following conditions:
* A = X + Y
* B = X xor Y, where xor is bitwise exclusive or.
* X is the smallest number among all numbers for which the first two conditions are true.
Input
The first line contains integer number A and the second line contains integer number B (0 ≤ A, B ≤ 264 - 1).
Output
The only output line should contain two integer non-negative numbers X and Y. Print the only number -1 if there is no answer.
Examples
Input
142
76
Output
33 109
Submitted Solution:
```
a = int(input())
b = int(input())
if (a+b)%2!=0:
print(-1)
else:
print((a-b)//2 , (a+b)//2)
```
Yes
| 92,275 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bitwise exclusive OR (or bitwise addition modulo two) is a binary operation which is equivalent to applying logical exclusive OR to every pair of bits located on the same positions in binary notation of operands. In other words, a binary digit of the result is equal to 1 if and only if bits on the respective positions in the operands are different.
For example, if X = 10910 = 11011012, Y = 4110 = 1010012, then:
X xor Y = 6810 = 10001002.
Write a program, which takes two non-negative integers A and B as an input and finds two non-negative integers X and Y, which satisfy the following conditions:
* A = X + Y
* B = X xor Y, where xor is bitwise exclusive or.
* X is the smallest number among all numbers for which the first two conditions are true.
Input
The first line contains integer number A and the second line contains integer number B (0 ≤ A, B ≤ 264 - 1).
Output
The only output line should contain two integer non-negative numbers X and Y. Print the only number -1 if there is no answer.
Examples
Input
142
76
Output
33 109
Submitted Solution:
```
a = int(input())
b = int(input())
if (a - b) % 2 == 1:
print("-1")
exit(0)
x = (a - b) // 2
y = a - x
print(x, y)
```
Yes
| 92,276 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bitwise exclusive OR (or bitwise addition modulo two) is a binary operation which is equivalent to applying logical exclusive OR to every pair of bits located on the same positions in binary notation of operands. In other words, a binary digit of the result is equal to 1 if and only if bits on the respective positions in the operands are different.
For example, if X = 10910 = 11011012, Y = 4110 = 1010012, then:
X xor Y = 6810 = 10001002.
Write a program, which takes two non-negative integers A and B as an input and finds two non-negative integers X and Y, which satisfy the following conditions:
* A = X + Y
* B = X xor Y, where xor is bitwise exclusive or.
* X is the smallest number among all numbers for which the first two conditions are true.
Input
The first line contains integer number A and the second line contains integer number B (0 ≤ A, B ≤ 264 - 1).
Output
The only output line should contain two integer non-negative numbers X and Y. Print the only number -1 if there is no answer.
Examples
Input
142
76
Output
33 109
Submitted Solution:
```
a = int(input())
b = int(input())
if (a - b) % 2 == 1:
print("-1")
exit(0)
x = (a - b) // 2
y = a - x
print(x, y)
# Made By Mostafa_Khaled
```
Yes
| 92,277 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bitwise exclusive OR (or bitwise addition modulo two) is a binary operation which is equivalent to applying logical exclusive OR to every pair of bits located on the same positions in binary notation of operands. In other words, a binary digit of the result is equal to 1 if and only if bits on the respective positions in the operands are different.
For example, if X = 10910 = 11011012, Y = 4110 = 1010012, then:
X xor Y = 6810 = 10001002.
Write a program, which takes two non-negative integers A and B as an input and finds two non-negative integers X and Y, which satisfy the following conditions:
* A = X + Y
* B = X xor Y, where xor is bitwise exclusive or.
* X is the smallest number among all numbers for which the first two conditions are true.
Input
The first line contains integer number A and the second line contains integer number B (0 ≤ A, B ≤ 264 - 1).
Output
The only output line should contain two integer non-negative numbers X and Y. Print the only number -1 if there is no answer.
Examples
Input
142
76
Output
33 109
Submitted Solution:
```
import math
from collections import defaultdict
from sys import stdin
R = lambda: map(int, stdin.readline().split())
a, b = int(input()), int(input())
dp = [[[0, 0] for j in range(2)] for i in range(70)]
dp[0][0][0] = dp[0][1][0] = 1
trace = defaultdict(tuple)
for i in range(65):
ai, bi = (a >> i & 1), (b >> i & 1)
for bt in range(2):
for cy in range(2):
if dp[i][bt][cy]:
if ai == ((bi ^ bt & 1) + bt + cy) & 1:
ncy = ((bi ^ bt & 1) + bt + cy) >> 1 & 1
dp[i + 1][0][ncy] = dp[i + 1][1][ncy] = 1
trace[tuple((i + 1, 0, ncy))] = trace[tuple((i + 1, 1, ncy))] = tuple((i, bt, cy))
else:
dp[i][bt][cy] = 0
cur = tuple((64, 0, 0)) if dp[64][0][0] else tuple((64, 1, 0)) if dp[64][1][0] else 0
if not cur:
print(-1)
else:
res = 0
while cur:
res = (cur[1] << cur[0]) | res
cur = trace[cur]
print(min(res, a - res), max(res, a - res), sep=' ')
```
Yes
| 92,278 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bitwise exclusive OR (or bitwise addition modulo two) is a binary operation which is equivalent to applying logical exclusive OR to every pair of bits located on the same positions in binary notation of operands. In other words, a binary digit of the result is equal to 1 if and only if bits on the respective positions in the operands are different.
For example, if X = 10910 = 11011012, Y = 4110 = 1010012, then:
X xor Y = 6810 = 10001002.
Write a program, which takes two non-negative integers A and B as an input and finds two non-negative integers X and Y, which satisfy the following conditions:
* A = X + Y
* B = X xor Y, where xor is bitwise exclusive or.
* X is the smallest number among all numbers for which the first two conditions are true.
Input
The first line contains integer number A and the second line contains integer number B (0 ≤ A, B ≤ 264 - 1).
Output
The only output line should contain two integer non-negative numbers X and Y. Print the only number -1 if there is no answer.
Examples
Input
142
76
Output
33 109
Submitted Solution:
```
def xor(a,b,y):
if y^a == b:
return 1
return 0
def find(x,y):
for i in range(x//2):
if xor(i,x-i,y):
return i
return -1
x = int(input())
y = int(input())
k = find(x,y)
if k !=-1:
print(k,x-k)
else:
print(-1)
```
No
| 92,279 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bitwise exclusive OR (or bitwise addition modulo two) is a binary operation which is equivalent to applying logical exclusive OR to every pair of bits located on the same positions in binary notation of operands. In other words, a binary digit of the result is equal to 1 if and only if bits on the respective positions in the operands are different.
For example, if X = 10910 = 11011012, Y = 4110 = 1010012, then:
X xor Y = 6810 = 10001002.
Write a program, which takes two non-negative integers A and B as an input and finds two non-negative integers X and Y, which satisfy the following conditions:
* A = X + Y
* B = X xor Y, where xor is bitwise exclusive or.
* X is the smallest number among all numbers for which the first two conditions are true.
Input
The first line contains integer number A and the second line contains integer number B (0 ≤ A, B ≤ 264 - 1).
Output
The only output line should contain two integer non-negative numbers X and Y. Print the only number -1 if there is no answer.
Examples
Input
142
76
Output
33 109
Submitted Solution:
```
import math
R = lambda: map(int, input().split())
a = int(input())
b = int(input())
dp = [[-1] * 4 for i in range(66)]
dp[-1][0] = dp[-1][1] = 0
for i in range(64):
if (a >> i & 1) == 0 and (b >> i & 1) == 0:
dp[i][0] = 0 if dp[i - 1][0] >= 0 else (1 if dp[i - 1][1] else -1)
dp[i][3] = 0 if dp[i - 1][0] >= 0 else (1 if dp[i - 1][1] else -1)
elif (a >> i & 1) == 1 and (b >> i & 1) == 1:
dp[i][0] = 0 if dp[i - 1][0] >= 0 else (1 if dp[i - 1][1] else -1)
dp[i][1] = 0 if dp[i - 1][0] >= 0 else (1 if dp[i - 1][1] else -1)
elif (a >> i & 1) == 0 and (b >> i & 1) == 1:
dp[i][2] = 2 if dp[i - 1][2] >= 0 else (3 if dp[i - 1][3] else -1)
dp[i][3] = 2 if dp[i - 1][2] >= 0 else (3 if dp[i - 1][3] else -1)
else:
dp[i][0] = 2 if dp[i - 1][2] >= 0 else (3 if dp[i - 1][3] else -1)
dp[i][3] = 2 if dp[i - 1][2] >= 0 else (3 if dp[i - 1][3] else -1)
if dp[63][0] < 0 and dp[63][1] < 0:
print(-1)
exit(0)
nxt = 0 if dp[63][0] >= 0 else 1
res = 0
for i in range(63, -1, -1):
res = nxt & 1 << i | res
nxt = dp[i][nxt]
x, y = min(res, a - res), max(res, a - res)
if x + y == a and x ^ y == b:
print(x, y, sep=' ')
else:
print(-1)
```
No
| 92,280 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bitwise exclusive OR (or bitwise addition modulo two) is a binary operation which is equivalent to applying logical exclusive OR to every pair of bits located on the same positions in binary notation of operands. In other words, a binary digit of the result is equal to 1 if and only if bits on the respective positions in the operands are different.
For example, if X = 10910 = 11011012, Y = 4110 = 1010012, then:
X xor Y = 6810 = 10001002.
Write a program, which takes two non-negative integers A and B as an input and finds two non-negative integers X and Y, which satisfy the following conditions:
* A = X + Y
* B = X xor Y, where xor is bitwise exclusive or.
* X is the smallest number among all numbers for which the first two conditions are true.
Input
The first line contains integer number A and the second line contains integer number B (0 ≤ A, B ≤ 264 - 1).
Output
The only output line should contain two integer non-negative numbers X and Y. Print the only number -1 if there is no answer.
Examples
Input
142
76
Output
33 109
Submitted Solution:
```
x = int(input())
y = int(input())
if (y - x) % 2 == 0:
print((y - x) // 2, (x + y) // 2, sep=' ', end='\n')
else:
print(-1)
```
No
| 92,281 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bitwise exclusive OR (or bitwise addition modulo two) is a binary operation which is equivalent to applying logical exclusive OR to every pair of bits located on the same positions in binary notation of operands. In other words, a binary digit of the result is equal to 1 if and only if bits on the respective positions in the operands are different.
For example, if X = 10910 = 11011012, Y = 4110 = 1010012, then:
X xor Y = 6810 = 10001002.
Write a program, which takes two non-negative integers A and B as an input and finds two non-negative integers X and Y, which satisfy the following conditions:
* A = X + Y
* B = X xor Y, where xor is bitwise exclusive or.
* X is the smallest number among all numbers for which the first two conditions are true.
Input
The first line contains integer number A and the second line contains integer number B (0 ≤ A, B ≤ 264 - 1).
Output
The only output line should contain two integer non-negative numbers X and Y. Print the only number -1 if there is no answer.
Examples
Input
142
76
Output
33 109
Submitted Solution:
```
# bsdk idhar kya dekhne ko aaya hai, khud kr!!!
# import math
# from itertools import *
# import random
# import calendar
# import datetime
# import webbrowser
a = int(input())
b = int(input())
for i in range(1, a):
flag = 0
for j in range(1, a - i):
if i + j == a and i ^ j == b:
print(i, j)
flag = 1
break
if flag == 1:
break
else:
print(-1)
```
No
| 92,282 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A robber has attempted to rob a bank but failed to complete his task. However, he had managed to open all the safes.
Oleg the bank client loves money (who doesn't), and decides to take advantage of this failed robbery and steal some money from the safes. There are many safes arranged in a line, where the i-th safe from the left is called safe i. There are n banknotes left in all the safes in total. The i-th banknote is in safe xi. Oleg is now at safe a. There are two security guards, one of which guards the safe b such that b < a, i.e. the first guard is to the left of Oleg. The other guard guards the safe c so that c > a, i.e. he is to the right of Oleg.
The two guards are very lazy, so they do not move. In every second, Oleg can either take all the banknotes from the current safe or move to any of the neighboring safes. However, he cannot visit any safe that is guarded by security guards at any time, becaues he might be charged for stealing. Determine the maximum amount of banknotes Oleg can gather.
Input
The first line of input contains three space-separated integers, a, b and c (1 ≤ b < a < c ≤ 109), denoting the positions of Oleg, the first security guard and the second security guard, respectively.
The next line of input contains a single integer n (1 ≤ n ≤ 105), denoting the number of banknotes.
The next line of input contains n space-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 109), denoting that the i-th banknote is located in the xi-th safe. Note that xi are not guaranteed to be distinct.
Output
Output a single integer: the maximum number of banknotes Oleg can take.
Examples
Input
5 3 7
8
4 7 5 5 3 6 2 8
Output
4
Input
6 5 7
5
1 5 7 92 3
Output
0
Note
In the first example Oleg can take the banknotes in positions 4, 5, 6 (note that there are 2 banknotes at position 5). Oleg can't take the banknotes in safes 7 and 8 because he can't run into the second security guard. Similarly, Oleg cannot take the banknotes at positions 3 and 2 because he can't run into the first security guard. Thus, he can take a maximum of 4 banknotes.
For the second sample, Oleg can't take any banknotes without bumping into any of the security guards.
Tags: brute force, implementation
Correct Solution:
```
class CodeforcesTask794ASolution:
def __init__(self):
self.result = ''
self.a_b_c = []
self.n = 0
self.banknotes = []
def read_input(self):
self.a_b_c = [int(x) for x in input().split(" ")]
self.n = int(input())
self.banknotes = [int(x) for x in input().split(" ")]
def process_task(self):
notes = 0
for note in self.banknotes:
if self.a_b_c[1] < note < self.a_b_c[2]:
notes += 1
self.result = str(notes)
def get_result(self):
return self.result
if __name__ == "__main__":
Solution = CodeforcesTask794ASolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())
```
| 92,283 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A robber has attempted to rob a bank but failed to complete his task. However, he had managed to open all the safes.
Oleg the bank client loves money (who doesn't), and decides to take advantage of this failed robbery and steal some money from the safes. There are many safes arranged in a line, where the i-th safe from the left is called safe i. There are n banknotes left in all the safes in total. The i-th banknote is in safe xi. Oleg is now at safe a. There are two security guards, one of which guards the safe b such that b < a, i.e. the first guard is to the left of Oleg. The other guard guards the safe c so that c > a, i.e. he is to the right of Oleg.
The two guards are very lazy, so they do not move. In every second, Oleg can either take all the banknotes from the current safe or move to any of the neighboring safes. However, he cannot visit any safe that is guarded by security guards at any time, becaues he might be charged for stealing. Determine the maximum amount of banknotes Oleg can gather.
Input
The first line of input contains three space-separated integers, a, b and c (1 ≤ b < a < c ≤ 109), denoting the positions of Oleg, the first security guard and the second security guard, respectively.
The next line of input contains a single integer n (1 ≤ n ≤ 105), denoting the number of banknotes.
The next line of input contains n space-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 109), denoting that the i-th banknote is located in the xi-th safe. Note that xi are not guaranteed to be distinct.
Output
Output a single integer: the maximum number of banknotes Oleg can take.
Examples
Input
5 3 7
8
4 7 5 5 3 6 2 8
Output
4
Input
6 5 7
5
1 5 7 92 3
Output
0
Note
In the first example Oleg can take the banknotes in positions 4, 5, 6 (note that there are 2 banknotes at position 5). Oleg can't take the banknotes in safes 7 and 8 because he can't run into the second security guard. Similarly, Oleg cannot take the banknotes at positions 3 and 2 because he can't run into the first security guard. Thus, he can take a maximum of 4 banknotes.
For the second sample, Oleg can't take any banknotes without bumping into any of the security guards.
Tags: brute force, implementation
Correct Solution:
```
a, b, c = map(int, input().split())
n = int(input())
l = list(map(int, input().split()))
ans = 0
for i in l:
if i in range(b+1, c):
ans += 1
print(ans)
```
| 92,284 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A robber has attempted to rob a bank but failed to complete his task. However, he had managed to open all the safes.
Oleg the bank client loves money (who doesn't), and decides to take advantage of this failed robbery and steal some money from the safes. There are many safes arranged in a line, where the i-th safe from the left is called safe i. There are n banknotes left in all the safes in total. The i-th banknote is in safe xi. Oleg is now at safe a. There are two security guards, one of which guards the safe b such that b < a, i.e. the first guard is to the left of Oleg. The other guard guards the safe c so that c > a, i.e. he is to the right of Oleg.
The two guards are very lazy, so they do not move. In every second, Oleg can either take all the banknotes from the current safe or move to any of the neighboring safes. However, he cannot visit any safe that is guarded by security guards at any time, becaues he might be charged for stealing. Determine the maximum amount of banknotes Oleg can gather.
Input
The first line of input contains three space-separated integers, a, b and c (1 ≤ b < a < c ≤ 109), denoting the positions of Oleg, the first security guard and the second security guard, respectively.
The next line of input contains a single integer n (1 ≤ n ≤ 105), denoting the number of banknotes.
The next line of input contains n space-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 109), denoting that the i-th banknote is located in the xi-th safe. Note that xi are not guaranteed to be distinct.
Output
Output a single integer: the maximum number of banknotes Oleg can take.
Examples
Input
5 3 7
8
4 7 5 5 3 6 2 8
Output
4
Input
6 5 7
5
1 5 7 92 3
Output
0
Note
In the first example Oleg can take the banknotes in positions 4, 5, 6 (note that there are 2 banknotes at position 5). Oleg can't take the banknotes in safes 7 and 8 because he can't run into the second security guard. Similarly, Oleg cannot take the banknotes at positions 3 and 2 because he can't run into the first security guard. Thus, he can take a maximum of 4 banknotes.
For the second sample, Oleg can't take any banknotes without bumping into any of the security guards.
Tags: brute force, implementation
Correct Solution:
```
a,b,c = list(map(int,input().split()))
n = int(input())
a = list(map(int,input().split()))
ans = 0
for i in a:
if b < i < c:
ans += 1
print(ans)
```
| 92,285 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A robber has attempted to rob a bank but failed to complete his task. However, he had managed to open all the safes.
Oleg the bank client loves money (who doesn't), and decides to take advantage of this failed robbery and steal some money from the safes. There are many safes arranged in a line, where the i-th safe from the left is called safe i. There are n banknotes left in all the safes in total. The i-th banknote is in safe xi. Oleg is now at safe a. There are two security guards, one of which guards the safe b such that b < a, i.e. the first guard is to the left of Oleg. The other guard guards the safe c so that c > a, i.e. he is to the right of Oleg.
The two guards are very lazy, so they do not move. In every second, Oleg can either take all the banknotes from the current safe or move to any of the neighboring safes. However, he cannot visit any safe that is guarded by security guards at any time, becaues he might be charged for stealing. Determine the maximum amount of banknotes Oleg can gather.
Input
The first line of input contains three space-separated integers, a, b and c (1 ≤ b < a < c ≤ 109), denoting the positions of Oleg, the first security guard and the second security guard, respectively.
The next line of input contains a single integer n (1 ≤ n ≤ 105), denoting the number of banknotes.
The next line of input contains n space-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 109), denoting that the i-th banknote is located in the xi-th safe. Note that xi are not guaranteed to be distinct.
Output
Output a single integer: the maximum number of banknotes Oleg can take.
Examples
Input
5 3 7
8
4 7 5 5 3 6 2 8
Output
4
Input
6 5 7
5
1 5 7 92 3
Output
0
Note
In the first example Oleg can take the banknotes in positions 4, 5, 6 (note that there are 2 banknotes at position 5). Oleg can't take the banknotes in safes 7 and 8 because he can't run into the second security guard. Similarly, Oleg cannot take the banknotes at positions 3 and 2 because he can't run into the first security guard. Thus, he can take a maximum of 4 banknotes.
For the second sample, Oleg can't take any banknotes without bumping into any of the security guards.
Tags: brute force, implementation
Correct Solution:
```
def main_function():
a, b, c = [int(i) for i in input().split(" ")]
n = int(input())
x = [int(i) for i in input().split(" ")]
banknotes = 0
for i in x:
if i > b and i < c:
banknotes += 1
return str(banknotes)
print(main_function())
```
| 92,286 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A robber has attempted to rob a bank but failed to complete his task. However, he had managed to open all the safes.
Oleg the bank client loves money (who doesn't), and decides to take advantage of this failed robbery and steal some money from the safes. There are many safes arranged in a line, where the i-th safe from the left is called safe i. There are n banknotes left in all the safes in total. The i-th banknote is in safe xi. Oleg is now at safe a. There are two security guards, one of which guards the safe b such that b < a, i.e. the first guard is to the left of Oleg. The other guard guards the safe c so that c > a, i.e. he is to the right of Oleg.
The two guards are very lazy, so they do not move. In every second, Oleg can either take all the banknotes from the current safe or move to any of the neighboring safes. However, he cannot visit any safe that is guarded by security guards at any time, becaues he might be charged for stealing. Determine the maximum amount of banknotes Oleg can gather.
Input
The first line of input contains three space-separated integers, a, b and c (1 ≤ b < a < c ≤ 109), denoting the positions of Oleg, the first security guard and the second security guard, respectively.
The next line of input contains a single integer n (1 ≤ n ≤ 105), denoting the number of banknotes.
The next line of input contains n space-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 109), denoting that the i-th banknote is located in the xi-th safe. Note that xi are not guaranteed to be distinct.
Output
Output a single integer: the maximum number of banknotes Oleg can take.
Examples
Input
5 3 7
8
4 7 5 5 3 6 2 8
Output
4
Input
6 5 7
5
1 5 7 92 3
Output
0
Note
In the first example Oleg can take the banknotes in positions 4, 5, 6 (note that there are 2 banknotes at position 5). Oleg can't take the banknotes in safes 7 and 8 because he can't run into the second security guard. Similarly, Oleg cannot take the banknotes at positions 3 and 2 because he can't run into the first security guard. Thus, he can take a maximum of 4 banknotes.
For the second sample, Oleg can't take any banknotes without bumping into any of the security guards.
Tags: brute force, implementation
Correct Solution:
```
#----Kuzlyaev-Nikita-Codeforces-----
#------------03.04.2020-------------
alph="abcdefghijklmnopqrstuvwxyz"
#-----------------------------------
a,b,c=map(int,input().split())
n=int(input())
x=list(map(int,input().split()))
E=0
for i in range(n):
if x[i]>b and x[i]<c:
E+=1
print(E)
```
| 92,287 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A robber has attempted to rob a bank but failed to complete his task. However, he had managed to open all the safes.
Oleg the bank client loves money (who doesn't), and decides to take advantage of this failed robbery and steal some money from the safes. There are many safes arranged in a line, where the i-th safe from the left is called safe i. There are n banknotes left in all the safes in total. The i-th banknote is in safe xi. Oleg is now at safe a. There are two security guards, one of which guards the safe b such that b < a, i.e. the first guard is to the left of Oleg. The other guard guards the safe c so that c > a, i.e. he is to the right of Oleg.
The two guards are very lazy, so they do not move. In every second, Oleg can either take all the banknotes from the current safe or move to any of the neighboring safes. However, he cannot visit any safe that is guarded by security guards at any time, becaues he might be charged for stealing. Determine the maximum amount of banknotes Oleg can gather.
Input
The first line of input contains three space-separated integers, a, b and c (1 ≤ b < a < c ≤ 109), denoting the positions of Oleg, the first security guard and the second security guard, respectively.
The next line of input contains a single integer n (1 ≤ n ≤ 105), denoting the number of banknotes.
The next line of input contains n space-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 109), denoting that the i-th banknote is located in the xi-th safe. Note that xi are not guaranteed to be distinct.
Output
Output a single integer: the maximum number of banknotes Oleg can take.
Examples
Input
5 3 7
8
4 7 5 5 3 6 2 8
Output
4
Input
6 5 7
5
1 5 7 92 3
Output
0
Note
In the first example Oleg can take the banknotes in positions 4, 5, 6 (note that there are 2 banknotes at position 5). Oleg can't take the banknotes in safes 7 and 8 because he can't run into the second security guard. Similarly, Oleg cannot take the banknotes at positions 3 and 2 because he can't run into the first security guard. Thus, he can take a maximum of 4 banknotes.
For the second sample, Oleg can't take any banknotes without bumping into any of the security guards.
Tags: brute force, implementation
Correct Solution:
```
a,b,c=map(int,input().split())
d=int(input())
l=list(map(int,input().split()))
i=0
e=0
while(i<d):
if l[i]>b and l[i]<c:
e+=1
i+=1
print(e)
```
| 92,288 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A robber has attempted to rob a bank but failed to complete his task. However, he had managed to open all the safes.
Oleg the bank client loves money (who doesn't), and decides to take advantage of this failed robbery and steal some money from the safes. There are many safes arranged in a line, where the i-th safe from the left is called safe i. There are n banknotes left in all the safes in total. The i-th banknote is in safe xi. Oleg is now at safe a. There are two security guards, one of which guards the safe b such that b < a, i.e. the first guard is to the left of Oleg. The other guard guards the safe c so that c > a, i.e. he is to the right of Oleg.
The two guards are very lazy, so they do not move. In every second, Oleg can either take all the banknotes from the current safe or move to any of the neighboring safes. However, he cannot visit any safe that is guarded by security guards at any time, becaues he might be charged for stealing. Determine the maximum amount of banknotes Oleg can gather.
Input
The first line of input contains three space-separated integers, a, b and c (1 ≤ b < a < c ≤ 109), denoting the positions of Oleg, the first security guard and the second security guard, respectively.
The next line of input contains a single integer n (1 ≤ n ≤ 105), denoting the number of banknotes.
The next line of input contains n space-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 109), denoting that the i-th banknote is located in the xi-th safe. Note that xi are not guaranteed to be distinct.
Output
Output a single integer: the maximum number of banknotes Oleg can take.
Examples
Input
5 3 7
8
4 7 5 5 3 6 2 8
Output
4
Input
6 5 7
5
1 5 7 92 3
Output
0
Note
In the first example Oleg can take the banknotes in positions 4, 5, 6 (note that there are 2 banknotes at position 5). Oleg can't take the banknotes in safes 7 and 8 because he can't run into the second security guard. Similarly, Oleg cannot take the banknotes at positions 3 and 2 because he can't run into the first security guard. Thus, he can take a maximum of 4 banknotes.
For the second sample, Oleg can't take any banknotes without bumping into any of the security guards.
Tags: brute force, implementation
Correct Solution:
```
l=list(map(int,input().rstrip().split()))
n=int(input())
l1=list(map(int,input().rstrip().split()))
c=0
for i in l1:
if (i>l[1] and i<l[2]):
c+=1
print(c)
```
| 92,289 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A robber has attempted to rob a bank but failed to complete his task. However, he had managed to open all the safes.
Oleg the bank client loves money (who doesn't), and decides to take advantage of this failed robbery and steal some money from the safes. There are many safes arranged in a line, where the i-th safe from the left is called safe i. There are n banknotes left in all the safes in total. The i-th banknote is in safe xi. Oleg is now at safe a. There are two security guards, one of which guards the safe b such that b < a, i.e. the first guard is to the left of Oleg. The other guard guards the safe c so that c > a, i.e. he is to the right of Oleg.
The two guards are very lazy, so they do not move. In every second, Oleg can either take all the banknotes from the current safe or move to any of the neighboring safes. However, he cannot visit any safe that is guarded by security guards at any time, becaues he might be charged for stealing. Determine the maximum amount of banknotes Oleg can gather.
Input
The first line of input contains three space-separated integers, a, b and c (1 ≤ b < a < c ≤ 109), denoting the positions of Oleg, the first security guard and the second security guard, respectively.
The next line of input contains a single integer n (1 ≤ n ≤ 105), denoting the number of banknotes.
The next line of input contains n space-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 109), denoting that the i-th banknote is located in the xi-th safe. Note that xi are not guaranteed to be distinct.
Output
Output a single integer: the maximum number of banknotes Oleg can take.
Examples
Input
5 3 7
8
4 7 5 5 3 6 2 8
Output
4
Input
6 5 7
5
1 5 7 92 3
Output
0
Note
In the first example Oleg can take the banknotes in positions 4, 5, 6 (note that there are 2 banknotes at position 5). Oleg can't take the banknotes in safes 7 and 8 because he can't run into the second security guard. Similarly, Oleg cannot take the banknotes at positions 3 and 2 because he can't run into the first security guard. Thus, he can take a maximum of 4 banknotes.
For the second sample, Oleg can't take any banknotes without bumping into any of the security guards.
Tags: brute force, implementation
Correct Solution:
```
(n,a,b) = [int(x) for x in input().split()]
number = int(input())
notes = [int(x) for x in input().split()]
answer = 0
for i in range(len(notes)):
if a<notes[i]<b:
answer+=1
print(answer)
```
| 92,290 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A robber has attempted to rob a bank but failed to complete his task. However, he had managed to open all the safes.
Oleg the bank client loves money (who doesn't), and decides to take advantage of this failed robbery and steal some money from the safes. There are many safes arranged in a line, where the i-th safe from the left is called safe i. There are n banknotes left in all the safes in total. The i-th banknote is in safe xi. Oleg is now at safe a. There are two security guards, one of which guards the safe b such that b < a, i.e. the first guard is to the left of Oleg. The other guard guards the safe c so that c > a, i.e. he is to the right of Oleg.
The two guards are very lazy, so they do not move. In every second, Oleg can either take all the banknotes from the current safe or move to any of the neighboring safes. However, he cannot visit any safe that is guarded by security guards at any time, becaues he might be charged for stealing. Determine the maximum amount of banknotes Oleg can gather.
Input
The first line of input contains three space-separated integers, a, b and c (1 ≤ b < a < c ≤ 109), denoting the positions of Oleg, the first security guard and the second security guard, respectively.
The next line of input contains a single integer n (1 ≤ n ≤ 105), denoting the number of banknotes.
The next line of input contains n space-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 109), denoting that the i-th banknote is located in the xi-th safe. Note that xi are not guaranteed to be distinct.
Output
Output a single integer: the maximum number of banknotes Oleg can take.
Examples
Input
5 3 7
8
4 7 5 5 3 6 2 8
Output
4
Input
6 5 7
5
1 5 7 92 3
Output
0
Note
In the first example Oleg can take the banknotes in positions 4, 5, 6 (note that there are 2 banknotes at position 5). Oleg can't take the banknotes in safes 7 and 8 because he can't run into the second security guard. Similarly, Oleg cannot take the banknotes at positions 3 and 2 because he can't run into the first security guard. Thus, he can take a maximum of 4 banknotes.
For the second sample, Oleg can't take any banknotes without bumping into any of the security guards.
Submitted Solution:
```
T_ON = 0
DEBUG_ON = 1
MOD = 998244353
def solve():
c, a, b = read_ints()
n = read_int()
A = read_ints()
count = 0
for x in A:
if a < x < b:
count += 1
print(count)
def main():
T = read_int() if T_ON else 1
for i in range(T):
solve()
def debug(*xargs):
if DEBUG_ON:
print(*xargs)
from collections import *
import math
#---------------------------------FAST_IO---------------------------------------
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#----------------------------------IO_WRAP--------------------------------------
def read_int():
return int(input())
def read_ints():
return list(map(int, input().split()))
def print_nums(nums):
print(" ".join(map(str, nums)))
def YES():
print("YES")
def Yes():
print("Yes")
def NO():
print("NO")
def No():
print("No")
def First():
print("First")
def Second():
print("Second")
#----------------------------------FIB--------------------------------------
def fib(n):
"""
the nth fib, start from zero
"""
a, b = 0, 1
for _ in range(n):
a, b = b, a + b
return a
def fib_ns(n):
"""
the first n fibs, start from zero
"""
assert n >= 1
f = [0 for _ in range(n + 1)]
f[0] = 0
f[1] = 1
for i in range(2, n + 1):
f[i] = f[i - 1] + f[i - 2]
return f
def fib_to_n(n):
"""
return fibs <= n, start from zero
n=8
f=[0,1,1,2,3,5,8]
"""
f = []
a, b = 0, 1
while a <= n:
f.append(a)
a, b = b, a + b
return f
#----------------------------------MOD--------------------------------------
def gcd(a, b):
if a == 0:
return b
return gcd(b % a, a)
def xgcd(a, b):
"""return (g, x, y) such that a*x + b*y = g = gcd(a, b)"""
x0, x1, y0, y1 = 0, 1, 1, 0
while a != 0:
(q, a), b = divmod(b, a), a
y0, y1 = y1, y0 - q * y1
x0, x1 = x1, x0 - q * x1
return b, x0, y0
def lcm(a, b):
d = gcd(a, b)
return a * b // d
def is_even(x):
return x % 2 == 0
def is_odd(x):
return x % 2 == 1
def modinv(a, m):
"""return x such that (a * x) % m == 1"""
g, x, _ = xgcd(a, m)
if g != 1:
raise Exception('gcd(a, m) != 1')
return x % m
def mod_add(x, y):
x += y
while x >= MOD:
x -= MOD
while x < 0:
x += MOD
return x
def mod_mul(x, y):
return (x * y) % MOD
def mod_pow(x, y):
if y == 0:
return 1
if y % 2:
return mod_mul(x, mod_pow(x, y - 1))
p = mod_pow(x, y // 2)
return mod_mul(p, p)
def mod_inv(y):
return mod_pow(y, MOD - 2)
def mod_div(x, y):
# y^(-1): Fermat little theorem, MOD is a prime
return mod_mul(x, mod_inv(y))
#---------------------------------PRIME---------------------------------------
def is_prime(n):
if n == 1:
return False
for i in range(2, int(n ** 0.5) + 1):
if n % i:
return False
return True
def gen_primes(n):
"""
generate primes of [1..n] using sieve's method
"""
P = [True for _ in range(n + 1)]
P[0] = P[1] = False
for i in range(int(n ** 0.5) + 1):
if P[i]:
for j in range(2 * i, n + 1, i):
P[j] = False
return P
#---------------------------------MISC---------------------------------------
def is_lucky(n):
return set(list(str(n))).issubset({'4', '7'})
#---------------------------------MAIN---------------------------------------
main()
```
Yes
| 92,291 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A robber has attempted to rob a bank but failed to complete his task. However, he had managed to open all the safes.
Oleg the bank client loves money (who doesn't), and decides to take advantage of this failed robbery and steal some money from the safes. There are many safes arranged in a line, where the i-th safe from the left is called safe i. There are n banknotes left in all the safes in total. The i-th banknote is in safe xi. Oleg is now at safe a. There are two security guards, one of which guards the safe b such that b < a, i.e. the first guard is to the left of Oleg. The other guard guards the safe c so that c > a, i.e. he is to the right of Oleg.
The two guards are very lazy, so they do not move. In every second, Oleg can either take all the banknotes from the current safe or move to any of the neighboring safes. However, he cannot visit any safe that is guarded by security guards at any time, becaues he might be charged for stealing. Determine the maximum amount of banknotes Oleg can gather.
Input
The first line of input contains three space-separated integers, a, b and c (1 ≤ b < a < c ≤ 109), denoting the positions of Oleg, the first security guard and the second security guard, respectively.
The next line of input contains a single integer n (1 ≤ n ≤ 105), denoting the number of banknotes.
The next line of input contains n space-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 109), denoting that the i-th banknote is located in the xi-th safe. Note that xi are not guaranteed to be distinct.
Output
Output a single integer: the maximum number of banknotes Oleg can take.
Examples
Input
5 3 7
8
4 7 5 5 3 6 2 8
Output
4
Input
6 5 7
5
1 5 7 92 3
Output
0
Note
In the first example Oleg can take the banknotes in positions 4, 5, 6 (note that there are 2 banknotes at position 5). Oleg can't take the banknotes in safes 7 and 8 because he can't run into the second security guard. Similarly, Oleg cannot take the banknotes at positions 3 and 2 because he can't run into the first security guard. Thus, he can take a maximum of 4 banknotes.
For the second sample, Oleg can't take any banknotes without bumping into any of the security guards.
Submitted Solution:
```
n,m,o = map(int,input().split())
a = int(input())
b = sorted(list(map(int,input().split())))
z =0
for i in b:
if i>m and i<o:
z+=1
print(z)
```
Yes
| 92,292 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A robber has attempted to rob a bank but failed to complete his task. However, he had managed to open all the safes.
Oleg the bank client loves money (who doesn't), and decides to take advantage of this failed robbery and steal some money from the safes. There are many safes arranged in a line, where the i-th safe from the left is called safe i. There are n banknotes left in all the safes in total. The i-th banknote is in safe xi. Oleg is now at safe a. There are two security guards, one of which guards the safe b such that b < a, i.e. the first guard is to the left of Oleg. The other guard guards the safe c so that c > a, i.e. he is to the right of Oleg.
The two guards are very lazy, so they do not move. In every second, Oleg can either take all the banknotes from the current safe or move to any of the neighboring safes. However, he cannot visit any safe that is guarded by security guards at any time, becaues he might be charged for stealing. Determine the maximum amount of banknotes Oleg can gather.
Input
The first line of input contains three space-separated integers, a, b and c (1 ≤ b < a < c ≤ 109), denoting the positions of Oleg, the first security guard and the second security guard, respectively.
The next line of input contains a single integer n (1 ≤ n ≤ 105), denoting the number of banknotes.
The next line of input contains n space-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 109), denoting that the i-th banknote is located in the xi-th safe. Note that xi are not guaranteed to be distinct.
Output
Output a single integer: the maximum number of banknotes Oleg can take.
Examples
Input
5 3 7
8
4 7 5 5 3 6 2 8
Output
4
Input
6 5 7
5
1 5 7 92 3
Output
0
Note
In the first example Oleg can take the banknotes in positions 4, 5, 6 (note that there are 2 banknotes at position 5). Oleg can't take the banknotes in safes 7 and 8 because he can't run into the second security guard. Similarly, Oleg cannot take the banknotes at positions 3 and 2 because he can't run into the first security guard. Thus, he can take a maximum of 4 banknotes.
For the second sample, Oleg can't take any banknotes without bumping into any of the security guards.
Submitted Solution:
```
#!/usr/bin/env python3
from sys import stdin, stdout
def rint():
return map(int, stdin.readline().split())
#lines = stdin.readlines()
a, b, c = rint()
n = int(input())
x = list(rint())
ans = 0
for i in x:
if i > b and i < c:
ans += 1
print(ans)
```
Yes
| 92,293 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A robber has attempted to rob a bank but failed to complete his task. However, he had managed to open all the safes.
Oleg the bank client loves money (who doesn't), and decides to take advantage of this failed robbery and steal some money from the safes. There are many safes arranged in a line, where the i-th safe from the left is called safe i. There are n banknotes left in all the safes in total. The i-th banknote is in safe xi. Oleg is now at safe a. There are two security guards, one of which guards the safe b such that b < a, i.e. the first guard is to the left of Oleg. The other guard guards the safe c so that c > a, i.e. he is to the right of Oleg.
The two guards are very lazy, so they do not move. In every second, Oleg can either take all the banknotes from the current safe or move to any of the neighboring safes. However, he cannot visit any safe that is guarded by security guards at any time, becaues he might be charged for stealing. Determine the maximum amount of banknotes Oleg can gather.
Input
The first line of input contains three space-separated integers, a, b and c (1 ≤ b < a < c ≤ 109), denoting the positions of Oleg, the first security guard and the second security guard, respectively.
The next line of input contains a single integer n (1 ≤ n ≤ 105), denoting the number of banknotes.
The next line of input contains n space-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 109), denoting that the i-th banknote is located in the xi-th safe. Note that xi are not guaranteed to be distinct.
Output
Output a single integer: the maximum number of banknotes Oleg can take.
Examples
Input
5 3 7
8
4 7 5 5 3 6 2 8
Output
4
Input
6 5 7
5
1 5 7 92 3
Output
0
Note
In the first example Oleg can take the banknotes in positions 4, 5, 6 (note that there are 2 banknotes at position 5). Oleg can't take the banknotes in safes 7 and 8 because he can't run into the second security guard. Similarly, Oleg cannot take the banknotes at positions 3 and 2 because he can't run into the first security guard. Thus, he can take a maximum of 4 banknotes.
For the second sample, Oleg can't take any banknotes without bumping into any of the security guards.
Submitted Solution:
```
a, b, c = map(int, input().split())
n = int(input())
x = map(int, input().split())
ans = 0
for i in x:
if b < i < c:
ans += 1
print(ans)
```
Yes
| 92,294 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A robber has attempted to rob a bank but failed to complete his task. However, he had managed to open all the safes.
Oleg the bank client loves money (who doesn't), and decides to take advantage of this failed robbery and steal some money from the safes. There are many safes arranged in a line, where the i-th safe from the left is called safe i. There are n banknotes left in all the safes in total. The i-th banknote is in safe xi. Oleg is now at safe a. There are two security guards, one of which guards the safe b such that b < a, i.e. the first guard is to the left of Oleg. The other guard guards the safe c so that c > a, i.e. he is to the right of Oleg.
The two guards are very lazy, so they do not move. In every second, Oleg can either take all the banknotes from the current safe or move to any of the neighboring safes. However, he cannot visit any safe that is guarded by security guards at any time, becaues he might be charged for stealing. Determine the maximum amount of banknotes Oleg can gather.
Input
The first line of input contains three space-separated integers, a, b and c (1 ≤ b < a < c ≤ 109), denoting the positions of Oleg, the first security guard and the second security guard, respectively.
The next line of input contains a single integer n (1 ≤ n ≤ 105), denoting the number of banknotes.
The next line of input contains n space-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 109), denoting that the i-th banknote is located in the xi-th safe. Note that xi are not guaranteed to be distinct.
Output
Output a single integer: the maximum number of banknotes Oleg can take.
Examples
Input
5 3 7
8
4 7 5 5 3 6 2 8
Output
4
Input
6 5 7
5
1 5 7 92 3
Output
0
Note
In the first example Oleg can take the banknotes in positions 4, 5, 6 (note that there are 2 banknotes at position 5). Oleg can't take the banknotes in safes 7 and 8 because he can't run into the second security guard. Similarly, Oleg cannot take the banknotes at positions 3 and 2 because he can't run into the first security guard. Thus, he can take a maximum of 4 banknotes.
For the second sample, Oleg can't take any banknotes without bumping into any of the security guards.
Submitted Solution:
```
from bisect import bisect_left
def num_notes(x, left, right):
count = 0
for i in range(left, right + 1):
count += x[i]
return count
def search_left(a, x, lo=0, hi=None):
hi = hi if hi is not None else len(a)
pos = bisect_left(a, x, lo, hi)
return (pos if pos != hi and a[pos] == x else pos + 1)
def search_right(a, x, lo=0, hi=None):
hi = hi if hi is not None else len(a)
pos = bisect_left(a, x, lo, hi)
return (pos if pos != hi and a[pos] == x else pos - 1)
if __name__ == '__main__':
a, b, c = [int(num) for num in input().split()]
n = int(input())
x = []
for i in range(0, n):
x.append(int(n))
x.sort()
left = search_left(x, a)
right = search_right(x, b)
print(num_notes(x, left, right))
```
No
| 92,295 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A robber has attempted to rob a bank but failed to complete his task. However, he had managed to open all the safes.
Oleg the bank client loves money (who doesn't), and decides to take advantage of this failed robbery and steal some money from the safes. There are many safes arranged in a line, where the i-th safe from the left is called safe i. There are n banknotes left in all the safes in total. The i-th banknote is in safe xi. Oleg is now at safe a. There are two security guards, one of which guards the safe b such that b < a, i.e. the first guard is to the left of Oleg. The other guard guards the safe c so that c > a, i.e. he is to the right of Oleg.
The two guards are very lazy, so they do not move. In every second, Oleg can either take all the banknotes from the current safe or move to any of the neighboring safes. However, he cannot visit any safe that is guarded by security guards at any time, becaues he might be charged for stealing. Determine the maximum amount of banknotes Oleg can gather.
Input
The first line of input contains three space-separated integers, a, b and c (1 ≤ b < a < c ≤ 109), denoting the positions of Oleg, the first security guard and the second security guard, respectively.
The next line of input contains a single integer n (1 ≤ n ≤ 105), denoting the number of banknotes.
The next line of input contains n space-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 109), denoting that the i-th banknote is located in the xi-th safe. Note that xi are not guaranteed to be distinct.
Output
Output a single integer: the maximum number of banknotes Oleg can take.
Examples
Input
5 3 7
8
4 7 5 5 3 6 2 8
Output
4
Input
6 5 7
5
1 5 7 92 3
Output
0
Note
In the first example Oleg can take the banknotes in positions 4, 5, 6 (note that there are 2 banknotes at position 5). Oleg can't take the banknotes in safes 7 and 8 because he can't run into the second security guard. Similarly, Oleg cannot take the banknotes at positions 3 and 2 because he can't run into the first security guard. Thus, he can take a maximum of 4 banknotes.
For the second sample, Oleg can't take any banknotes without bumping into any of the security guards.
Submitted Solution:
```
######################################################
def convert_inp_to_int():
return [int(x) for x in input().strip().split()]
#######################################################
def get_position(flag,n,notes_at,pos):
if(flag):
i=0
while(i<n):
if(notes_at[i]>pos):
return (i-1)
i+=1
return (i-1)
else:
i=0
while(i<n):
if(notes_at[i]>=pos):
return (i-1)
i+=1
return (i-1)
####################################################
abc=convert_inp_to_int()
a=abc[0]
b=abc[1]
c=abc[2]
n=convert_inp_to_int()[0]
notes_at=convert_inp_to_int()
notes_at.sort()
#print(notes_at)
g1_pos=get_position(1,n,notes_at,b)
g2_pos=get_position(0,n,notes_at,c)
g1_pos+=1
#print(oleg_pos,g1_pos,g2_pos)
if(g1_pos<g2_pos):
print(g2_pos-g1_pos+1)
else:
print(0)
```
No
| 92,296 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A robber has attempted to rob a bank but failed to complete his task. However, he had managed to open all the safes.
Oleg the bank client loves money (who doesn't), and decides to take advantage of this failed robbery and steal some money from the safes. There are many safes arranged in a line, where the i-th safe from the left is called safe i. There are n banknotes left in all the safes in total. The i-th banknote is in safe xi. Oleg is now at safe a. There are two security guards, one of which guards the safe b such that b < a, i.e. the first guard is to the left of Oleg. The other guard guards the safe c so that c > a, i.e. he is to the right of Oleg.
The two guards are very lazy, so they do not move. In every second, Oleg can either take all the banknotes from the current safe or move to any of the neighboring safes. However, he cannot visit any safe that is guarded by security guards at any time, becaues he might be charged for stealing. Determine the maximum amount of banknotes Oleg can gather.
Input
The first line of input contains three space-separated integers, a, b and c (1 ≤ b < a < c ≤ 109), denoting the positions of Oleg, the first security guard and the second security guard, respectively.
The next line of input contains a single integer n (1 ≤ n ≤ 105), denoting the number of banknotes.
The next line of input contains n space-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 109), denoting that the i-th banknote is located in the xi-th safe. Note that xi are not guaranteed to be distinct.
Output
Output a single integer: the maximum number of banknotes Oleg can take.
Examples
Input
5 3 7
8
4 7 5 5 3 6 2 8
Output
4
Input
6 5 7
5
1 5 7 92 3
Output
0
Note
In the first example Oleg can take the banknotes in positions 4, 5, 6 (note that there are 2 banknotes at position 5). Oleg can't take the banknotes in safes 7 and 8 because he can't run into the second security guard. Similarly, Oleg cannot take the banknotes at positions 3 and 2 because he can't run into the first security guard. Thus, he can take a maximum of 4 banknotes.
For the second sample, Oleg can't take any banknotes without bumping into any of the security guards.
Submitted Solution:
```
l=input().split(" ")
n=int(input())
k=input().split(" ")
b=[]
s=0
for i in range(int(l[1])+1,int(l[2])):
b.append(i)
for j in k:
if(int(j) in b):
s=s+k.count(j)
for i in range(k.count(j)):
k.remove(j)
print(s)
```
No
| 92,297 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A robber has attempted to rob a bank but failed to complete his task. However, he had managed to open all the safes.
Oleg the bank client loves money (who doesn't), and decides to take advantage of this failed robbery and steal some money from the safes. There are many safes arranged in a line, where the i-th safe from the left is called safe i. There are n banknotes left in all the safes in total. The i-th banknote is in safe xi. Oleg is now at safe a. There are two security guards, one of which guards the safe b such that b < a, i.e. the first guard is to the left of Oleg. The other guard guards the safe c so that c > a, i.e. he is to the right of Oleg.
The two guards are very lazy, so they do not move. In every second, Oleg can either take all the banknotes from the current safe or move to any of the neighboring safes. However, he cannot visit any safe that is guarded by security guards at any time, becaues he might be charged for stealing. Determine the maximum amount of banknotes Oleg can gather.
Input
The first line of input contains three space-separated integers, a, b and c (1 ≤ b < a < c ≤ 109), denoting the positions of Oleg, the first security guard and the second security guard, respectively.
The next line of input contains a single integer n (1 ≤ n ≤ 105), denoting the number of banknotes.
The next line of input contains n space-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 109), denoting that the i-th banknote is located in the xi-th safe. Note that xi are not guaranteed to be distinct.
Output
Output a single integer: the maximum number of banknotes Oleg can take.
Examples
Input
5 3 7
8
4 7 5 5 3 6 2 8
Output
4
Input
6 5 7
5
1 5 7 92 3
Output
0
Note
In the first example Oleg can take the banknotes in positions 4, 5, 6 (note that there are 2 banknotes at position 5). Oleg can't take the banknotes in safes 7 and 8 because he can't run into the second security guard. Similarly, Oleg cannot take the banknotes at positions 3 and 2 because he can't run into the first security guard. Thus, he can take a maximum of 4 banknotes.
For the second sample, Oleg can't take any banknotes without bumping into any of the security guards.
Submitted Solution:
```
a,b,c = input().split(' ')
a,b,c = int(a),int(b),int(c)
input()
safes = range(b+1,c)
line3 = input().split(' ')
c = 0
for sf in line3:
if sf in safes: c+= 1
print(c)
```
No
| 92,298 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Those unwilling to return home from a long journey, will be affected by the oddity of the snail and lose their way. Mayoi, the oddity's carrier, wouldn't like this to happen, but there's nothing to do with this before a cure is figured out. For now, she would only like to know the enormous number of possibilities to be faced with if someone gets lost.
There are n towns in the region, numbered from 1 to n. The town numbered 1 is called the capital. The traffic network is formed by bidirectional roads connecting pairs of towns. No two roads connect the same pair of towns, and no road connects a town with itself. The time needed to travel through each of the roads is the same. Lost travelers will not be able to find out how the towns are connected, but the residents can help them by providing the following facts:
* Starting from each town other than the capital, the shortest path (i.e. the path passing through the minimum number of roads) to the capital exists, and is unique;
* Let li be the number of roads on the shortest path from town i to the capital, then li ≥ li - 1 holds for all 2 ≤ i ≤ n;
* For town i, the number of roads connected to it is denoted by di, which equals either 2 or 3.
You are to count the number of different ways in which the towns are connected, and give the answer modulo 109 + 7. Two ways of connecting towns are considered different if a pair (u, v) (1 ≤ u, v ≤ n) exists such there is a road between towns u and v in one of them but not in the other.
Input
The first line of input contains a positive integer n (3 ≤ n ≤ 50) — the number of towns.
The second line contains n space-separated integers d1, d2, ..., dn (2 ≤ di ≤ 3) — the number of roads connected to towns 1, 2, ..., n, respectively. It is guaranteed that the sum of di over all i is even.
Output
Output one integer — the total number of different possible ways in which the towns are connected, modulo 109 + 7.
Examples
Input
4
3 2 3 2
Output
1
Input
5
2 3 3 2 2
Output
2
Input
5
2 2 2 2 2
Output
2
Input
20
2 2 2 2 3 2 3 2 2 2 2 2 2 2 2 2 2 3 3 2
Output
82944
Note
In the first example, the following structure is the only one to satisfy the constraints, the distances from towns 2, 3, 4 to the capital are all 1.
<image>
In the second example, the following two structures satisfy the constraints.
<image>
Submitted Solution:
```
n = input() #X is the rank of the current highest, each that rank disappear and the rank Y below become the new highest rank X
a = input() #Each turn the current first node on Z will try to connect to X and move into Y, no 2 nodes in X connect the same node
a = a.split(' ')#Strategy: Dynamic programming, there are 2 case, the first node in Z connect one of the nodes in X or every node in Z does not connect X
a = list(map(int,a))#After the second case happen, the nodes in X will connect each other to terminate X and replace X with Y
X = [a[0]] #The number in each node represent the number of nodes it can continue connecting so each time it connects, its number minus 1
Y = []
Z = a[1:]
def pair(x,y):
if y == 0:
if x == 0:
return 1
return (x-1)*pair(x-2,0)
if x == 0:
if y == 1 or y == 2:
return 0
return (y-1)*(y-2)*pair(2,y-3)/2
return y*pair(x,y-1) + (x-1)*pair(x-2,y)
def around(a):
t = 0
for i in a:
if i == 1:
t += 1
return pair(t,len(a)-t)
def tree(A,B,C): #the main function
if A == []:
if B == []:
return 1
return tree(B,[],C) #Move Y to X
elif sum(A) % 2 == 1:
if C == []: #In this case, contracdict
return 0
else: #Because the sum is odd, it cannot connect each other
t = 0
E = B + [C[0]-1]
D = C[1:]
for i in range(len(A)):
x = A[:]
if x[i] == 1:
x = x[:i] + x[i+1:]
else:
x[i] -= 1
t += tree(x,E,D)
return t
elif C == []: #reaching the end
return around(A)*tree(B,[],[])
else:
if B == []: #because Y is empty, the around function also can't happen
t = 0
E = B + [C[0]-1]
D = C[1:]
for i in range(len(A)):
x = A[:]
if x[i] == 1:
x = x[:i] + x[i+1:]
else:
x[i] -= 1
t += tree(x,E,D)
return t
t = around(A)*tree(B,[],C) #this is where the 2 cases happen
E = B + [C[0]-1]
D = C[1:]
for i in range(len(A)):
x = A[:]
if x[i] == 1:
x = x[:i] + x[i+1:]
else:
x[i] -= 1
t += tree(x,E,D)
return t
print(tree(X,Y,Z)) #Note: There's a lot of replication, you can use clear them out if you can
```
No
| 92,299 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.