text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.
To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and then each of them shows some number of fingers on one hand (one to five), and then the boys count in a circle, starting from Dima, the number of people, respective to the total number of fingers shown. The person on who the countdown stops will clean the apartment.
For example, if Dima and one of his friends played hide and seek, and 7 fingers were shown during the counting-out, then Dima would clean the place. If there were 2 or say, 8 fingers shown, then his friend would clean the place.
Dima knows how many fingers each of his friends will show during the counting-out. Now he is interested in the number of ways to show some number of fingers on one hand (one to five), so that he did not have to clean the place. Help Dima.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains n positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show.
The numbers in the lines are separated by a single space.
Output
In a single line print the answer to the problem.
Examples
Input
1
1
Output
3
Input
1
2
Output
2
Input
2
3 5
Output
3
Note
In the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend.
In the second sample Dima can show 2 or 4 fingers.
Tags: implementation, math
Correct Solution:
```
n = int(input())
m = list(map(int, input().split()))
sum=0
for i in range(len(m)):
sum += m[i]
h=0;
for i in range(1,6):
if (sum-1+i)%(n+1)!=0:
h+=1
print(h);
```
| 88,700 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.
To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and then each of them shows some number of fingers on one hand (one to five), and then the boys count in a circle, starting from Dima, the number of people, respective to the total number of fingers shown. The person on who the countdown stops will clean the apartment.
For example, if Dima and one of his friends played hide and seek, and 7 fingers were shown during the counting-out, then Dima would clean the place. If there were 2 or say, 8 fingers shown, then his friend would clean the place.
Dima knows how many fingers each of his friends will show during the counting-out. Now he is interested in the number of ways to show some number of fingers on one hand (one to five), so that he did not have to clean the place. Help Dima.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains n positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show.
The numbers in the lines are separated by a single space.
Output
In a single line print the answer to the problem.
Examples
Input
1
1
Output
3
Input
1
2
Output
2
Input
2
3 5
Output
3
Note
In the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend.
In the second sample Dima can show 2 or 4 fingers.
Tags: implementation, math
Correct Solution:
```
n=int(input())
l=list(map(int,input().split()))
friend=n+1
s=sum(l)
count=5
for i in range (5):
r=(s+i+1)%friend
if(r==1):
count-=1
print(count)
```
| 88,701 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.
To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and then each of them shows some number of fingers on one hand (one to five), and then the boys count in a circle, starting from Dima, the number of people, respective to the total number of fingers shown. The person on who the countdown stops will clean the apartment.
For example, if Dima and one of his friends played hide and seek, and 7 fingers were shown during the counting-out, then Dima would clean the place. If there were 2 or say, 8 fingers shown, then his friend would clean the place.
Dima knows how many fingers each of his friends will show during the counting-out. Now he is interested in the number of ways to show some number of fingers on one hand (one to five), so that he did not have to clean the place. Help Dima.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains n positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show.
The numbers in the lines are separated by a single space.
Output
In a single line print the answer to the problem.
Examples
Input
1
1
Output
3
Input
1
2
Output
2
Input
2
3 5
Output
3
Note
In the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend.
In the second sample Dima can show 2 or 4 fingers.
Tags: implementation, math
Correct Solution:
```
n = int(input())
a = list(map(int,input().split()))
x = [i for i in range(1,5*(n+1),n+1)]
cnt=0
for i in range(sum(a)+1,sum(a)+6):
if i in x:
cnt+=1
print(5-cnt)
```
| 88,702 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.
To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and then each of them shows some number of fingers on one hand (one to five), and then the boys count in a circle, starting from Dima, the number of people, respective to the total number of fingers shown. The person on who the countdown stops will clean the apartment.
For example, if Dima and one of his friends played hide and seek, and 7 fingers were shown during the counting-out, then Dima would clean the place. If there were 2 or say, 8 fingers shown, then his friend would clean the place.
Dima knows how many fingers each of his friends will show during the counting-out. Now he is interested in the number of ways to show some number of fingers on one hand (one to five), so that he did not have to clean the place. Help Dima.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains n positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show.
The numbers in the lines are separated by a single space.
Output
In a single line print the answer to the problem.
Examples
Input
1
1
Output
3
Input
1
2
Output
2
Input
2
3 5
Output
3
Note
In the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend.
In the second sample Dima can show 2 or 4 fingers.
Tags: implementation, math
Correct Solution:
```
n = int(input())
n += 1
frnds = list(map(int, input().split()))
total = sum(frnds)
count = 0
for i in range(1, 5+1):
if (total+i)%n != 1:
count += 1
print(count)
```
| 88,703 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.
To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and then each of them shows some number of fingers on one hand (one to five), and then the boys count in a circle, starting from Dima, the number of people, respective to the total number of fingers shown. The person on who the countdown stops will clean the apartment.
For example, if Dima and one of his friends played hide and seek, and 7 fingers were shown during the counting-out, then Dima would clean the place. If there were 2 or say, 8 fingers shown, then his friend would clean the place.
Dima knows how many fingers each of his friends will show during the counting-out. Now he is interested in the number of ways to show some number of fingers on one hand (one to five), so that he did not have to clean the place. Help Dima.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains n positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show.
The numbers in the lines are separated by a single space.
Output
In a single line print the answer to the problem.
Examples
Input
1
1
Output
3
Input
1
2
Output
2
Input
2
3 5
Output
3
Note
In the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend.
In the second sample Dima can show 2 or 4 fingers.
Tags: implementation, math
Correct Solution:
```
# cook your dish here
n=int(input())
l=input().split()
sum=0
for i in l :sum += int(i)
count=0
for i in range(5):
if (sum+i)% (n+1) !=0:count+=1
print(count)
```
| 88,704 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.
To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and then each of them shows some number of fingers on one hand (one to five), and then the boys count in a circle, starting from Dima, the number of people, respective to the total number of fingers shown. The person on who the countdown stops will clean the apartment.
For example, if Dima and one of his friends played hide and seek, and 7 fingers were shown during the counting-out, then Dima would clean the place. If there were 2 or say, 8 fingers shown, then his friend would clean the place.
Dima knows how many fingers each of his friends will show during the counting-out. Now he is interested in the number of ways to show some number of fingers on one hand (one to five), so that he did not have to clean the place. Help Dima.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains n positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show.
The numbers in the lines are separated by a single space.
Output
In a single line print the answer to the problem.
Examples
Input
1
1
Output
3
Input
1
2
Output
2
Input
2
3 5
Output
3
Note
In the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend.
In the second sample Dima can show 2 or 4 fingers.
Tags: implementation, math
Correct Solution:
```
n=int(input())
l=list(map(int,input().split()))
s=sum(l)
ans=0
for i in range(1,6):
if (s+i)%(n+1)!=1:
ans+=1
# break
print(ans)
```
| 88,705 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.
To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and then each of them shows some number of fingers on one hand (one to five), and then the boys count in a circle, starting from Dima, the number of people, respective to the total number of fingers shown. The person on who the countdown stops will clean the apartment.
For example, if Dima and one of his friends played hide and seek, and 7 fingers were shown during the counting-out, then Dima would clean the place. If there were 2 or say, 8 fingers shown, then his friend would clean the place.
Dima knows how many fingers each of his friends will show during the counting-out. Now he is interested in the number of ways to show some number of fingers on one hand (one to five), so that he did not have to clean the place. Help Dima.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains n positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show.
The numbers in the lines are separated by a single space.
Output
In a single line print the answer to the problem.
Examples
Input
1
1
Output
3
Input
1
2
Output
2
Input
2
3 5
Output
3
Note
In the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend.
In the second sample Dima can show 2 or 4 fingers.
Tags: implementation, math
Correct Solution:
```
n = int(input())
s = sum([int(i) for i in input().split()])
print(sum([(s+i)%(n+1)!=1 for i in range(1,6)]))
# if 2
# avoid = 1,3,5,7,9
# if 3
# avoid = 1,4,7,10,13
# if 4
# avoid = 1,5,9,13,17
# if 5
# avoid = 1,6,11,16,21
# if 6
# avoid = 1,7,13,19,25
# if 7
# avoid = 1,8,15,22,29
```
| 88,706 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.
To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and then each of them shows some number of fingers on one hand (one to five), and then the boys count in a circle, starting from Dima, the number of people, respective to the total number of fingers shown. The person on who the countdown stops will clean the apartment.
For example, if Dima and one of his friends played hide and seek, and 7 fingers were shown during the counting-out, then Dima would clean the place. If there were 2 or say, 8 fingers shown, then his friend would clean the place.
Dima knows how many fingers each of his friends will show during the counting-out. Now he is interested in the number of ways to show some number of fingers on one hand (one to five), so that he did not have to clean the place. Help Dima.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains n positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show.
The numbers in the lines are separated by a single space.
Output
In a single line print the answer to the problem.
Examples
Input
1
1
Output
3
Input
1
2
Output
2
Input
2
3 5
Output
3
Note
In the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend.
In the second sample Dima can show 2 or 4 fingers.
Tags: implementation, math
Correct Solution:
```
import sys
from math import sqrt, gcd, ceil, log
# from bisect import bisect, bisect_left
from collections import defaultdict, Counter, deque
# from heapq import heapify, heappush, heappop
input = sys.stdin.readline
read = lambda: list(map(int, input().strip().split()))
def main():
n = int(input()); s = sum(read())%(n+1)
ans = 0
for i in range(1, 6):
if (s+i)%(n+1) != 1:ans += 1
print(ans)
if __name__ == "__main__":
main()
```
| 88,707 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.
To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and then each of them shows some number of fingers on one hand (one to five), and then the boys count in a circle, starting from Dima, the number of people, respective to the total number of fingers shown. The person on who the countdown stops will clean the apartment.
For example, if Dima and one of his friends played hide and seek, and 7 fingers were shown during the counting-out, then Dima would clean the place. If there were 2 or say, 8 fingers shown, then his friend would clean the place.
Dima knows how many fingers each of his friends will show during the counting-out. Now he is interested in the number of ways to show some number of fingers on one hand (one to five), so that he did not have to clean the place. Help Dima.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains n positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show.
The numbers in the lines are separated by a single space.
Output
In a single line print the answer to the problem.
Examples
Input
1
1
Output
3
Input
1
2
Output
2
Input
2
3 5
Output
3
Note
In the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend.
In the second sample Dima can show 2 or 4 fingers.
Submitted Solution:
```
n=int(input())
x=0
c=sum(list(map(int,input().split())))
for i in range (1,6):
c+=1
if c%(n+1)!=1:
x+=1
print(x)
```
Yes
| 88,708 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.
To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and then each of them shows some number of fingers on one hand (one to five), and then the boys count in a circle, starting from Dima, the number of people, respective to the total number of fingers shown. The person on who the countdown stops will clean the apartment.
For example, if Dima and one of his friends played hide and seek, and 7 fingers were shown during the counting-out, then Dima would clean the place. If there were 2 or say, 8 fingers shown, then his friend would clean the place.
Dima knows how many fingers each of his friends will show during the counting-out. Now he is interested in the number of ways to show some number of fingers on one hand (one to five), so that he did not have to clean the place. Help Dima.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains n positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show.
The numbers in the lines are separated by a single space.
Output
In a single line print the answer to the problem.
Examples
Input
1
1
Output
3
Input
1
2
Output
2
Input
2
3 5
Output
3
Note
In the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend.
In the second sample Dima can show 2 or 4 fingers.
Submitted Solution:
```
n=int(input())
a=list(map(int,input().split()))
s=sum(a)
cnt=0
for i in range(1,6):
if (s+i)%(n+1)!=1:
cnt+=1
print(cnt)
```
Yes
| 88,709 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.
To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and then each of them shows some number of fingers on one hand (one to five), and then the boys count in a circle, starting from Dima, the number of people, respective to the total number of fingers shown. The person on who the countdown stops will clean the apartment.
For example, if Dima and one of his friends played hide and seek, and 7 fingers were shown during the counting-out, then Dima would clean the place. If there were 2 or say, 8 fingers shown, then his friend would clean the place.
Dima knows how many fingers each of his friends will show during the counting-out. Now he is interested in the number of ways to show some number of fingers on one hand (one to five), so that he did not have to clean the place. Help Dima.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains n positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show.
The numbers in the lines are separated by a single space.
Output
In a single line print the answer to the problem.
Examples
Input
1
1
Output
3
Input
1
2
Output
2
Input
2
3 5
Output
3
Note
In the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend.
In the second sample Dima can show 2 or 4 fingers.
Submitted Solution:
```
n = int(input())
s = sum(map(int, input().split())) % (n + 1)
cnt = sum([1 for i in range(5) if (i + 1 + s) % (n + 1) != 1])
print (cnt)
```
Yes
| 88,710 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.
To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and then each of them shows some number of fingers on one hand (one to five), and then the boys count in a circle, starting from Dima, the number of people, respective to the total number of fingers shown. The person on who the countdown stops will clean the apartment.
For example, if Dima and one of his friends played hide and seek, and 7 fingers were shown during the counting-out, then Dima would clean the place. If there were 2 or say, 8 fingers shown, then his friend would clean the place.
Dima knows how many fingers each of his friends will show during the counting-out. Now he is interested in the number of ways to show some number of fingers on one hand (one to five), so that he did not have to clean the place. Help Dima.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains n positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show.
The numbers in the lines are separated by a single space.
Output
In a single line print the answer to the problem.
Examples
Input
1
1
Output
3
Input
1
2
Output
2
Input
2
3 5
Output
3
Note
In the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend.
In the second sample Dima can show 2 or 4 fingers.
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
s=sum(l)
c=0
if((s+1)%(n+1)!=1):
c+=1
if((s+2)%(n+1)!=1):
c+=1
if((s+3)%(n+1)!=1):
c+=1
if((s+4)%(n+1)!=1):
c+=1
if((s+5)%(n+1)!=1):
c+=1
print(c)
```
Yes
| 88,711 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.
To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and then each of them shows some number of fingers on one hand (one to five), and then the boys count in a circle, starting from Dima, the number of people, respective to the total number of fingers shown. The person on who the countdown stops will clean the apartment.
For example, if Dima and one of his friends played hide and seek, and 7 fingers were shown during the counting-out, then Dima would clean the place. If there were 2 or say, 8 fingers shown, then his friend would clean the place.
Dima knows how many fingers each of his friends will show during the counting-out. Now he is interested in the number of ways to show some number of fingers on one hand (one to five), so that he did not have to clean the place. Help Dima.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains n positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show.
The numbers in the lines are separated by a single space.
Output
In a single line print the answer to the problem.
Examples
Input
1
1
Output
3
Input
1
2
Output
2
Input
2
3 5
Output
3
Note
In the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend.
In the second sample Dima can show 2 or 4 fingers.
Submitted Solution:
```
n = int(input())
t = list(map(int, input().split()))
print([2, 1][sum(t) % 2])
```
No
| 88,712 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.
To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and then each of them shows some number of fingers on one hand (one to five), and then the boys count in a circle, starting from Dima, the number of people, respective to the total number of fingers shown. The person on who the countdown stops will clean the apartment.
For example, if Dima and one of his friends played hide and seek, and 7 fingers were shown during the counting-out, then Dima would clean the place. If there were 2 or say, 8 fingers shown, then his friend would clean the place.
Dima knows how many fingers each of his friends will show during the counting-out. Now he is interested in the number of ways to show some number of fingers on one hand (one to five), so that he did not have to clean the place. Help Dima.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains n positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show.
The numbers in the lines are separated by a single space.
Output
In a single line print the answer to the problem.
Examples
Input
1
1
Output
3
Input
1
2
Output
2
Input
2
3 5
Output
3
Note
In the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend.
In the second sample Dima can show 2 or 4 fingers.
Submitted Solution:
```
n = int(input())+1
f = sum(map(int,input().split()))
l = [x for x in range(1,6) if (f+x)%n+1!=1]
print(len(l))
```
No
| 88,713 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.
To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and then each of them shows some number of fingers on one hand (one to five), and then the boys count in a circle, starting from Dima, the number of people, respective to the total number of fingers shown. The person on who the countdown stops will clean the apartment.
For example, if Dima and one of his friends played hide and seek, and 7 fingers were shown during the counting-out, then Dima would clean the place. If there were 2 or say, 8 fingers shown, then his friend would clean the place.
Dima knows how many fingers each of his friends will show during the counting-out. Now he is interested in the number of ways to show some number of fingers on one hand (one to five), so that he did not have to clean the place. Help Dima.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains n positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show.
The numbers in the lines are separated by a single space.
Output
In a single line print the answer to the problem.
Examples
Input
1
1
Output
3
Input
1
2
Output
2
Input
2
3 5
Output
3
Note
In the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend.
In the second sample Dima can show 2 or 4 fingers.
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
s=sum(l)
if s%(n+1)==1:
print(1)
else:
for i in range(1,6):
if (s+i)%(n+1)==0:
print(i)
break
```
No
| 88,714 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.
To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and then each of them shows some number of fingers on one hand (one to five), and then the boys count in a circle, starting from Dima, the number of people, respective to the total number of fingers shown. The person on who the countdown stops will clean the apartment.
For example, if Dima and one of his friends played hide and seek, and 7 fingers were shown during the counting-out, then Dima would clean the place. If there were 2 or say, 8 fingers shown, then his friend would clean the place.
Dima knows how many fingers each of his friends will show during the counting-out. Now he is interested in the number of ways to show some number of fingers on one hand (one to five), so that he did not have to clean the place. Help Dima.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains n positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show.
The numbers in the lines are separated by a single space.
Output
In a single line print the answer to the problem.
Examples
Input
1
1
Output
3
Input
1
2
Output
2
Input
2
3 5
Output
3
Note
In the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend.
In the second sample Dima can show 2 or 4 fingers.
Submitted Solution:
```
n = int(input())+1
f=sum(map(int,input().split()))
for i in range(2,6):
if (f+i)%n !=1:
print(i)
break
```
No
| 88,715 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Greg and his friends were walking in the forest. Overall there were n people walking, including Greg. Soon he found himself in front of a river. The guys immediately decided to get across the river. Luckily, there was a boat by the river bank, just where the guys were standing. We know that the boat can hold people with the total weight of at most k kilograms.
Greg immediately took a piece of paper and listed there the weights of all people in his group (including himself). It turned out that each person weights either 50 or 100 kilograms. Now Greg wants to know what minimum number of times the boat needs to cross the river to transport the whole group to the other bank. The boat needs at least one person to navigate it from one bank to the other. As the boat crosses the river, it can have any non-zero number of passengers as long as their total weight doesn't exceed k.
Also Greg is wondering, how many ways there are to transport everybody to the other side in the minimum number of boat rides. Two ways are considered distinct if during some ride they have distinct sets of people on the boat.
Help Greg with this problem.
Input
The first line contains two integers n, k (1 ≤ n ≤ 50, 1 ≤ k ≤ 5000) — the number of people, including Greg, and the boat's weight limit. The next line contains n integers — the people's weights. A person's weight is either 50 kilos or 100 kilos.
You can consider Greg and his friends indexed in some way.
Output
In the first line print an integer — the minimum number of rides. If transporting everyone to the other bank is impossible, print an integer -1.
In the second line print the remainder after dividing the number of ways to transport the people in the minimum number of rides by number 1000000007 (109 + 7). If transporting everyone to the other bank is impossible, print integer 0.
Examples
Input
1 50
50
Output
1
1
Input
3 100
50 50 100
Output
5
2
Input
2 50
50 50
Output
-1
0
Note
In the first test Greg walks alone and consequently, he needs only one ride across the river.
In the second test you should follow the plan:
1. transport two 50 kg. people;
2. transport one 50 kg. person back;
3. transport one 100 kg. person;
4. transport one 50 kg. person back;
5. transport two 50 kg. people.
That totals to 5 rides. Depending on which person to choose at step 2, we can get two distinct ways.
Tags: combinatorics, dp, graphs, shortest paths
Correct Solution:
```
from collections import deque
n, k = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
c50 = sum([1 for i in a if i == 50])
c100 = sum([1 for i in a if i == 100])
c = [[0] * 51 for i in range(51)]
c[0][0] = 1
c[1][0] = 1
c[1][1] = 1
for x in range(2, 51):
for y in range(x + 1):
c[x][y] = c[x - 1][y - 1] + c[x - 1][y]
d = [[[[0, float('inf')] for l in range(2)] for i in range(c100 + 1)] for j in range(c50 + 1)]
# d[i][j][c] ответ, когда мы переправили i по 50 кг и j по 100 кг и лодка на берегу c
d[0][0][0][0] = 1
d[0][0][0][1] = 0
q = deque()
q.append([0, 0, 0])
while len(q) > 0:
i, j, shore = q.popleft()
for fifty in range(c50 - i + 1 if shore == 0 else i + 1):
for hundreds in range(c100 - j + 1 if shore == 0 else j + 1):
if fifty * 50 + hundreds * 100 > k or fifty + hundreds == 0:
continue
i1 = i + fifty if shore == 0 else i - fifty
j1 = j + hundreds if shore == 0 else j - hundreds
if d[i1][j1][1 ^ shore][1] > d[i][j][shore][1] + 1:
d[i1][j1][1 ^ shore][1] = d[i][j][shore][1] + 1
d[i1][j1][1 ^ shore][0] = 0
q.append((i1, j1, 1 ^ shore))
if d[i1][j1][1 ^ shore][1] < d[i][j][shore][1] + 1:
continue
koeff = (c[c50 - i][fifty] if shore == 0 else c[i][fifty]) * (
c[c100 - j][hundreds] if shore == 0 else c[j][hundreds])
d[i1][j1][1 ^ shore][0] += d[i][j][shore][0] * koeff
d[i1][j1][1 ^ shore][0] %= 10 ** 9 + 7
if d[c50][c100][1][1] == float('inf'):
print(-1)
print(0)
else:
print(d[c50][c100][1][1])
print(d[c50][c100][1][0])
```
| 88,716 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Greg and his friends were walking in the forest. Overall there were n people walking, including Greg. Soon he found himself in front of a river. The guys immediately decided to get across the river. Luckily, there was a boat by the river bank, just where the guys were standing. We know that the boat can hold people with the total weight of at most k kilograms.
Greg immediately took a piece of paper and listed there the weights of all people in his group (including himself). It turned out that each person weights either 50 or 100 kilograms. Now Greg wants to know what minimum number of times the boat needs to cross the river to transport the whole group to the other bank. The boat needs at least one person to navigate it from one bank to the other. As the boat crosses the river, it can have any non-zero number of passengers as long as their total weight doesn't exceed k.
Also Greg is wondering, how many ways there are to transport everybody to the other side in the minimum number of boat rides. Two ways are considered distinct if during some ride they have distinct sets of people on the boat.
Help Greg with this problem.
Input
The first line contains two integers n, k (1 ≤ n ≤ 50, 1 ≤ k ≤ 5000) — the number of people, including Greg, and the boat's weight limit. The next line contains n integers — the people's weights. A person's weight is either 50 kilos or 100 kilos.
You can consider Greg and his friends indexed in some way.
Output
In the first line print an integer — the minimum number of rides. If transporting everyone to the other bank is impossible, print an integer -1.
In the second line print the remainder after dividing the number of ways to transport the people in the minimum number of rides by number 1000000007 (109 + 7). If transporting everyone to the other bank is impossible, print integer 0.
Examples
Input
1 50
50
Output
1
1
Input
3 100
50 50 100
Output
5
2
Input
2 50
50 50
Output
-1
0
Note
In the first test Greg walks alone and consequently, he needs only one ride across the river.
In the second test you should follow the plan:
1. transport two 50 kg. people;
2. transport one 50 kg. person back;
3. transport one 100 kg. person;
4. transport one 50 kg. person back;
5. transport two 50 kg. people.
That totals to 5 rides. Depending on which person to choose at step 2, we can get two distinct ways.
Submitted Solution:
```
from collections import deque
n, k = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
c50 = sum([1 for i in a if i == 50])
c100 = sum([1 for i in a if i == 100])
c = [[0] * 51 for i in range(51)]
c[0][0] = 1
c[1][0] = 1
c[1][1] = 1
for x in range(2, 51):
for y in range(x + 1):
c[x][y] = c[x - 1][y - 1] + c[x - 1][y]
d = [[[[0, float('inf')] for l in range(2)] for i in range(c100 + 1)] for j in range(c50 + 1)]
# d[i][j][c] ответ, когда мы переправили i по 50 кг и j по 100 кг и лодка на берегу c
d[0][0][0][0] = 1
d[0][0][0][1] = 0
q = deque()
q.append([0, 0, 0])
while len(q) > 0:
i, j, shore = q.popleft()
if d[i][j][shore][1] == float('inf'):
continue
for fifty in range(c50 - i + 1 if shore == 0 else i + 1):
for hundreds in range(c100 - j + 1 if shore == 0 else j + 1):
if fifty * 50 + hundreds * 100 > k or fifty + hundreds == 0:
continue
i1 = i + fifty if shore == 0 else i - fifty
j1 = j + hundreds if shore == 0 else j - hundreds
if d[i1][j1][1 ^ shore][1] > d[i][j][shore][1] + 1:
d[i1][j1][1 ^ shore][1] = d[i][j][shore][1] + 1
d[i1][j1][1 ^ shore][0] = 0
q.append((i1, j1, 1 ^ shore) )
if d[i1][j1][1 ^ shore][1] < d[i][j][shore][1] + 1:
continue
koeff = (c[c50 - i][fifty] if shore == 0 else c[i][fifty]) * (
c[c100 - j][hundreds] if shore == 0 else c[j][hundreds])
d[i1][j1][1 ^ shore][0] += d[i][j][shore][0] * koeff
if d[c50][c100][1][1] == float('inf'):
print(-1)
print(0)
else:
print(d[c50][c100][1][1])
print(d[c50][c100][1][0])
```
No
| 88,717 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As a tradition, every year before IOI all the members of Natalia Fan Club are invited to Malek Dance Club to have a fun night together. Malek Dance Club has 2n members and coincidentally Natalia Fan Club also has 2n members. Each member of MDC is assigned a unique id i from 0 to 2n - 1. The same holds for each member of NFC.
One of the parts of this tradition is one by one dance, where each member of MDC dances with a member of NFC. A dance pair is a pair of numbers (a, b) such that member a from MDC dances with member b from NFC.
The complexity of a pairs' assignment is the number of pairs of dancing pairs (a, b) and (c, d) such that a < c and b > d.
You are given a binary number of length n named x. We know that member i from MDC dances with member <image> from NFC. Your task is to calculate the complexity of this assignment modulo 1000000007 (109 + 7).
Expression <image> denotes applying «XOR» to numbers x and y. This operation exists in all modern programming languages, for example, in C++ and Java it denotes as «^», in Pascal — «xor».
Input
The first line of input contains a binary number x of lenght n, (1 ≤ n ≤ 100).
This number may contain leading zeros.
Output
Print the complexity of the given dance assignent modulo 1000000007 (109 + 7).
Examples
Input
11
Output
6
Input
01
Output
2
Input
1
Output
1
Tags: combinatorics, math
Correct Solution:
```
s = input()
new_s = ""
n = len(s)
for i in range(n - 1, -1, -1):
new_s += s[i]
s = new_s
kek = 0
for i in range(n):
kek += (1 << i) * (s[i] == '1')
for i in range(n - 1):
kek *= 2
print(kek % (10 ** 9 + 7))
```
| 88,718 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As a tradition, every year before IOI all the members of Natalia Fan Club are invited to Malek Dance Club to have a fun night together. Malek Dance Club has 2n members and coincidentally Natalia Fan Club also has 2n members. Each member of MDC is assigned a unique id i from 0 to 2n - 1. The same holds for each member of NFC.
One of the parts of this tradition is one by one dance, where each member of MDC dances with a member of NFC. A dance pair is a pair of numbers (a, b) such that member a from MDC dances with member b from NFC.
The complexity of a pairs' assignment is the number of pairs of dancing pairs (a, b) and (c, d) such that a < c and b > d.
You are given a binary number of length n named x. We know that member i from MDC dances with member <image> from NFC. Your task is to calculate the complexity of this assignment modulo 1000000007 (109 + 7).
Expression <image> denotes applying «XOR» to numbers x and y. This operation exists in all modern programming languages, for example, in C++ and Java it denotes as «^», in Pascal — «xor».
Input
The first line of input contains a binary number x of lenght n, (1 ≤ n ≤ 100).
This number may contain leading zeros.
Output
Print the complexity of the given dance assignent modulo 1000000007 (109 + 7).
Examples
Input
11
Output
6
Input
01
Output
2
Input
1
Output
1
Tags: combinatorics, math
Correct Solution:
```
pri=pow(10,9)+7
s=input()
m=len(s)
val=int(s,2)
print((pow(2,m-1,pri)*val)%pri)
```
| 88,719 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As a tradition, every year before IOI all the members of Natalia Fan Club are invited to Malek Dance Club to have a fun night together. Malek Dance Club has 2n members and coincidentally Natalia Fan Club also has 2n members. Each member of MDC is assigned a unique id i from 0 to 2n - 1. The same holds for each member of NFC.
One of the parts of this tradition is one by one dance, where each member of MDC dances with a member of NFC. A dance pair is a pair of numbers (a, b) such that member a from MDC dances with member b from NFC.
The complexity of a pairs' assignment is the number of pairs of dancing pairs (a, b) and (c, d) such that a < c and b > d.
You are given a binary number of length n named x. We know that member i from MDC dances with member <image> from NFC. Your task is to calculate the complexity of this assignment modulo 1000000007 (109 + 7).
Expression <image> denotes applying «XOR» to numbers x and y. This operation exists in all modern programming languages, for example, in C++ and Java it denotes as «^», in Pascal — «xor».
Input
The first line of input contains a binary number x of lenght n, (1 ≤ n ≤ 100).
This number may contain leading zeros.
Output
Print the complexity of the given dance assignent modulo 1000000007 (109 + 7).
Examples
Input
11
Output
6
Input
01
Output
2
Input
1
Output
1
Tags: combinatorics, math
Correct Solution:
```
s,m,ans=input()[::-1],int(1e9+7),0
for i in range(len(s)):
if s[i]=='1':ans=(ans+pow(2,i,m))%m
print(ans*pow(2,len(s)-1,m)%m)
```
| 88,720 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As a tradition, every year before IOI all the members of Natalia Fan Club are invited to Malek Dance Club to have a fun night together. Malek Dance Club has 2n members and coincidentally Natalia Fan Club also has 2n members. Each member of MDC is assigned a unique id i from 0 to 2n - 1. The same holds for each member of NFC.
One of the parts of this tradition is one by one dance, where each member of MDC dances with a member of NFC. A dance pair is a pair of numbers (a, b) such that member a from MDC dances with member b from NFC.
The complexity of a pairs' assignment is the number of pairs of dancing pairs (a, b) and (c, d) such that a < c and b > d.
You are given a binary number of length n named x. We know that member i from MDC dances with member <image> from NFC. Your task is to calculate the complexity of this assignment modulo 1000000007 (109 + 7).
Expression <image> denotes applying «XOR» to numbers x and y. This operation exists in all modern programming languages, for example, in C++ and Java it denotes as «^», in Pascal — «xor».
Input
The first line of input contains a binary number x of lenght n, (1 ≤ n ≤ 100).
This number may contain leading zeros.
Output
Print the complexity of the given dance assignent modulo 1000000007 (109 + 7).
Examples
Input
11
Output
6
Input
01
Output
2
Input
1
Output
1
Tags: combinatorics, math
Correct Solution:
```
n = input().strip()
s = len(n)
k = int(n,2)
start = 4 **( s-1)
zib = 2**(s-1)
step = 2**(s-1)
print((start+(k-zib)*step)%(10**9+7))
```
| 88,721 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As a tradition, every year before IOI all the members of Natalia Fan Club are invited to Malek Dance Club to have a fun night together. Malek Dance Club has 2n members and coincidentally Natalia Fan Club also has 2n members. Each member of MDC is assigned a unique id i from 0 to 2n - 1. The same holds for each member of NFC.
One of the parts of this tradition is one by one dance, where each member of MDC dances with a member of NFC. A dance pair is a pair of numbers (a, b) such that member a from MDC dances with member b from NFC.
The complexity of a pairs' assignment is the number of pairs of dancing pairs (a, b) and (c, d) such that a < c and b > d.
You are given a binary number of length n named x. We know that member i from MDC dances with member <image> from NFC. Your task is to calculate the complexity of this assignment modulo 1000000007 (109 + 7).
Expression <image> denotes applying «XOR» to numbers x and y. This operation exists in all modern programming languages, for example, in C++ and Java it denotes as «^», in Pascal — «xor».
Input
The first line of input contains a binary number x of lenght n, (1 ≤ n ≤ 100).
This number may contain leading zeros.
Output
Print the complexity of the given dance assignent modulo 1000000007 (109 + 7).
Examples
Input
11
Output
6
Input
01
Output
2
Input
1
Output
1
Tags: combinatorics, math
Correct Solution:
```
#!/usr/bin/env python3
p = 1000000007
s = input()
print(int(s,2) * pow(2, len(s) - 1) % p)
```
| 88,722 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As a tradition, every year before IOI all the members of Natalia Fan Club are invited to Malek Dance Club to have a fun night together. Malek Dance Club has 2n members and coincidentally Natalia Fan Club also has 2n members. Each member of MDC is assigned a unique id i from 0 to 2n - 1. The same holds for each member of NFC.
One of the parts of this tradition is one by one dance, where each member of MDC dances with a member of NFC. A dance pair is a pair of numbers (a, b) such that member a from MDC dances with member b from NFC.
The complexity of a pairs' assignment is the number of pairs of dancing pairs (a, b) and (c, d) such that a < c and b > d.
You are given a binary number of length n named x. We know that member i from MDC dances with member <image> from NFC. Your task is to calculate the complexity of this assignment modulo 1000000007 (109 + 7).
Expression <image> denotes applying «XOR» to numbers x and y. This operation exists in all modern programming languages, for example, in C++ and Java it denotes as «^», in Pascal — «xor».
Input
The first line of input contains a binary number x of lenght n, (1 ≤ n ≤ 100).
This number may contain leading zeros.
Output
Print the complexity of the given dance assignent modulo 1000000007 (109 + 7).
Examples
Input
11
Output
6
Input
01
Output
2
Input
1
Output
1
Tags: combinatorics, math
Correct Solution:
```
p = 1000000007
s = input()
print(int(s,2) * pow(2, len(s) - 1) % p)
```
| 88,723 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As a tradition, every year before IOI all the members of Natalia Fan Club are invited to Malek Dance Club to have a fun night together. Malek Dance Club has 2n members and coincidentally Natalia Fan Club also has 2n members. Each member of MDC is assigned a unique id i from 0 to 2n - 1. The same holds for each member of NFC.
One of the parts of this tradition is one by one dance, where each member of MDC dances with a member of NFC. A dance pair is a pair of numbers (a, b) such that member a from MDC dances with member b from NFC.
The complexity of a pairs' assignment is the number of pairs of dancing pairs (a, b) and (c, d) such that a < c and b > d.
You are given a binary number of length n named x. We know that member i from MDC dances with member <image> from NFC. Your task is to calculate the complexity of this assignment modulo 1000000007 (109 + 7).
Expression <image> denotes applying «XOR» to numbers x and y. This operation exists in all modern programming languages, for example, in C++ and Java it denotes as «^», in Pascal — «xor».
Input
The first line of input contains a binary number x of lenght n, (1 ≤ n ≤ 100).
This number may contain leading zeros.
Output
Print the complexity of the given dance assignent modulo 1000000007 (109 + 7).
Examples
Input
11
Output
6
Input
01
Output
2
Input
1
Output
1
Tags: combinatorics, math
Correct Solution:
```
#t=int(input())
mod = 10**9+7
for _ in range(1):
s=input()
c=1
ans = 0
for i in range(len(s)-1,-1,-1):
ans=(ans+c*int(s[i]))%mod
c=(c*2)%mod
d = pow(2,len(s),mod)
ans=(ans*d)%mod
ans=(ans*pow(2,mod-2,mod))%mod
print(ans)
```
| 88,724 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As a tradition, every year before IOI all the members of Natalia Fan Club are invited to Malek Dance Club to have a fun night together. Malek Dance Club has 2n members and coincidentally Natalia Fan Club also has 2n members. Each member of MDC is assigned a unique id i from 0 to 2n - 1. The same holds for each member of NFC.
One of the parts of this tradition is one by one dance, where each member of MDC dances with a member of NFC. A dance pair is a pair of numbers (a, b) such that member a from MDC dances with member b from NFC.
The complexity of a pairs' assignment is the number of pairs of dancing pairs (a, b) and (c, d) such that a < c and b > d.
You are given a binary number of length n named x. We know that member i from MDC dances with member <image> from NFC. Your task is to calculate the complexity of this assignment modulo 1000000007 (109 + 7).
Expression <image> denotes applying «XOR» to numbers x and y. This operation exists in all modern programming languages, for example, in C++ and Java it denotes as «^», in Pascal — «xor».
Input
The first line of input contains a binary number x of lenght n, (1 ≤ n ≤ 100).
This number may contain leading zeros.
Output
Print the complexity of the given dance assignent modulo 1000000007 (109 + 7).
Examples
Input
11
Output
6
Input
01
Output
2
Input
1
Output
1
Tags: combinatorics, math
Correct Solution:
```
s = input()
res = pow(2, len(s)-1)*(int(s, 2))
print (res%1000000007)
```
| 88,725 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As a tradition, every year before IOI all the members of Natalia Fan Club are invited to Malek Dance Club to have a fun night together. Malek Dance Club has 2n members and coincidentally Natalia Fan Club also has 2n members. Each member of MDC is assigned a unique id i from 0 to 2n - 1. The same holds for each member of NFC.
One of the parts of this tradition is one by one dance, where each member of MDC dances with a member of NFC. A dance pair is a pair of numbers (a, b) such that member a from MDC dances with member b from NFC.
The complexity of a pairs' assignment is the number of pairs of dancing pairs (a, b) and (c, d) such that a < c and b > d.
You are given a binary number of length n named x. We know that member i from MDC dances with member <image> from NFC. Your task is to calculate the complexity of this assignment modulo 1000000007 (109 + 7).
Expression <image> denotes applying «XOR» to numbers x and y. This operation exists in all modern programming languages, for example, in C++ and Java it denotes as «^», in Pascal — «xor».
Input
The first line of input contains a binary number x of lenght n, (1 ≤ n ≤ 100).
This number may contain leading zeros.
Output
Print the complexity of the given dance assignent modulo 1000000007 (109 + 7).
Examples
Input
11
Output
6
Input
01
Output
2
Input
1
Output
1
Submitted Solution:
```
MOD = 1000000007
s = input()
n = len(s)
p = [1]
for i in range(301):
p.append((2*p[-1]) %MOD)
res = 0
m = n
g = 0
for i in range(n):
if s[i] == '1':
res += (p[g] * (p[2*m-2]%MOD)) % MOD
res = res % MOD
g += 1
m -= 1
print(res)
```
Yes
| 88,726 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As a tradition, every year before IOI all the members of Natalia Fan Club are invited to Malek Dance Club to have a fun night together. Malek Dance Club has 2n members and coincidentally Natalia Fan Club also has 2n members. Each member of MDC is assigned a unique id i from 0 to 2n - 1. The same holds for each member of NFC.
One of the parts of this tradition is one by one dance, where each member of MDC dances with a member of NFC. A dance pair is a pair of numbers (a, b) such that member a from MDC dances with member b from NFC.
The complexity of a pairs' assignment is the number of pairs of dancing pairs (a, b) and (c, d) such that a < c and b > d.
You are given a binary number of length n named x. We know that member i from MDC dances with member <image> from NFC. Your task is to calculate the complexity of this assignment modulo 1000000007 (109 + 7).
Expression <image> denotes applying «XOR» to numbers x and y. This operation exists in all modern programming languages, for example, in C++ and Java it denotes as «^», in Pascal — «xor».
Input
The first line of input contains a binary number x of lenght n, (1 ≤ n ≤ 100).
This number may contain leading zeros.
Output
Print the complexity of the given dance assignent modulo 1000000007 (109 + 7).
Examples
Input
11
Output
6
Input
01
Output
2
Input
1
Output
1
Submitted Solution:
```
mod = 10 ** 9 + 7
x = input()[::-1]
n = len(x)
ans = 0
for i, t in enumerate(x):
if t == '1':
ans = (ans + pow(2, n - 1 + i)) % mod
print(ans)
```
Yes
| 88,727 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As a tradition, every year before IOI all the members of Natalia Fan Club are invited to Malek Dance Club to have a fun night together. Malek Dance Club has 2n members and coincidentally Natalia Fan Club also has 2n members. Each member of MDC is assigned a unique id i from 0 to 2n - 1. The same holds for each member of NFC.
One of the parts of this tradition is one by one dance, where each member of MDC dances with a member of NFC. A dance pair is a pair of numbers (a, b) such that member a from MDC dances with member b from NFC.
The complexity of a pairs' assignment is the number of pairs of dancing pairs (a, b) and (c, d) such that a < c and b > d.
You are given a binary number of length n named x. We know that member i from MDC dances with member <image> from NFC. Your task is to calculate the complexity of this assignment modulo 1000000007 (109 + 7).
Expression <image> denotes applying «XOR» to numbers x and y. This operation exists in all modern programming languages, for example, in C++ and Java it denotes as «^», in Pascal — «xor».
Input
The first line of input contains a binary number x of lenght n, (1 ≤ n ≤ 100).
This number may contain leading zeros.
Output
Print the complexity of the given dance assignent modulo 1000000007 (109 + 7).
Examples
Input
11
Output
6
Input
01
Output
2
Input
1
Output
1
Submitted Solution:
```
x = input()
n = len(x)
mod = 10 ** 9 + 7
ans = 0
for i in range(n):
if x[i] == '1':
pref = pow(2, i, mod)
suf = pow(2, n - i - 1, mod) ** 2
ans += (pref * suf) % mod
print(ans % mod)
```
Yes
| 88,728 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As a tradition, every year before IOI all the members of Natalia Fan Club are invited to Malek Dance Club to have a fun night together. Malek Dance Club has 2n members and coincidentally Natalia Fan Club also has 2n members. Each member of MDC is assigned a unique id i from 0 to 2n - 1. The same holds for each member of NFC.
One of the parts of this tradition is one by one dance, where each member of MDC dances with a member of NFC. A dance pair is a pair of numbers (a, b) such that member a from MDC dances with member b from NFC.
The complexity of a pairs' assignment is the number of pairs of dancing pairs (a, b) and (c, d) such that a < c and b > d.
You are given a binary number of length n named x. We know that member i from MDC dances with member <image> from NFC. Your task is to calculate the complexity of this assignment modulo 1000000007 (109 + 7).
Expression <image> denotes applying «XOR» to numbers x and y. This operation exists in all modern programming languages, for example, in C++ and Java it denotes as «^», in Pascal — «xor».
Input
The first line of input contains a binary number x of lenght n, (1 ≤ n ≤ 100).
This number may contain leading zeros.
Output
Print the complexity of the given dance assignent modulo 1000000007 (109 + 7).
Examples
Input
11
Output
6
Input
01
Output
2
Input
1
Output
1
Submitted Solution:
```
M = 10 ** 9 + 7
def solve1(x):
n = len(x)
x = int(x, 2)
ans = 0
for a in range(2 ** n):
for c in range(2 ** n):
b = a ^ x
d = c ^ x
if a < c and b > d:
ans += 1
return ans % M
def solve2(x):
return int(x, 2) * pow(2, (len(x) - 1), M) % M
x = input()
# print(solve1(x))
print(solve2(x))
```
Yes
| 88,729 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As a tradition, every year before IOI all the members of Natalia Fan Club are invited to Malek Dance Club to have a fun night together. Malek Dance Club has 2n members and coincidentally Natalia Fan Club also has 2n members. Each member of MDC is assigned a unique id i from 0 to 2n - 1. The same holds for each member of NFC.
One of the parts of this tradition is one by one dance, where each member of MDC dances with a member of NFC. A dance pair is a pair of numbers (a, b) such that member a from MDC dances with member b from NFC.
The complexity of a pairs' assignment is the number of pairs of dancing pairs (a, b) and (c, d) such that a < c and b > d.
You are given a binary number of length n named x. We know that member i from MDC dances with member <image> from NFC. Your task is to calculate the complexity of this assignment modulo 1000000007 (109 + 7).
Expression <image> denotes applying «XOR» to numbers x and y. This operation exists in all modern programming languages, for example, in C++ and Java it denotes as «^», in Pascal — «xor».
Input
The first line of input contains a binary number x of lenght n, (1 ≤ n ≤ 100).
This number may contain leading zeros.
Output
Print the complexity of the given dance assignent modulo 1000000007 (109 + 7).
Examples
Input
11
Output
6
Input
01
Output
2
Input
1
Output
1
Submitted Solution:
```
__inp = input()
len = len(__inp)
x = 0
for i in __inp:
x = x*2 + int(i)
print((len*x) % 1000000007)
```
No
| 88,730 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As a tradition, every year before IOI all the members of Natalia Fan Club are invited to Malek Dance Club to have a fun night together. Malek Dance Club has 2n members and coincidentally Natalia Fan Club also has 2n members. Each member of MDC is assigned a unique id i from 0 to 2n - 1. The same holds for each member of NFC.
One of the parts of this tradition is one by one dance, where each member of MDC dances with a member of NFC. A dance pair is a pair of numbers (a, b) such that member a from MDC dances with member b from NFC.
The complexity of a pairs' assignment is the number of pairs of dancing pairs (a, b) and (c, d) such that a < c and b > d.
You are given a binary number of length n named x. We know that member i from MDC dances with member <image> from NFC. Your task is to calculate the complexity of this assignment modulo 1000000007 (109 + 7).
Expression <image> denotes applying «XOR» to numbers x and y. This operation exists in all modern programming languages, for example, in C++ and Java it denotes as «^», in Pascal — «xor».
Input
The first line of input contains a binary number x of lenght n, (1 ≤ n ≤ 100).
This number may contain leading zeros.
Output
Print the complexity of the given dance assignent modulo 1000000007 (109 + 7).
Examples
Input
11
Output
6
Input
01
Output
2
Input
1
Output
1
Submitted Solution:
```
x =input()
print(int(x,2) << (len(x) - 1))
```
No
| 88,731 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As a tradition, every year before IOI all the members of Natalia Fan Club are invited to Malek Dance Club to have a fun night together. Malek Dance Club has 2n members and coincidentally Natalia Fan Club also has 2n members. Each member of MDC is assigned a unique id i from 0 to 2n - 1. The same holds for each member of NFC.
One of the parts of this tradition is one by one dance, where each member of MDC dances with a member of NFC. A dance pair is a pair of numbers (a, b) such that member a from MDC dances with member b from NFC.
The complexity of a pairs' assignment is the number of pairs of dancing pairs (a, b) and (c, d) such that a < c and b > d.
You are given a binary number of length n named x. We know that member i from MDC dances with member <image> from NFC. Your task is to calculate the complexity of this assignment modulo 1000000007 (109 + 7).
Expression <image> denotes applying «XOR» to numbers x and y. This operation exists in all modern programming languages, for example, in C++ and Java it denotes as «^», in Pascal — «xor».
Input
The first line of input contains a binary number x of lenght n, (1 ≤ n ≤ 100).
This number may contain leading zeros.
Output
Print the complexity of the given dance assignent modulo 1000000007 (109 + 7).
Examples
Input
11
Output
6
Input
01
Output
2
Input
1
Output
1
Submitted Solution:
```
MOD = int(10e9 + 7)
x = input()[::-1]
n = len(x)
res = 0
for i, t in enumerate(x):
if t == '1':
res = (res + (1 << (n - 1 + i))) % MOD
print(res)
```
No
| 88,732 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As a tradition, every year before IOI all the members of Natalia Fan Club are invited to Malek Dance Club to have a fun night together. Malek Dance Club has 2n members and coincidentally Natalia Fan Club also has 2n members. Each member of MDC is assigned a unique id i from 0 to 2n - 1. The same holds for each member of NFC.
One of the parts of this tradition is one by one dance, where each member of MDC dances with a member of NFC. A dance pair is a pair of numbers (a, b) such that member a from MDC dances with member b from NFC.
The complexity of a pairs' assignment is the number of pairs of dancing pairs (a, b) and (c, d) such that a < c and b > d.
You are given a binary number of length n named x. We know that member i from MDC dances with member <image> from NFC. Your task is to calculate the complexity of this assignment modulo 1000000007 (109 + 7).
Expression <image> denotes applying «XOR» to numbers x and y. This operation exists in all modern programming languages, for example, in C++ and Java it denotes as «^», in Pascal — «xor».
Input
The first line of input contains a binary number x of lenght n, (1 ≤ n ≤ 100).
This number may contain leading zeros.
Output
Print the complexity of the given dance assignent modulo 1000000007 (109 + 7).
Examples
Input
11
Output
6
Input
01
Output
2
Input
1
Output
1
Submitted Solution:
```
a=input()
print((2**a.count('1')-1)*2**(len(a)-1))
```
No
| 88,733 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mad scientist Mike is building a time machine in his spare time. To finish the work, he needs a resistor with a certain resistance value.
However, all Mike has is lots of identical resistors with unit resistance R0 = 1. Elements with other resistance can be constructed from these resistors. In this problem, we will consider the following as elements:
1. one resistor;
2. an element and one resistor plugged in sequence;
3. an element and one resistor plugged in parallel.
<image>
With the consecutive connection the resistance of the new element equals R = Re + R0. With the parallel connection the resistance of the new element equals <image>. In this case Re equals the resistance of the element being connected.
Mike needs to assemble an element with a resistance equal to the fraction <image>. Determine the smallest possible number of resistors he needs to make such an element.
Input
The single input line contains two space-separated integers a and b (1 ≤ a, b ≤ 1018). It is guaranteed that the fraction <image> is irreducible. It is guaranteed that a solution always exists.
Output
Print a single number — the answer to the problem.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is recommended to use the cin, cout streams or the %I64d specifier.
Examples
Input
1 1
Output
1
Input
3 2
Output
3
Input
199 200
Output
200
Note
In the first sample, one resistor is enough.
In the second sample one can connect the resistors in parallel, take the resulting element and connect it to a third resistor consecutively. Then, we get an element with resistance <image>. We cannot make this element using two resistors.
Tags: math, number theory
Correct Solution:
```
###### ### ####### ####### ## # ##### ### #####
# # # # # # # # # # # # # ###
# # # # # # # # # # # # # ###
###### ######### # # # # # # ######### #
###### ######### # # # # # # ######### #
# # # # # # # # # # #### # # #
# # # # # # # ## # # # # #
###### # # ####### ####### # # ##### # # # #
from __future__ import print_function # for PyPy2
# from itertools import permutations as perm
# from functools import cmp_to_key # for adding custom comparator
# from fractions import Fraction
# from collections import *
from sys import stdin
# from bisect import *
# from heapq import *
# from math import *
g = lambda : stdin.readline().strip()
gl = lambda : g().split()
gil = lambda : [int(var) for var in gl()]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
mod = int(1e9)+7
inf = float("inf")
a, b = gil()
ans = 0
while min(a, b) != 1:
n, d = max(a, b), min(a, b)
ans += n//d
a, b = n%d, d
ans += max(a, b)
print(ans)
```
| 88,734 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mad scientist Mike is building a time machine in his spare time. To finish the work, he needs a resistor with a certain resistance value.
However, all Mike has is lots of identical resistors with unit resistance R0 = 1. Elements with other resistance can be constructed from these resistors. In this problem, we will consider the following as elements:
1. one resistor;
2. an element and one resistor plugged in sequence;
3. an element and one resistor plugged in parallel.
<image>
With the consecutive connection the resistance of the new element equals R = Re + R0. With the parallel connection the resistance of the new element equals <image>. In this case Re equals the resistance of the element being connected.
Mike needs to assemble an element with a resistance equal to the fraction <image>. Determine the smallest possible number of resistors he needs to make such an element.
Input
The single input line contains two space-separated integers a and b (1 ≤ a, b ≤ 1018). It is guaranteed that the fraction <image> is irreducible. It is guaranteed that a solution always exists.
Output
Print a single number — the answer to the problem.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is recommended to use the cin, cout streams or the %I64d specifier.
Examples
Input
1 1
Output
1
Input
3 2
Output
3
Input
199 200
Output
200
Note
In the first sample, one resistor is enough.
In the second sample one can connect the resistors in parallel, take the resulting element and connect it to a third resistor consecutively. Then, we get an element with resistance <image>. We cannot make this element using two resistors.
Tags: math, number theory
Correct Solution:
```
def sol(a,b):
global ans
ans+=a//b
a=a%b
if a==0:
return 0
return sol(b,a)
ans=0
a,b=map(int,input().split())
sol(max(a,b),min(a,b))
print(ans)
```
| 88,735 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mad scientist Mike is building a time machine in his spare time. To finish the work, he needs a resistor with a certain resistance value.
However, all Mike has is lots of identical resistors with unit resistance R0 = 1. Elements with other resistance can be constructed from these resistors. In this problem, we will consider the following as elements:
1. one resistor;
2. an element and one resistor plugged in sequence;
3. an element and one resistor plugged in parallel.
<image>
With the consecutive connection the resistance of the new element equals R = Re + R0. With the parallel connection the resistance of the new element equals <image>. In this case Re equals the resistance of the element being connected.
Mike needs to assemble an element with a resistance equal to the fraction <image>. Determine the smallest possible number of resistors he needs to make such an element.
Input
The single input line contains two space-separated integers a and b (1 ≤ a, b ≤ 1018). It is guaranteed that the fraction <image> is irreducible. It is guaranteed that a solution always exists.
Output
Print a single number — the answer to the problem.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is recommended to use the cin, cout streams or the %I64d specifier.
Examples
Input
1 1
Output
1
Input
3 2
Output
3
Input
199 200
Output
200
Note
In the first sample, one resistor is enough.
In the second sample one can connect the resistors in parallel, take the resulting element and connect it to a third resistor consecutively. Then, we get an element with resistance <image>. We cannot make this element using two resistors.
Tags: math, number theory
Correct Solution:
```
a=[0]+[int(i)for i in input().split()]
while a[1]*a[2]!=0:
a=[a[0]+a[1]//a[2],a[2],a[1]%a[2]]
print(a[0])
```
| 88,736 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mad scientist Mike is building a time machine in his spare time. To finish the work, he needs a resistor with a certain resistance value.
However, all Mike has is lots of identical resistors with unit resistance R0 = 1. Elements with other resistance can be constructed from these resistors. In this problem, we will consider the following as elements:
1. one resistor;
2. an element and one resistor plugged in sequence;
3. an element and one resistor plugged in parallel.
<image>
With the consecutive connection the resistance of the new element equals R = Re + R0. With the parallel connection the resistance of the new element equals <image>. In this case Re equals the resistance of the element being connected.
Mike needs to assemble an element with a resistance equal to the fraction <image>. Determine the smallest possible number of resistors he needs to make such an element.
Input
The single input line contains two space-separated integers a and b (1 ≤ a, b ≤ 1018). It is guaranteed that the fraction <image> is irreducible. It is guaranteed that a solution always exists.
Output
Print a single number — the answer to the problem.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is recommended to use the cin, cout streams or the %I64d specifier.
Examples
Input
1 1
Output
1
Input
3 2
Output
3
Input
199 200
Output
200
Note
In the first sample, one resistor is enough.
In the second sample one can connect the resistors in parallel, take the resulting element and connect it to a third resistor consecutively. Then, we get an element with resistance <image>. We cannot make this element using two resistors.
Tags: math, number theory
Correct Solution:
```
a,b=map(int,input().split())
ans=0
while a and b:
ans+=a//b
a,b=b,a%b
print(ans)
```
| 88,737 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mad scientist Mike is building a time machine in his spare time. To finish the work, he needs a resistor with a certain resistance value.
However, all Mike has is lots of identical resistors with unit resistance R0 = 1. Elements with other resistance can be constructed from these resistors. In this problem, we will consider the following as elements:
1. one resistor;
2. an element and one resistor plugged in sequence;
3. an element and one resistor plugged in parallel.
<image>
With the consecutive connection the resistance of the new element equals R = Re + R0. With the parallel connection the resistance of the new element equals <image>. In this case Re equals the resistance of the element being connected.
Mike needs to assemble an element with a resistance equal to the fraction <image>. Determine the smallest possible number of resistors he needs to make such an element.
Input
The single input line contains two space-separated integers a and b (1 ≤ a, b ≤ 1018). It is guaranteed that the fraction <image> is irreducible. It is guaranteed that a solution always exists.
Output
Print a single number — the answer to the problem.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is recommended to use the cin, cout streams or the %I64d specifier.
Examples
Input
1 1
Output
1
Input
3 2
Output
3
Input
199 200
Output
200
Note
In the first sample, one resistor is enough.
In the second sample one can connect the resistors in parallel, take the resulting element and connect it to a third resistor consecutively. Then, we get an element with resistance <image>. We cannot make this element using two resistors.
Tags: math, number theory
Correct Solution:
```
#!/usr/bin/env python
from __future__ import division, print_function
import math
import os
import sys
from fractions import *
from sys import *
from decimal import *
from io import BytesIO, IOBase
from itertools import *
from collections import *
# sys.setrecursionlimit(10**5)
M = 10 ** 9 + 7
# print(math.factorial(5))
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
# sys.setrecursionlimit(10**6)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def inp(): return sys.stdin.readline().rstrip("\r\n") # for fast input
def out(var): sys.stdout.write(str(var)) # for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
def fsep(): return map(float, inp().split())
def inpu(): return int(inp())
# -----------------------------------------------------------------
def regularbracket(t):
p = 0
for i in t:
if i == "(":
p += 1
else:
p -= 1
if p < 0:
return False
else:
if p > 0:
return False
else:
return True
# -------------------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] <= key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# ------------------------------reverse string(pallindrome)
def reverse1(string):
pp = ""
for i in string[::-1]:
pp += i
if pp == string:
return True
return False
# --------------------------------reverse list(paindrome)
def reverse2(list1):
l = []
for i in list1[::-1]:
l.append(i)
if l == list1:
return True
return False
def mex(list1):
# list1 = sorted(list1)
p = max(list1) + 1
for i in range(len(list1)):
if list1[i] != i:
p = i
break
return p
def sumofdigits(n):
n = str(n)
s1 = 0
for i in n:
s1 += int(i)
return s1
def perfect_square(n):
s = math.sqrt(n)
if s == int(s):
return True
return False
# -----------------------------roman
def roman_number(x):
if x > 15999:
return
value = [5000, 4000, 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
symbol = ["F", "MF", "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"]
roman = ""
i = 0
while x > 0:
div = x // value[i]
x = x % value[i]
while div:
roman += symbol[i]
div -= 1
i += 1
return roman
def soretd(s):
for i in range(1, len(s)):
if s[i - 1] > s[i]:
return False
return True
# print(soretd("1"))
# ---------------------------
def countRhombi(h, w):
ct = 0
for i in range(2, h + 1, 2):
for j in range(2, w + 1, 2):
ct += (h - i + 1) * (w - j + 1)
return ct
def countrhombi2(h, w):
return ((h * h) // 4) * ((w * w) // 4)
# ---------------------------------
def binpow(a, b):
if b == 0:
return 1
else:
res = binpow(a, b // 2)
if b % 2 != 0:
return res * res * a
else:
return res * res
# -------------------------------------------------------
def binpowmodulus(a, b, m):
a %= m
res = 1
while (b > 0):
if (b & 1):
res = res * a % m
a = a * a % m
b >>= 1
return res
# -------------------------------------------------------------
def coprime_to_n(n):
result = n
i = 2
while (i * i <= n):
if (n % i == 0):
while (n % i == 0):
n //= i
result -= result // i
i += 1
if (n > 1):
result -= result // n
return result
# -------------------prime
def prime(x):
if x == 1:
return False
else:
for i in range(2, int(math.sqrt(x)) + 1):
# print(x)
if (x % i == 0):
return False
else:
return True
def luckynumwithequalnumberoffourandseven(x, n, a):
if x >= n and str(x).count("4") == str(x).count("7"):
a.append(x)
else:
if x < 1e12:
luckynumwithequalnumberoffourandseven(x * 10 + 4, n, a)
luckynumwithequalnumberoffourandseven(x * 10 + 7, n, a)
return a
def luckynuber(x, n, a):
p = set(str(x))
if len(p) <= 2:
a.append(x)
if x < n:
luckynuber(x + 1, n, a)
return a
# ------------------------------------------------------interactive problems
def interact(type, x):
if type == "r":
inp = input()
return inp.strip()
else:
print(x, flush=True)
# ------------------------------------------------------------------zero at end of factorial of a number
def findTrailingZeros(n):
# Initialize result
count = 0
# Keep dividing n by
# 5 & update Count
while (n >= 5):
n //= 5
count += n
return count
# -----------------------------------------------merge sort
# Python program for implementation of MergeSort
def mergeSort(arr):
if len(arr) > 1:
# Finding the mid of the array
mid = len(arr) // 2
# Dividing the array elements
L = arr[:mid]
# into 2 halves
R = arr[mid:]
# Sorting the first half
mergeSort(L)
# Sorting the second half
mergeSort(R)
i = j = k = 0
# Copy data to temp arrays L[] and R[]
while i < len(L) and j < len(R):
if L[i] < R[j]:
arr[k] = L[i]
i += 1
else:
arr[k] = R[j]
j += 1
k += 1
# Checking if any element was left
while i < len(L):
arr[k] = L[i]
i += 1
k += 1
while j < len(R):
arr[k] = R[j]
j += 1
k += 1
# -----------------------------------------------lucky number with two lucky any digits
res = set()
def solven(p, l, a, b, n): # given number
if p > n or l > 10:
return
if p > 0:
res.add(p)
solven(p * 10 + a, l + 1, a, b, n)
solven(p * 10 + b, l + 1, a, b, n)
# problem
"""
n = int(input())
for a in range(0, 10):
for b in range(0, a):
solve(0, 0)
print(len(res))
"""
# Python3 program to find all subsets
# by backtracking.
# In the array A at every step we have two
# choices for each element either we can
# ignore the element or we can include the
# element in our subset
def subsetsUtil(A, subset, index, d):
print(*subset)
s = sum(subset)
d.append(s)
for i in range(index, len(A)):
# include the A[i] in subset.
subset.append(A[i])
# move onto the next element.
subsetsUtil(A, subset, i + 1, d)
# exclude the A[i] from subset and
# triggers backtracking.
subset.pop(-1)
return d
def subsetSums(arr, l, r, d, sum=0):
if l > r:
d.append(sum)
return
subsetSums(arr, l + 1, r, d, sum + arr[l])
# Subset excluding arr[l]
subsetSums(arr, l + 1, r, d, sum)
return d
def print_factors(x):
factors = []
for i in range(1, x + 1):
if x % i == 0:
factors.append(i)
return (factors)
# -----------------------------------------------
def calc(X, d, ans, D):
# print(X,d)
if len(X) == 0:
return
i = X.index(max(X))
ans[D[max(X)]] = d
Y = X[:i]
Z = X[i + 1:]
calc(Y, d + 1, ans, D)
calc(Z, d + 1, ans, D)
# ---------------------------------------
def factorization(n, l):
c = n
if prime(n) == True:
l.append(n)
return l
for i in range(2, c):
if n == 1:
break
while n % i == 0:
l.append(i)
n = n // i
return l
# endregion------------------------------
def good(b):
l = []
i = 0
while (len(b) != 0):
if b[i] < b[len(b) - 1 - i]:
l.append(b[i])
b.remove(b[i])
else:
l.append(b[len(b) - 1 - i])
b.remove(b[len(b) - 1 - i])
if l == sorted(l):
# print(l)
return True
return False
# arr=[]
# print(good(arr))
def generate(st, s):
if len(s) == 0:
return
# If current string is not already present.
if s not in st:
st.add(s)
# Traverse current string, one by one
# remove every character and recur.
for i in range(len(s)):
t = list(s).copy()
t.remove(s[i])
t = ''.join(t)
generate(st, t)
return
#=--------------------------------------------longest increasing subsequence
def largestincreasingsubsequence(A):
l = [1]*len(A)
sub=[]
for i in range(1,len(l)):
for k in range(i):
if A[k]<A[i]:
sub.append(l[k])
l[i]=1+max(sub,default=0)
return max(l,default=0)
#----------------------------------longest palindromic substring
# Python3 program for the
# above approach
# Function to calculate
# Bitwise OR of sums of
# all subsequences
def findOR(nums, N):
# Stores the prefix
# sum of nums[]
prefix_sum = 0
# Stores the bitwise OR of
# sum of each subsequence
result = 0
# Iterate through array nums[]
for i in range(N):
# Bits set in nums[i] are
# also set in result
result |= nums[i]
# Calculate prefix_sum
prefix_sum += nums[i]
# Bits set in prefix_sum
# are also set in result
result |= prefix_sum
# Return the result
return result
#l=[]
def OR(a, n):
ans = a[0]
for i in range(1, n):
ans |= a[i]
#l.append(ans)
return ans
"""
def main():
n = inpu()
arr = lis()
l=[]
p=[]
q=[]
for i in range(len(arr)):
q.append([arr[i],i+1])
#print(q)
q.sort()
#print(q)
for i in range(0,n,2):
l.append(q[i][1])
for i in range(1,n,2):
p.append(q[i][1])
print(len(l))
print(*l)
print(len(p))
print(*p)
if __name__ == '__main__':
main()
"""
"""
def main():
n=inpu()
arr = lis()
a=0
b=sum(arr)
cnt=0
for i in range(len(arr)):
a+=arr[i]
b-=arr[i]
#print(a,b)
if a==b:
cnt+=1
if a!=0:
print(cnt)
else:
print(cnt-1)
if __name__ == '__main__':
main()
"""
"""
def main():
n = inpu()
arr = lis()
print(max(((sum(arr) - 1) // (n - 1)) + 1, max(arr)))
if __name__ == '__main__':
main()
"""
"""
def main():
n = int(input())
val = [0] * (n + 1)
add = [0] * (n + 1)
ptr = 1
sum = 0
res = [0] * n
for i in range(n):
l = lis()
if l[0] == 1:
a, x = l[1:]
add[a - 1] += x
sum += a * x
elif l[0] == 2:
k = l[1]
val[ptr] = k
sum += k
ptr += 1
else:
ptr -= 1
sum -= val[ptr]
sum -= add[ptr]
add[ptr - 1] += add[ptr]
add[ptr] = 0
res[i] = sum / ptr
print('\n'.join(str(x) for x in res))
if __name__ == '__main__':
main()
"""
"""
def main():
n,k=sep()
arr=lis()
arr = sorted(arr)
l = 0
s = 0
ans = 1
best = arr[0]
for i in range(1, n):
s += (i - l) * (arr[i] - arr[i - 1])
while s > k:
s -= arr[i] - arr[l]
l += 1
if i - l + 1 > ans:
ans = i - l + 1
best = arr[i]
print(ans, best)
if __name__ == '__main__':
main()
"""
def main():
a,b = sep()
cnt=0
while(b!=0):
cnt+=(a//b)
a,b = b,a%b
print(cnt)
if __name__ == '__main__':
main()
```
| 88,738 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mad scientist Mike is building a time machine in his spare time. To finish the work, he needs a resistor with a certain resistance value.
However, all Mike has is lots of identical resistors with unit resistance R0 = 1. Elements with other resistance can be constructed from these resistors. In this problem, we will consider the following as elements:
1. one resistor;
2. an element and one resistor plugged in sequence;
3. an element and one resistor plugged in parallel.
<image>
With the consecutive connection the resistance of the new element equals R = Re + R0. With the parallel connection the resistance of the new element equals <image>. In this case Re equals the resistance of the element being connected.
Mike needs to assemble an element with a resistance equal to the fraction <image>. Determine the smallest possible number of resistors he needs to make such an element.
Input
The single input line contains two space-separated integers a and b (1 ≤ a, b ≤ 1018). It is guaranteed that the fraction <image> is irreducible. It is guaranteed that a solution always exists.
Output
Print a single number — the answer to the problem.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is recommended to use the cin, cout streams or the %I64d specifier.
Examples
Input
1 1
Output
1
Input
3 2
Output
3
Input
199 200
Output
200
Note
In the first sample, one resistor is enough.
In the second sample one can connect the resistors in parallel, take the resulting element and connect it to a third resistor consecutively. Then, we get an element with resistance <image>. We cannot make this element using two resistors.
Tags: math, number theory
Correct Solution:
```
import sys
import math
MAXNUM = math.inf
MINNUM = -1 * math.inf
def getInts():
return map(int, sys.stdin.readline().rstrip().split(" "))
def getString():
return sys.stdin.readline().rstrip()
def solve(a, b):
counter = 1
while a != 1 and b != 1: # a num b denom
if a > b: # num greater than denom, so subtract by 1
diff = a // b
a -= b * diff
counter += diff
else: # denom > num
diff = b // a
b -= a * diff
counter += diff
if a > 1:
counter += a - 1
if b > 1:
counter += b - 1
return counter
def printOutput(ans):
sys.stdout.write(str(ans) + "\n") # add to me
def readinput():
a, b = getInts()
printOutput(solve(a, b))
readinput()
```
| 88,739 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mad scientist Mike is building a time machine in his spare time. To finish the work, he needs a resistor with a certain resistance value.
However, all Mike has is lots of identical resistors with unit resistance R0 = 1. Elements with other resistance can be constructed from these resistors. In this problem, we will consider the following as elements:
1. one resistor;
2. an element and one resistor plugged in sequence;
3. an element and one resistor plugged in parallel.
<image>
With the consecutive connection the resistance of the new element equals R = Re + R0. With the parallel connection the resistance of the new element equals <image>. In this case Re equals the resistance of the element being connected.
Mike needs to assemble an element with a resistance equal to the fraction <image>. Determine the smallest possible number of resistors he needs to make such an element.
Input
The single input line contains two space-separated integers a and b (1 ≤ a, b ≤ 1018). It is guaranteed that the fraction <image> is irreducible. It is guaranteed that a solution always exists.
Output
Print a single number — the answer to the problem.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is recommended to use the cin, cout streams or the %I64d specifier.
Examples
Input
1 1
Output
1
Input
3 2
Output
3
Input
199 200
Output
200
Note
In the first sample, one resistor is enough.
In the second sample one can connect the resistors in parallel, take the resulting element and connect it to a third resistor consecutively. Then, we get an element with resistance <image>. We cannot make this element using two resistors.
Tags: math, number theory
Correct Solution:
```
def gcd(a,b):
if b==0: return 0
return a//b+gcd(b,a%b)
a,b=map(int,input().split())
print(gcd(a,b))
```
| 88,740 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mad scientist Mike is building a time machine in his spare time. To finish the work, he needs a resistor with a certain resistance value.
However, all Mike has is lots of identical resistors with unit resistance R0 = 1. Elements with other resistance can be constructed from these resistors. In this problem, we will consider the following as elements:
1. one resistor;
2. an element and one resistor plugged in sequence;
3. an element and one resistor plugged in parallel.
<image>
With the consecutive connection the resistance of the new element equals R = Re + R0. With the parallel connection the resistance of the new element equals <image>. In this case Re equals the resistance of the element being connected.
Mike needs to assemble an element with a resistance equal to the fraction <image>. Determine the smallest possible number of resistors he needs to make such an element.
Input
The single input line contains two space-separated integers a and b (1 ≤ a, b ≤ 1018). It is guaranteed that the fraction <image> is irreducible. It is guaranteed that a solution always exists.
Output
Print a single number — the answer to the problem.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is recommended to use the cin, cout streams or the %I64d specifier.
Examples
Input
1 1
Output
1
Input
3 2
Output
3
Input
199 200
Output
200
Note
In the first sample, one resistor is enough.
In the second sample one can connect the resistors in parallel, take the resulting element and connect it to a third resistor consecutively. Then, we get an element with resistance <image>. We cannot make this element using two resistors.
Tags: math, number theory
Correct Solution:
```
import sys
import string
import math
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
from fractions import Fraction
def mi(s):
return map(int, s.strip().split())
def lmi(s):
return list(mi(s))
def tmi(s):
return tuple(mi(s))
def mf(f, s):
return map(f, s)
def lmf(f, s):
return list(mf(f, s))
def js(lst):
return " ".join(str(d) for d in lst)
def jsns(lst):
return "".join(str(d) for d in lst)
def line():
return sys.stdin.readline().strip()
def linesp():
return line().split()
def iline():
return int(line())
def mat(n):
matr = []
for _ in range(n):
matr.append(linesp())
return matr
def matns(n):
mat = []
for _ in range(n):
mat.append([c for c in line()])
return mat
def mati(n):
mat = []
for _ in range(n):
mat.append(lmi(line()))
return mat
def pmat(mat):
for row in mat:
print(js(row))
def recb(a,b):
# So, can we compute this in constant time.
if a==b:
return 1
elif a>b:
return 1+rec(a-b,b)
else:
return 1+rec(a,b-a)
def rec(a,b):
ans=0
while True:
if a==b:
ans+=1
break
elif a==0 or b==0:
break
if a>b:
k=(a-a%b)//b
a,b=a%b,b
elif a<b:
k=(b-b%a)//a
a,b=a,b%a
ans+=k
return ans
def main():
a,b=mi(line())
print(rec(a,b))
main()
```
| 88,741 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mad scientist Mike is building a time machine in his spare time. To finish the work, he needs a resistor with a certain resistance value.
However, all Mike has is lots of identical resistors with unit resistance R0 = 1. Elements with other resistance can be constructed from these resistors. In this problem, we will consider the following as elements:
1. one resistor;
2. an element and one resistor plugged in sequence;
3. an element and one resistor plugged in parallel.
<image>
With the consecutive connection the resistance of the new element equals R = Re + R0. With the parallel connection the resistance of the new element equals <image>. In this case Re equals the resistance of the element being connected.
Mike needs to assemble an element with a resistance equal to the fraction <image>. Determine the smallest possible number of resistors he needs to make such an element.
Input
The single input line contains two space-separated integers a and b (1 ≤ a, b ≤ 1018). It is guaranteed that the fraction <image> is irreducible. It is guaranteed that a solution always exists.
Output
Print a single number — the answer to the problem.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is recommended to use the cin, cout streams or the %I64d specifier.
Examples
Input
1 1
Output
1
Input
3 2
Output
3
Input
199 200
Output
200
Note
In the first sample, one resistor is enough.
In the second sample one can connect the resistors in parallel, take the resulting element and connect it to a third resistor consecutively. Then, we get an element with resistance <image>. We cannot make this element using two resistors.
Submitted Solution:
```
a, b = map(int, input().split())
ans = 0
while a and b:
if a % b == 0 or b % a == 0:
print(max(a // b, b // a) + ans)
exit(0)
if a - b > 0:
ans += a // b
a, b = a % b, b
else:
ans += b // a
a, b = a, b % a
if a % b == 0:
ans += a // b
else:
ans += b // a
print(ans)
```
Yes
| 88,742 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mad scientist Mike is building a time machine in his spare time. To finish the work, he needs a resistor with a certain resistance value.
However, all Mike has is lots of identical resistors with unit resistance R0 = 1. Elements with other resistance can be constructed from these resistors. In this problem, we will consider the following as elements:
1. one resistor;
2. an element and one resistor plugged in sequence;
3. an element and one resistor plugged in parallel.
<image>
With the consecutive connection the resistance of the new element equals R = Re + R0. With the parallel connection the resistance of the new element equals <image>. In this case Re equals the resistance of the element being connected.
Mike needs to assemble an element with a resistance equal to the fraction <image>. Determine the smallest possible number of resistors he needs to make such an element.
Input
The single input line contains two space-separated integers a and b (1 ≤ a, b ≤ 1018). It is guaranteed that the fraction <image> is irreducible. It is guaranteed that a solution always exists.
Output
Print a single number — the answer to the problem.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is recommended to use the cin, cout streams or the %I64d specifier.
Examples
Input
1 1
Output
1
Input
3 2
Output
3
Input
199 200
Output
200
Note
In the first sample, one resistor is enough.
In the second sample one can connect the resistors in parallel, take the resulting element and connect it to a third resistor consecutively. Then, we get an element with resistance <image>. We cannot make this element using two resistors.
Submitted Solution:
```
from functools import reduce
from operator import *
from math import *
from sys import *
from string import *
setrecursionlimit(10**7)
RI=lambda: list(map(int,input().split()))
RS=lambda: input().rstrip().split()
#################################################
n,m=RI()
ans=0
while m:
ans+=n//m
n,m= m,n%m
print(ans)
```
Yes
| 88,743 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mad scientist Mike is building a time machine in his spare time. To finish the work, he needs a resistor with a certain resistance value.
However, all Mike has is lots of identical resistors with unit resistance R0 = 1. Elements with other resistance can be constructed from these resistors. In this problem, we will consider the following as elements:
1. one resistor;
2. an element and one resistor plugged in sequence;
3. an element and one resistor plugged in parallel.
<image>
With the consecutive connection the resistance of the new element equals R = Re + R0. With the parallel connection the resistance of the new element equals <image>. In this case Re equals the resistance of the element being connected.
Mike needs to assemble an element with a resistance equal to the fraction <image>. Determine the smallest possible number of resistors he needs to make such an element.
Input
The single input line contains two space-separated integers a and b (1 ≤ a, b ≤ 1018). It is guaranteed that the fraction <image> is irreducible. It is guaranteed that a solution always exists.
Output
Print a single number — the answer to the problem.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is recommended to use the cin, cout streams or the %I64d specifier.
Examples
Input
1 1
Output
1
Input
3 2
Output
3
Input
199 200
Output
200
Note
In the first sample, one resistor is enough.
In the second sample one can connect the resistors in parallel, take the resulting element and connect it to a third resistor consecutively. Then, we get an element with resistance <image>. We cannot make this element using two resistors.
Submitted Solution:
```
a, b = map(int, input().split())
def calc(a, b):
if a <= 0 or b <= 0:
return 0
if a == 1:
return b
if b == 1:
return a
if a >= b:
return a // b + calc(a % b, b)
return b // a + calc(a, b % a)
print(calc(a, b))
```
Yes
| 88,744 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mad scientist Mike is building a time machine in his spare time. To finish the work, he needs a resistor with a certain resistance value.
However, all Mike has is lots of identical resistors with unit resistance R0 = 1. Elements with other resistance can be constructed from these resistors. In this problem, we will consider the following as elements:
1. one resistor;
2. an element and one resistor plugged in sequence;
3. an element and one resistor plugged in parallel.
<image>
With the consecutive connection the resistance of the new element equals R = Re + R0. With the parallel connection the resistance of the new element equals <image>. In this case Re equals the resistance of the element being connected.
Mike needs to assemble an element with a resistance equal to the fraction <image>. Determine the smallest possible number of resistors he needs to make such an element.
Input
The single input line contains two space-separated integers a and b (1 ≤ a, b ≤ 1018). It is guaranteed that the fraction <image> is irreducible. It is guaranteed that a solution always exists.
Output
Print a single number — the answer to the problem.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is recommended to use the cin, cout streams or the %I64d specifier.
Examples
Input
1 1
Output
1
Input
3 2
Output
3
Input
199 200
Output
200
Note
In the first sample, one resistor is enough.
In the second sample one can connect the resistors in parallel, take the resulting element and connect it to a third resistor consecutively. Then, we get an element with resistance <image>. We cannot make this element using two resistors.
Submitted Solution:
```
import sys, os, io
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(sys.stdin.readline())
def ria(): return list(map(int, sys.stdin.readline().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math,datetime,functools,itertools,operator,bisect,fractions,statistics
from collections import deque,defaultdict,OrderedDict,Counter
from fractions import Fraction
from decimal import Decimal
from sys import stdout
from heapq import heappush, heappop, heapify ,_heapify_max,_heappop_max,nsmallest,nlargest
# sys.setrecursionlimit(111111)
INF=999999999999999999999999
alphabets="abcdefghijklmnopqrstuvwxyz"
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
class SegTree:
def __init__(self, n):
self.N = 1 << n.bit_length()
self.tree = [0] * (self.N<<1)
def update(self, i, j, v):
i += self.N
j += self.N
while i <= j:
if i%2==1: self.tree[i] += v
if j%2==0: self.tree[j] += v
i, j = (i+1) >> 1, (j-1) >> 1
def query(self, i):
v = 0
i += self.N
while i > 0:
v += self.tree[i]
i >>= 1
return v
def SieveOfEratosthenes(limit):
"""Returns all primes not greater than limit."""
isPrime = [True]*(limit+1)
isPrime[0] = isPrime[1] = False
primes = []
for i in range(2, limit+1):
if not isPrime[i]:continue
primes += [i]
for j in range(i*i, limit+1, i):
isPrime[j] = False
return primes
def main():
mod=1000000007
# InverseofNumber(mod)
# InverseofFactorial(mod)
# factorial(mod)
starttime=datetime.datetime.now()
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r")
sys.stdout = open("output.txt","w")
###CODE
tc = 1
for _ in range(tc):
a,b=ria()
# LOGIC-
# actually the quesn can easily understood as
# we have 1 ohm resistor
# we have 2 options now
# we can add 1 ohm resistor in series to this
# or we can add 1 ohm resistor in parallel to this
# let say we get to a/b ohm circuit system using k resistors
# now we add 1 resistor in series and parallel and see what happens
# a/b becomes (a+b)/b in series and a/(a+b) in parallel using k+1 resistors
# so if we have resistance as a/b it becomes (a+b)/b or a/(a+b) using 1 resistor
# in other words :
# so if we had resistance a/b it would have been
# (a-b)/a without 1 ohm resistor in series
# a/(b-a) without 1 ohm resistor in parallel
# func(a,b)=func(a-b,b) or func(a,b-a)
# does it ring a bell?
# Adding 1 ohm resistor to a circuit is just reverse of euclidean algo for finding gcd
# That means that the answer is equal to the number of steps in standard Euclidean algorithm.
# but basic gcd(a,b)=gcd(b-a,a) wont work we have to use mod to calculate faster
# like gcd(a,b)=gcd(b,a%b)
op=0
while min(a,b):
if a>b:
op+=a//b
a%=b
else:
op+=b//a
b%=a
wi(op)
#<--Solving Area Ends
endtime=datetime.datetime.now()
time=(endtime-starttime).total_seconds()*1000
if(os.path.exists('input.txt')):
print("Time:",time,"ms")
class FastReader(io.IOBase):
newlines = 0
def __init__(self, fd, chunk_size=1024 * 8):
self._fd = fd
self._chunk_size = chunk_size
self.buffer = io.BytesIO()
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
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, size=-1):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
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()
class FastWriter(io.IOBase):
def __init__(self, fd):
self._fd = fd
self.buffer = io.BytesIO()
self.write = self.buffer.write
def flush(self):
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class FastStdin(io.IOBase):
def __init__(self, fd=0):
self.buffer = FastReader(fd)
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
class FastStdout(io.IOBase):
def __init__(self, fd=1):
self.buffer = FastWriter(fd)
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.flush = self.buffer.flush
if __name__ == '__main__':
sys.stdin = FastStdin()
sys.stdout = FastStdout()
main()
```
Yes
| 88,745 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mad scientist Mike is building a time machine in his spare time. To finish the work, he needs a resistor with a certain resistance value.
However, all Mike has is lots of identical resistors with unit resistance R0 = 1. Elements with other resistance can be constructed from these resistors. In this problem, we will consider the following as elements:
1. one resistor;
2. an element and one resistor plugged in sequence;
3. an element and one resistor plugged in parallel.
<image>
With the consecutive connection the resistance of the new element equals R = Re + R0. With the parallel connection the resistance of the new element equals <image>. In this case Re equals the resistance of the element being connected.
Mike needs to assemble an element with a resistance equal to the fraction <image>. Determine the smallest possible number of resistors he needs to make such an element.
Input
The single input line contains two space-separated integers a and b (1 ≤ a, b ≤ 1018). It is guaranteed that the fraction <image> is irreducible. It is guaranteed that a solution always exists.
Output
Print a single number — the answer to the problem.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is recommended to use the cin, cout streams or the %I64d specifier.
Examples
Input
1 1
Output
1
Input
3 2
Output
3
Input
199 200
Output
200
Note
In the first sample, one resistor is enough.
In the second sample one can connect the resistors in parallel, take the resulting element and connect it to a third resistor consecutively. Then, we get an element with resistance <image>. We cannot make this element using two resistors.
Submitted Solution:
```
from math import gcd
def main():
a, b = map(int, input().split())
r = a // b
ans = r
a = a % b
if a > 0:
a, b = b, a
r = a // b
ans += r
a = a % b
ans += b * a
print(ans)
if __name__ == "__main__":
main()
```
No
| 88,746 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mad scientist Mike is building a time machine in his spare time. To finish the work, he needs a resistor with a certain resistance value.
However, all Mike has is lots of identical resistors with unit resistance R0 = 1. Elements with other resistance can be constructed from these resistors. In this problem, we will consider the following as elements:
1. one resistor;
2. an element and one resistor plugged in sequence;
3. an element and one resistor plugged in parallel.
<image>
With the consecutive connection the resistance of the new element equals R = Re + R0. With the parallel connection the resistance of the new element equals <image>. In this case Re equals the resistance of the element being connected.
Mike needs to assemble an element with a resistance equal to the fraction <image>. Determine the smallest possible number of resistors he needs to make such an element.
Input
The single input line contains two space-separated integers a and b (1 ≤ a, b ≤ 1018). It is guaranteed that the fraction <image> is irreducible. It is guaranteed that a solution always exists.
Output
Print a single number — the answer to the problem.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is recommended to use the cin, cout streams or the %I64d specifier.
Examples
Input
1 1
Output
1
Input
3 2
Output
3
Input
199 200
Output
200
Note
In the first sample, one resistor is enough.
In the second sample one can connect the resistors in parallel, take the resulting element and connect it to a third resistor consecutively. Then, we get an element with resistance <image>. We cannot make this element using two resistors.
Submitted Solution:
```
#https://codeforces.com/problemset/problem/343/A
inp = input()
a,b = int(inp.split()[0]) , int(inp.split()[1])
from math import floor
Sum=0
def work(a,b):
global Sum
if a/float(b) > 1:
Sum+= floor(a/float(b))
work(a-(b*floor(a/float(b))) , b)
elif a/float(b) < 1:
Sum+=b
else:
Sum+=1
work(a,b)
print(Sum)
```
No
| 88,747 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mad scientist Mike is building a time machine in his spare time. To finish the work, he needs a resistor with a certain resistance value.
However, all Mike has is lots of identical resistors with unit resistance R0 = 1. Elements with other resistance can be constructed from these resistors. In this problem, we will consider the following as elements:
1. one resistor;
2. an element and one resistor plugged in sequence;
3. an element and one resistor plugged in parallel.
<image>
With the consecutive connection the resistance of the new element equals R = Re + R0. With the parallel connection the resistance of the new element equals <image>. In this case Re equals the resistance of the element being connected.
Mike needs to assemble an element with a resistance equal to the fraction <image>. Determine the smallest possible number of resistors he needs to make such an element.
Input
The single input line contains two space-separated integers a and b (1 ≤ a, b ≤ 1018). It is guaranteed that the fraction <image> is irreducible. It is guaranteed that a solution always exists.
Output
Print a single number — the answer to the problem.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is recommended to use the cin, cout streams or the %I64d specifier.
Examples
Input
1 1
Output
1
Input
3 2
Output
3
Input
199 200
Output
200
Note
In the first sample, one resistor is enough.
In the second sample one can connect the resistors in parallel, take the resulting element and connect it to a third resistor consecutively. Then, we get an element with resistance <image>. We cannot make this element using two resistors.
Submitted Solution:
```
I = lambda : list(map(int, input().split(' ')))
a, b = I()
if a <= b:
print(b)
else:
print(a//b + a%b)
```
No
| 88,748 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mad scientist Mike is building a time machine in his spare time. To finish the work, he needs a resistor with a certain resistance value.
However, all Mike has is lots of identical resistors with unit resistance R0 = 1. Elements with other resistance can be constructed from these resistors. In this problem, we will consider the following as elements:
1. one resistor;
2. an element and one resistor plugged in sequence;
3. an element and one resistor plugged in parallel.
<image>
With the consecutive connection the resistance of the new element equals R = Re + R0. With the parallel connection the resistance of the new element equals <image>. In this case Re equals the resistance of the element being connected.
Mike needs to assemble an element with a resistance equal to the fraction <image>. Determine the smallest possible number of resistors he needs to make such an element.
Input
The single input line contains two space-separated integers a and b (1 ≤ a, b ≤ 1018). It is guaranteed that the fraction <image> is irreducible. It is guaranteed that a solution always exists.
Output
Print a single number — the answer to the problem.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is recommended to use the cin, cout streams or the %I64d specifier.
Examples
Input
1 1
Output
1
Input
3 2
Output
3
Input
199 200
Output
200
Note
In the first sample, one resistor is enough.
In the second sample one can connect the resistors in parallel, take the resulting element and connect it to a third resistor consecutively. Then, we get an element with resistance <image>. We cannot make this element using two resistors.
Submitted Solution:
```
from math import gcd
a, b = map(int, input().split(" "))
x = gcd(a,b)
a, b = a/x, b/x
ans = 0
ans += a//b
a -= a//b
print(int(ans))
```
No
| 88,749 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima, Inna and Seryozha have gathered in a room. That's right, someone's got to go. To cheer Seryozha up and inspire him to have a walk, Inna decided to cook something.
Dima and Seryozha have n fruits in the fridge. Each fruit has two parameters: the taste and the number of calories. Inna decided to make a fruit salad, so she wants to take some fruits from the fridge for it. Inna follows a certain principle as she chooses the fruits: the total taste to the total calories ratio of the chosen fruits must equal k. In other words, <image> , where aj is the taste of the j-th chosen fruit and bj is its calories.
Inna hasn't chosen the fruits yet, she is thinking: what is the maximum taste of the chosen fruits if she strictly follows her principle? Help Inna solve this culinary problem — now the happiness of a young couple is in your hands!
Inna loves Dima very much so she wants to make the salad from at least one fruit.
Input
The first line of the input contains two integers n, k (1 ≤ n ≤ 100, 1 ≤ k ≤ 10). The second line of the input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the fruits' tastes. The third line of the input contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 100) — the fruits' calories. Fruit number i has taste ai and calories bi.
Output
If there is no way Inna can choose the fruits for the salad, print in the single line number -1. Otherwise, print a single integer — the maximum possible sum of the taste values of the chosen fruits.
Examples
Input
3 2
10 8 1
2 7 1
Output
18
Input
5 3
4 4 4 4 4
2 2 2 2 2
Output
-1
Note
In the first test sample we can get the total taste of the fruits equal to 18 if we choose fruit number 1 and fruit number 2, then the total calories will equal 9. The condition <image> fulfills, that's exactly what Inna wants.
In the second test sample we cannot choose the fruits so as to follow Inna's principle.
Tags: dp
Correct Solution:
```
from collections import defaultdict
n, k = map(int, input().split())
a = [0] + list(map(int, input().split()))
b = [0] + list(map(int, input().split()))
dp = [defaultdict(lambda : int(-2e9)) for _ in range(n+1)]
dp[0][n*100] = 0
for i in range(1, n+1):
s = a[i] - b[i] * k
for j in range(n*200, -1, -1):
dp[i][j] = max(dp[i-1][j], dp[i-1][j-s] + a[i])
print(dp[n][n*100] if dp[n][n*100] > 0 else -1)
```
| 88,750 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima, Inna and Seryozha have gathered in a room. That's right, someone's got to go. To cheer Seryozha up and inspire him to have a walk, Inna decided to cook something.
Dima and Seryozha have n fruits in the fridge. Each fruit has two parameters: the taste and the number of calories. Inna decided to make a fruit salad, so she wants to take some fruits from the fridge for it. Inna follows a certain principle as she chooses the fruits: the total taste to the total calories ratio of the chosen fruits must equal k. In other words, <image> , where aj is the taste of the j-th chosen fruit and bj is its calories.
Inna hasn't chosen the fruits yet, she is thinking: what is the maximum taste of the chosen fruits if she strictly follows her principle? Help Inna solve this culinary problem — now the happiness of a young couple is in your hands!
Inna loves Dima very much so she wants to make the salad from at least one fruit.
Input
The first line of the input contains two integers n, k (1 ≤ n ≤ 100, 1 ≤ k ≤ 10). The second line of the input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the fruits' tastes. The third line of the input contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 100) — the fruits' calories. Fruit number i has taste ai and calories bi.
Output
If there is no way Inna can choose the fruits for the salad, print in the single line number -1. Otherwise, print a single integer — the maximum possible sum of the taste values of the chosen fruits.
Examples
Input
3 2
10 8 1
2 7 1
Output
18
Input
5 3
4 4 4 4 4
2 2 2 2 2
Output
-1
Note
In the first test sample we can get the total taste of the fruits equal to 18 if we choose fruit number 1 and fruit number 2, then the total calories will equal 9. The condition <image> fulfills, that's exactly what Inna wants.
In the second test sample we cannot choose the fruits so as to follow Inna's principle.
Tags: dp
Correct Solution:
```
n, k = [int(x) for x in input().split(' ')]
taste = [int(x) for x in input().split(' ')]
cal = [int(x) for x in input().split(' ')]
w = [taste[i] - k*cal[i] for i in range(n)]
taste_per_diff = [-1 for i in range(50000)]
shift = 20000
taste_per_diff[shift] = 0
for i in range(n):
new_tpd = [x for x in taste_per_diff]
for j in range(0, 40000):
if taste_per_diff[j] != -1:
new_tpd[j+w[i]] = max(new_tpd[j+w[i]], taste_per_diff[j] + taste[i])
taste_per_diff = new_tpd
if taste_per_diff[shift] == 0:
print(-1)
else:
print(taste_per_diff[shift])
```
| 88,751 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima, Inna and Seryozha have gathered in a room. That's right, someone's got to go. To cheer Seryozha up and inspire him to have a walk, Inna decided to cook something.
Dima and Seryozha have n fruits in the fridge. Each fruit has two parameters: the taste and the number of calories. Inna decided to make a fruit salad, so she wants to take some fruits from the fridge for it. Inna follows a certain principle as she chooses the fruits: the total taste to the total calories ratio of the chosen fruits must equal k. In other words, <image> , where aj is the taste of the j-th chosen fruit and bj is its calories.
Inna hasn't chosen the fruits yet, she is thinking: what is the maximum taste of the chosen fruits if she strictly follows her principle? Help Inna solve this culinary problem — now the happiness of a young couple is in your hands!
Inna loves Dima very much so she wants to make the salad from at least one fruit.
Input
The first line of the input contains two integers n, k (1 ≤ n ≤ 100, 1 ≤ k ≤ 10). The second line of the input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the fruits' tastes. The third line of the input contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 100) — the fruits' calories. Fruit number i has taste ai and calories bi.
Output
If there is no way Inna can choose the fruits for the salad, print in the single line number -1. Otherwise, print a single integer — the maximum possible sum of the taste values of the chosen fruits.
Examples
Input
3 2
10 8 1
2 7 1
Output
18
Input
5 3
4 4 4 4 4
2 2 2 2 2
Output
-1
Note
In the first test sample we can get the total taste of the fruits equal to 18 if we choose fruit number 1 and fruit number 2, then the total calories will equal 9. The condition <image> fulfills, that's exactly what Inna wants.
In the second test sample we cannot choose the fruits so as to follow Inna's principle.
Tags: dp
Correct Solution:
```
k = int(input().split()[1])
a = [int(s) for s in input().split()]
b = [int(s) for s in input().split()]
ambk = [(a[i], a[i] - b[i]*k) for i in range(len(a))]
ambk.sort(key=lambda a:-a[1])
ts = [0]*(100*100)
keys = [0]
atras = range(100*100 -1, -1, -1)
adelante = range(100*100)
for i in range(len(a)):
for j in ( atras if ambk[i][1] >= 0 else adelante ):
if ts[j] > 0 or j == 0:
if j + ambk[i][1] >= 0:
ts[j+ambk[i][1]] = max(ts[j+ambk[i][1]], ts[j] + ambk[i][0])
print("-1" if ts[0] == 0 else str(ts[0]))
```
| 88,752 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima, Inna and Seryozha have gathered in a room. That's right, someone's got to go. To cheer Seryozha up and inspire him to have a walk, Inna decided to cook something.
Dima and Seryozha have n fruits in the fridge. Each fruit has two parameters: the taste and the number of calories. Inna decided to make a fruit salad, so she wants to take some fruits from the fridge for it. Inna follows a certain principle as she chooses the fruits: the total taste to the total calories ratio of the chosen fruits must equal k. In other words, <image> , where aj is the taste of the j-th chosen fruit and bj is its calories.
Inna hasn't chosen the fruits yet, she is thinking: what is the maximum taste of the chosen fruits if she strictly follows her principle? Help Inna solve this culinary problem — now the happiness of a young couple is in your hands!
Inna loves Dima very much so she wants to make the salad from at least one fruit.
Input
The first line of the input contains two integers n, k (1 ≤ n ≤ 100, 1 ≤ k ≤ 10). The second line of the input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the fruits' tastes. The third line of the input contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 100) — the fruits' calories. Fruit number i has taste ai and calories bi.
Output
If there is no way Inna can choose the fruits for the salad, print in the single line number -1. Otherwise, print a single integer — the maximum possible sum of the taste values of the chosen fruits.
Examples
Input
3 2
10 8 1
2 7 1
Output
18
Input
5 3
4 4 4 4 4
2 2 2 2 2
Output
-1
Note
In the first test sample we can get the total taste of the fruits equal to 18 if we choose fruit number 1 and fruit number 2, then the total calories will equal 9. The condition <image> fulfills, that's exactly what Inna wants.
In the second test sample we cannot choose the fruits so as to follow Inna's principle.
Tags: dp
Correct Solution:
```
from sys import stdin,stdout
Pi = lambda x: stdout.write(str(x) + '\n')
Ps = lambda x: stdout.write(str(x))
S = lambda x: x*(x+1) // 2
I = lambda x: 1+(2*x)
R = lambda:stdin.readline()
Ri = lambda x:map(int,x.split())
Rs = lambda x:map(str,x.split())
Rf = lambda x:map(float,x.split())
MaxN = int(1e5) + 10
# dp,A = []
def f(i,x,n,k,dp,A,B):
if i==n:
if x==0:return 0
return -1000000
if dp[i][x+MaxN]!=-1:return dp[i][x+MaxN]
op1 = f(i+1, x+A[i]-B[i]*k,n,k,dp,A,B)+A[i]
op2 = f(i+1, x,n,k,dp,A,B)
dp[i][x+MaxN] = max(op2,op1)
return dp[i][x+MaxN]
def main():
# t = int(R())
for x in stdin:
n,x = Ri(x)
A = list(Ri(R()))
B = list(Ri(R()))
dp = []
for i in range(110):
dp.append([-1]*(MaxN*2))
ans = f(0,0,n,x,dp,A,B)
if ans < 1:ans = -1
Pi(ans)
if __name__=='__main__':
main()
# 60 == 360
```
| 88,753 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima, Inna and Seryozha have gathered in a room. That's right, someone's got to go. To cheer Seryozha up and inspire him to have a walk, Inna decided to cook something.
Dima and Seryozha have n fruits in the fridge. Each fruit has two parameters: the taste and the number of calories. Inna decided to make a fruit salad, so she wants to take some fruits from the fridge for it. Inna follows a certain principle as she chooses the fruits: the total taste to the total calories ratio of the chosen fruits must equal k. In other words, <image> , where aj is the taste of the j-th chosen fruit and bj is its calories.
Inna hasn't chosen the fruits yet, she is thinking: what is the maximum taste of the chosen fruits if she strictly follows her principle? Help Inna solve this culinary problem — now the happiness of a young couple is in your hands!
Inna loves Dima very much so she wants to make the salad from at least one fruit.
Input
The first line of the input contains two integers n, k (1 ≤ n ≤ 100, 1 ≤ k ≤ 10). The second line of the input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the fruits' tastes. The third line of the input contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 100) — the fruits' calories. Fruit number i has taste ai and calories bi.
Output
If there is no way Inna can choose the fruits for the salad, print in the single line number -1. Otherwise, print a single integer — the maximum possible sum of the taste values of the chosen fruits.
Examples
Input
3 2
10 8 1
2 7 1
Output
18
Input
5 3
4 4 4 4 4
2 2 2 2 2
Output
-1
Note
In the first test sample we can get the total taste of the fruits equal to 18 if we choose fruit number 1 and fruit number 2, then the total calories will equal 9. The condition <image> fulfills, that's exactly what Inna wants.
In the second test sample we cannot choose the fruits so as to follow Inna's principle.
Tags: dp
Correct Solution:
```
[n,k] = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
b.insert(0,0)
a.insert(0,0)
s = sum(b) * k
f = [[0 for i in range(0,4*s+1)] for j in range(0,n+1)]
for i in range(0,n+1):
a[i] = a[i] - (k * b[i])
for i in range(1,n+1):
for j in range(s,3*s+1):
f[i][j] = f[i-1][j]
if j-a[i] == 2*s or f[i-1][j-a[i]] > 0:
f[i][j] = max(f[i][j],f[i-1][j-a[i]]+b[i])
if f[n][2*s]:
print(f[n][2*s] * k)
else:
print(-1)
```
| 88,754 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima, Inna and Seryozha have gathered in a room. That's right, someone's got to go. To cheer Seryozha up and inspire him to have a walk, Inna decided to cook something.
Dima and Seryozha have n fruits in the fridge. Each fruit has two parameters: the taste and the number of calories. Inna decided to make a fruit salad, so she wants to take some fruits from the fridge for it. Inna follows a certain principle as she chooses the fruits: the total taste to the total calories ratio of the chosen fruits must equal k. In other words, <image> , where aj is the taste of the j-th chosen fruit and bj is its calories.
Inna hasn't chosen the fruits yet, she is thinking: what is the maximum taste of the chosen fruits if she strictly follows her principle? Help Inna solve this culinary problem — now the happiness of a young couple is in your hands!
Inna loves Dima very much so she wants to make the salad from at least one fruit.
Input
The first line of the input contains two integers n, k (1 ≤ n ≤ 100, 1 ≤ k ≤ 10). The second line of the input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the fruits' tastes. The third line of the input contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 100) — the fruits' calories. Fruit number i has taste ai and calories bi.
Output
If there is no way Inna can choose the fruits for the salad, print in the single line number -1. Otherwise, print a single integer — the maximum possible sum of the taste values of the chosen fruits.
Examples
Input
3 2
10 8 1
2 7 1
Output
18
Input
5 3
4 4 4 4 4
2 2 2 2 2
Output
-1
Note
In the first test sample we can get the total taste of the fruits equal to 18 if we choose fruit number 1 and fruit number 2, then the total calories will equal 9. The condition <image> fulfills, that's exactly what Inna wants.
In the second test sample we cannot choose the fruits so as to follow Inna's principle.
Tags: dp
Correct Solution:
```
n,k=map(int,input().split())
a=[int(temp) for temp in input().split()]#味道
b=[int(temp) for temp in input().split()]#卡路里，味道/卡路里=k
c=[-a[i]+k*b[i] for i in range(n)]
lis={0:0}#负数
lis1={0:0}#正数
for i in range(n):
temp=lis.copy()
for j in list(lis.keys()):
if c[i]<0:
if j-c[i] in lis:
lis[j-c[i]]=max(temp[j-c[i]],temp[j]+a[i])
else :
lis[j-c[i]]=temp[j]+a[i]#负数装载
temp=list(lis)
temp.sort()
temp.reverse()
maxnum=temp[0]
for i in range(n):
temp1=lis1.copy()
for j in list(lis1.keys()):
if c[i]>=0:
if j+c[i] in lis1:
lis1[j+c[i]]=max(temp1[j+c[i]],temp1[j]+a[i])
elif j+c[i]<=maxnum:
lis1[j+c[i]]=temp1[j]+a[i]#正数装载
maxnum=0
for i in temp:
if i in lis1:
maxnum=max(lis[i]+lis1[i],maxnum)
if maxnum==0:
print(-1)
else:
print(maxnum)
# 78, 158, 0, 59, 1
#-31, -19,-20, -86, -2, -9, -14
```
| 88,755 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima, Inna and Seryozha have gathered in a room. That's right, someone's got to go. To cheer Seryozha up and inspire him to have a walk, Inna decided to cook something.
Dima and Seryozha have n fruits in the fridge. Each fruit has two parameters: the taste and the number of calories. Inna decided to make a fruit salad, so she wants to take some fruits from the fridge for it. Inna follows a certain principle as she chooses the fruits: the total taste to the total calories ratio of the chosen fruits must equal k. In other words, <image> , where aj is the taste of the j-th chosen fruit and bj is its calories.
Inna hasn't chosen the fruits yet, she is thinking: what is the maximum taste of the chosen fruits if she strictly follows her principle? Help Inna solve this culinary problem — now the happiness of a young couple is in your hands!
Inna loves Dima very much so she wants to make the salad from at least one fruit.
Input
The first line of the input contains two integers n, k (1 ≤ n ≤ 100, 1 ≤ k ≤ 10). The second line of the input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the fruits' tastes. The third line of the input contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 100) — the fruits' calories. Fruit number i has taste ai and calories bi.
Output
If there is no way Inna can choose the fruits for the salad, print in the single line number -1. Otherwise, print a single integer — the maximum possible sum of the taste values of the chosen fruits.
Examples
Input
3 2
10 8 1
2 7 1
Output
18
Input
5 3
4 4 4 4 4
2 2 2 2 2
Output
-1
Note
In the first test sample we can get the total taste of the fruits equal to 18 if we choose fruit number 1 and fruit number 2, then the total calories will equal 9. The condition <image> fulfills, that's exactly what Inna wants.
In the second test sample we cannot choose the fruits so as to follow Inna's principle.
Tags: dp
Correct Solution:
```
n, k = map(int, input().split())
x, y = [0] * 100001, [0] * 100001
x[0] = y[0] = 1
g = h = 0
for u, v in zip(*(map(int, input().split()), map(int, input().split()))):
d = u - k * v
if d > 0:
for j in range(g, -1, -1):
if x[j]: x[j + d] = max(x[j + d], x[j] + v)
g += d
else:
for j in range(h, -1, -1):
if y[j]: y[j - d] = max(y[j - d], y[j] + v)
h -= d
s = max(x[i] + y[i] for i in range(min(g, h) + 1) if x[i] and y[i]) - 2
print(k * s - (not s))
```
| 88,756 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima, Inna and Seryozha have gathered in a room. That's right, someone's got to go. To cheer Seryozha up and inspire him to have a walk, Inna decided to cook something.
Dima and Seryozha have n fruits in the fridge. Each fruit has two parameters: the taste and the number of calories. Inna decided to make a fruit salad, so she wants to take some fruits from the fridge for it. Inna follows a certain principle as she chooses the fruits: the total taste to the total calories ratio of the chosen fruits must equal k. In other words, <image> , where aj is the taste of the j-th chosen fruit and bj is its calories.
Inna hasn't chosen the fruits yet, she is thinking: what is the maximum taste of the chosen fruits if she strictly follows her principle? Help Inna solve this culinary problem — now the happiness of a young couple is in your hands!
Inna loves Dima very much so she wants to make the salad from at least one fruit.
Input
The first line of the input contains two integers n, k (1 ≤ n ≤ 100, 1 ≤ k ≤ 10). The second line of the input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the fruits' tastes. The third line of the input contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 100) — the fruits' calories. Fruit number i has taste ai and calories bi.
Output
If there is no way Inna can choose the fruits for the salad, print in the single line number -1. Otherwise, print a single integer — the maximum possible sum of the taste values of the chosen fruits.
Examples
Input
3 2
10 8 1
2 7 1
Output
18
Input
5 3
4 4 4 4 4
2 2 2 2 2
Output
-1
Note
In the first test sample we can get the total taste of the fruits equal to 18 if we choose fruit number 1 and fruit number 2, then the total calories will equal 9. The condition <image> fulfills, that's exactly what Inna wants.
In the second test sample we cannot choose the fruits so as to follow Inna's principle.
Tags: dp
Correct Solution:
```
n,k=map(int,input().split())
s=list(map(int,input().split()))
s1=list(map(int,input().split()))
dp=[[[0 for j in range(10**5)] for l in range(2)] for i in range(n+1)]
y=s[0]-s1[0]*k
if y>=0:
dp[0][0][y]=s[0]
else:
dp[0][1][-y]=s[0]
for i in range(1,n):
y=s[i]-s1[i]*k
for j in range(100**2+2):
for l in range(2):
dp[i][l][j]=max(dp[i][l][j],dp[i-1][l][j])
if dp[i-1][l][j]!=0 or (j==0):
if l==1:
x=-j+y
else:
x=j+y
if x<0:
x=abs(x)
dp[i][1][x]=max(dp[i-1][1][x],dp[i][1][x],dp[i-1][l][j]+s[i])
else:
dp[i][0][x]=max(dp[i-1][0][x],dp[i][0][x],dp[i-1][l][j]+s[i])
if dp[n-1][0][0]==0:
print(-1)
else:
print(dp[n-1][0][0])
```
| 88,757 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima, Inna and Seryozha have gathered in a room. That's right, someone's got to go. To cheer Seryozha up and inspire him to have a walk, Inna decided to cook something.
Dima and Seryozha have n fruits in the fridge. Each fruit has two parameters: the taste and the number of calories. Inna decided to make a fruit salad, so she wants to take some fruits from the fridge for it. Inna follows a certain principle as she chooses the fruits: the total taste to the total calories ratio of the chosen fruits must equal k. In other words, <image> , where aj is the taste of the j-th chosen fruit and bj is its calories.
Inna hasn't chosen the fruits yet, she is thinking: what is the maximum taste of the chosen fruits if she strictly follows her principle? Help Inna solve this culinary problem — now the happiness of a young couple is in your hands!
Inna loves Dima very much so she wants to make the salad from at least one fruit.
Input
The first line of the input contains two integers n, k (1 ≤ n ≤ 100, 1 ≤ k ≤ 10). The second line of the input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the fruits' tastes. The third line of the input contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 100) — the fruits' calories. Fruit number i has taste ai and calories bi.
Output
If there is no way Inna can choose the fruits for the salad, print in the single line number -1. Otherwise, print a single integer — the maximum possible sum of the taste values of the chosen fruits.
Examples
Input
3 2
10 8 1
2 7 1
Output
18
Input
5 3
4 4 4 4 4
2 2 2 2 2
Output
-1
Note
In the first test sample we can get the total taste of the fruits equal to 18 if we choose fruit number 1 and fruit number 2, then the total calories will equal 9. The condition <image> fulfills, that's exactly what Inna wants.
In the second test sample we cannot choose the fruits so as to follow Inna's principle.
Submitted Solution:
```
n, k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(lambda x: int(x) * k, input().split()))
pos = [0] * 10 ** 5
neg = [0] * 10 ** 5
pos[0] = 1
neg[0] = 1
base = 0
for i in range(n):
d = a[i] - b[i]
if d > 0:
for j in range(10 ** 5-1,-1,-1):
if pos[j]:
if j + d < 10 ** 5:
pos[j+d] = max(pos[j+d],pos[j]+a[i])
elif d < 0:
for j in range(10 ** 5-1,-1,-1):
if neg[j]:
if j - d < 10 ** 5:
neg[j-d] = max(neg[j-d],neg[j]+a[i])
else:
base += a[i]
best = 0
for i in range(10 ** 5):
if pos[i] and neg[i]:
best = max(best,pos[i] + neg[i])
best -= 2
best += base
if best:
print(best)
else:
print(-1)
```
Yes
| 88,758 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima, Inna and Seryozha have gathered in a room. That's right, someone's got to go. To cheer Seryozha up and inspire him to have a walk, Inna decided to cook something.
Dima and Seryozha have n fruits in the fridge. Each fruit has two parameters: the taste and the number of calories. Inna decided to make a fruit salad, so she wants to take some fruits from the fridge for it. Inna follows a certain principle as she chooses the fruits: the total taste to the total calories ratio of the chosen fruits must equal k. In other words, <image> , where aj is the taste of the j-th chosen fruit and bj is its calories.
Inna hasn't chosen the fruits yet, she is thinking: what is the maximum taste of the chosen fruits if she strictly follows her principle? Help Inna solve this culinary problem — now the happiness of a young couple is in your hands!
Inna loves Dima very much so she wants to make the salad from at least one fruit.
Input
The first line of the input contains two integers n, k (1 ≤ n ≤ 100, 1 ≤ k ≤ 10). The second line of the input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the fruits' tastes. The third line of the input contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 100) — the fruits' calories. Fruit number i has taste ai and calories bi.
Output
If there is no way Inna can choose the fruits for the salad, print in the single line number -1. Otherwise, print a single integer — the maximum possible sum of the taste values of the chosen fruits.
Examples
Input
3 2
10 8 1
2 7 1
Output
18
Input
5 3
4 4 4 4 4
2 2 2 2 2
Output
-1
Note
In the first test sample we can get the total taste of the fruits equal to 18 if we choose fruit number 1 and fruit number 2, then the total calories will equal 9. The condition <image> fulfills, that's exactly what Inna wants.
In the second test sample we cannot choose the fruits so as to follow Inna's principle.
Submitted Solution:
```
n,k = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
diff = []
for x in range(n):
diff.append(a[x]-b[x]*k)
totals = {0:0}
for x in range(n):
t = a[x]
d = diff[x]
newGuys = []
for y in totals:
newGuys.append((y+d,totals[y] + t))
for y,z in newGuys:
if y in totals:
totals[y] = max(totals[y], z)
else:
totals[y] = z
if totals[0] == 0:
print(-1)
else:
print(totals[0])
if totals[0] == 1435:
print(' '.join([str(x) for x in diff]))
```
Yes
| 88,759 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima, Inna and Seryozha have gathered in a room. That's right, someone's got to go. To cheer Seryozha up and inspire him to have a walk, Inna decided to cook something.
Dima and Seryozha have n fruits in the fridge. Each fruit has two parameters: the taste and the number of calories. Inna decided to make a fruit salad, so she wants to take some fruits from the fridge for it. Inna follows a certain principle as she chooses the fruits: the total taste to the total calories ratio of the chosen fruits must equal k. In other words, <image> , where aj is the taste of the j-th chosen fruit and bj is its calories.
Inna hasn't chosen the fruits yet, she is thinking: what is the maximum taste of the chosen fruits if she strictly follows her principle? Help Inna solve this culinary problem — now the happiness of a young couple is in your hands!
Inna loves Dima very much so she wants to make the salad from at least one fruit.
Input
The first line of the input contains two integers n, k (1 ≤ n ≤ 100, 1 ≤ k ≤ 10). The second line of the input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the fruits' tastes. The third line of the input contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 100) — the fruits' calories. Fruit number i has taste ai and calories bi.
Output
If there is no way Inna can choose the fruits for the salad, print in the single line number -1. Otherwise, print a single integer — the maximum possible sum of the taste values of the chosen fruits.
Examples
Input
3 2
10 8 1
2 7 1
Output
18
Input
5 3
4 4 4 4 4
2 2 2 2 2
Output
-1
Note
In the first test sample we can get the total taste of the fruits equal to 18 if we choose fruit number 1 and fruit number 2, then the total calories will equal 9. The condition <image> fulfills, that's exactly what Inna wants.
In the second test sample we cannot choose the fruits so as to follow Inna's principle.
Submitted Solution:
```
n, k = [int(x) for x in input().split(' ')]
taste = [int(x) for x in input().split(' ')]
cal = [int(x) for x in input().split(' ')]
d = [[0 for j in range(10000*2)] for i in range(n)]
a = taste
b = cal
w = [a[i] - k*b[i] for i in range(n)]
dp = [-9999999 for i in range(300005)]
dp[10000] = 0
for i in range(n):
if w[i] > 0:
for j in range(20000, w[i], -1):
if dp[j - w[i]] != -9999999:
dp[j] = max(dp[j], dp[j-w[i]]+a[i])
else:
for j in range(20000):
if dp[j - w[i]] != -9999999:
dp[j] = max(dp[j], dp[j-w[i]]+a[i])
if dp[10000] == 0:
print(-1)
else:
print(dp[10000])
```
Yes
| 88,760 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima, Inna and Seryozha have gathered in a room. That's right, someone's got to go. To cheer Seryozha up and inspire him to have a walk, Inna decided to cook something.
Dima and Seryozha have n fruits in the fridge. Each fruit has two parameters: the taste and the number of calories. Inna decided to make a fruit salad, so she wants to take some fruits from the fridge for it. Inna follows a certain principle as she chooses the fruits: the total taste to the total calories ratio of the chosen fruits must equal k. In other words, <image> , where aj is the taste of the j-th chosen fruit and bj is its calories.
Inna hasn't chosen the fruits yet, she is thinking: what is the maximum taste of the chosen fruits if she strictly follows her principle? Help Inna solve this culinary problem — now the happiness of a young couple is in your hands!
Inna loves Dima very much so she wants to make the salad from at least one fruit.
Input
The first line of the input contains two integers n, k (1 ≤ n ≤ 100, 1 ≤ k ≤ 10). The second line of the input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the fruits' tastes. The third line of the input contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 100) — the fruits' calories. Fruit number i has taste ai and calories bi.
Output
If there is no way Inna can choose the fruits for the salad, print in the single line number -1. Otherwise, print a single integer — the maximum possible sum of the taste values of the chosen fruits.
Examples
Input
3 2
10 8 1
2 7 1
Output
18
Input
5 3
4 4 4 4 4
2 2 2 2 2
Output
-1
Note
In the first test sample we can get the total taste of the fruits equal to 18 if we choose fruit number 1 and fruit number 2, then the total calories will equal 9. The condition <image> fulfills, that's exactly what Inna wants.
In the second test sample we cannot choose the fruits so as to follow Inna's principle.
Submitted Solution:
```
from bisect import bisect_right
n, k = map(int, input().split())
t = sorted((u - k * v, v) for u, v in zip(*(map(int, input().split()), map(int, input().split()))))
m = n - bisect_right(t, (0, 0))
l, p, t = 0, [0] * 100001, t[:: -1]
for d, v in t[: m]:
for j in range(l, 0, -1):
if p[j]: p[j + d] = max(p[j + d], p[j] + v)
p[d] = max(p[d], p[0] + v)
l += d
for d, v in t[m: ]:
for j in range(- d, l + 1):
if p[j]: p[j + d] = max(p[j + d], p[j] + v)
print(p[0] * k if p[0] else -1)
```
Yes
| 88,761 |
Evaluate the correctness of the submitted Python 2 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima, Inna and Seryozha have gathered in a room. That's right, someone's got to go. To cheer Seryozha up and inspire him to have a walk, Inna decided to cook something.
Dima and Seryozha have n fruits in the fridge. Each fruit has two parameters: the taste and the number of calories. Inna decided to make a fruit salad, so she wants to take some fruits from the fridge for it. Inna follows a certain principle as she chooses the fruits: the total taste to the total calories ratio of the chosen fruits must equal k. In other words, <image> , where aj is the taste of the j-th chosen fruit and bj is its calories.
Inna hasn't chosen the fruits yet, she is thinking: what is the maximum taste of the chosen fruits if she strictly follows her principle? Help Inna solve this culinary problem — now the happiness of a young couple is in your hands!
Inna loves Dima very much so she wants to make the salad from at least one fruit.
Input
The first line of the input contains two integers n, k (1 ≤ n ≤ 100, 1 ≤ k ≤ 10). The second line of the input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the fruits' tastes. The third line of the input contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 100) — the fruits' calories. Fruit number i has taste ai and calories bi.
Output
If there is no way Inna can choose the fruits for the salad, print in the single line number -1. Otherwise, print a single integer — the maximum possible sum of the taste values of the chosen fruits.
Examples
Input
3 2
10 8 1
2 7 1
Output
18
Input
5 3
4 4 4 4 4
2 2 2 2 2
Output
-1
Note
In the first test sample we can get the total taste of the fruits equal to 18 if we choose fruit number 1 and fruit number 2, then the total calories will equal 9. The condition <image> fulfills, that's exactly what Inna wants.
In the second test sample we cannot choose the fruits so as to follow Inna's principle.
Submitted Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
def in_num():
return int(raw_input())
def in_arr():
return map(int,raw_input().split())
def pr_num(n):
stdout.write(str(n)+'\n')
def pr_arr(arr):
pr(' '.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return map(int,stdin.read().split())
range = xrange # not for python 3.0+
# main code
n,k=in_arr()
l1=in_arr()
l2=[i*k for i in in_arr()]
d=Counter()
d[0]=0
for i in range(n):
x=l1[i]-l2[i]
for j,k in d.items():
d[j+x]=max(d[j+x],k+l1[i])
pr_num(-1*(d[0]==0) + d[0])
```
Yes
| 88,762 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima, Inna and Seryozha have gathered in a room. That's right, someone's got to go. To cheer Seryozha up and inspire him to have a walk, Inna decided to cook something.
Dima and Seryozha have n fruits in the fridge. Each fruit has two parameters: the taste and the number of calories. Inna decided to make a fruit salad, so she wants to take some fruits from the fridge for it. Inna follows a certain principle as she chooses the fruits: the total taste to the total calories ratio of the chosen fruits must equal k. In other words, <image> , where aj is the taste of the j-th chosen fruit and bj is its calories.
Inna hasn't chosen the fruits yet, she is thinking: what is the maximum taste of the chosen fruits if she strictly follows her principle? Help Inna solve this culinary problem — now the happiness of a young couple is in your hands!
Inna loves Dima very much so she wants to make the salad from at least one fruit.
Input
The first line of the input contains two integers n, k (1 ≤ n ≤ 100, 1 ≤ k ≤ 10). The second line of the input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the fruits' tastes. The third line of the input contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 100) — the fruits' calories. Fruit number i has taste ai and calories bi.
Output
If there is no way Inna can choose the fruits for the salad, print in the single line number -1. Otherwise, print a single integer — the maximum possible sum of the taste values of the chosen fruits.
Examples
Input
3 2
10 8 1
2 7 1
Output
18
Input
5 3
4 4 4 4 4
2 2 2 2 2
Output
-1
Note
In the first test sample we can get the total taste of the fruits equal to 18 if we choose fruit number 1 and fruit number 2, then the total calories will equal 9. The condition <image> fulfills, that's exactly what Inna wants.
In the second test sample we cannot choose the fruits so as to follow Inna's principle.
Submitted Solution:
```
k = int(input().split()[1])
a = [int(s) for s in input().split()]
b = [int(s) for s in input().split()]
ambk = [(a[i], a[i] - b[i]*k) for i in range(len(a))]
ambk.sort(key=lambda a:-a[1])
print(str(ambk))
ts = [0]*(100*100)
keys = [0]
for i in range(len(a)):
for j in keys:
nk = set()
if j + ambk[i][1] >= 0:
if j + ambk[i][1] > 0 and ts[j + ambk[i][1]] == 0:
nk.add(j + ambk[i][1])
ts[j+ambk[i][1]] = max(ts[j+ambk[i][1]], ts[j] + ambk[i][0])
keys += list(nk)
print("-1" if ts[0] == 0 else str(ts[0]))
```
No
| 88,763 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima, Inna and Seryozha have gathered in a room. That's right, someone's got to go. To cheer Seryozha up and inspire him to have a walk, Inna decided to cook something.
Dima and Seryozha have n fruits in the fridge. Each fruit has two parameters: the taste and the number of calories. Inna decided to make a fruit salad, so she wants to take some fruits from the fridge for it. Inna follows a certain principle as she chooses the fruits: the total taste to the total calories ratio of the chosen fruits must equal k. In other words, <image> , where aj is the taste of the j-th chosen fruit and bj is its calories.
Inna hasn't chosen the fruits yet, she is thinking: what is the maximum taste of the chosen fruits if she strictly follows her principle? Help Inna solve this culinary problem — now the happiness of a young couple is in your hands!
Inna loves Dima very much so she wants to make the salad from at least one fruit.
Input
The first line of the input contains two integers n, k (1 ≤ n ≤ 100, 1 ≤ k ≤ 10). The second line of the input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the fruits' tastes. The third line of the input contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 100) — the fruits' calories. Fruit number i has taste ai and calories bi.
Output
If there is no way Inna can choose the fruits for the salad, print in the single line number -1. Otherwise, print a single integer — the maximum possible sum of the taste values of the chosen fruits.
Examples
Input
3 2
10 8 1
2 7 1
Output
18
Input
5 3
4 4 4 4 4
2 2 2 2 2
Output
-1
Note
In the first test sample we can get the total taste of the fruits equal to 18 if we choose fruit number 1 and fruit number 2, then the total calories will equal 9. The condition <image> fulfills, that's exactly what Inna wants.
In the second test sample we cannot choose the fruits so as to follow Inna's principle.
Submitted Solution:
```
[n,k] = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
w = [int(x) for x in input().split()]
a.insert(0,0)
w.insert(0,0)
s = sum(w)
q = 0
f = [[0 for y in range(0, s + 1)] for x in range(0, n + 1)]
for j in range(1,s+1):
f[0][j] = -999999
for i in range(1,n+1):
f[i][0] = 0
for i in range(1,n+1):
for j in range(1,s+1):
if w[i] <= j:
f[i][j] = max(f[i-1][j] , f[i-1][j-w[i]] + a[i])
if f[i][j] == k * j:
q = max(f[i][j],q)
else:
f[i][j] = f[i-1][j]
if q == 0:
print(-1)
else:
print(q)
```
No
| 88,764 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima, Inna and Seryozha have gathered in a room. That's right, someone's got to go. To cheer Seryozha up and inspire him to have a walk, Inna decided to cook something.
Dima and Seryozha have n fruits in the fridge. Each fruit has two parameters: the taste and the number of calories. Inna decided to make a fruit salad, so she wants to take some fruits from the fridge for it. Inna follows a certain principle as she chooses the fruits: the total taste to the total calories ratio of the chosen fruits must equal k. In other words, <image> , where aj is the taste of the j-th chosen fruit and bj is its calories.
Inna hasn't chosen the fruits yet, she is thinking: what is the maximum taste of the chosen fruits if she strictly follows her principle? Help Inna solve this culinary problem — now the happiness of a young couple is in your hands!
Inna loves Dima very much so she wants to make the salad from at least one fruit.
Input
The first line of the input contains two integers n, k (1 ≤ n ≤ 100, 1 ≤ k ≤ 10). The second line of the input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the fruits' tastes. The third line of the input contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 100) — the fruits' calories. Fruit number i has taste ai and calories bi.
Output
If there is no way Inna can choose the fruits for the salad, print in the single line number -1. Otherwise, print a single integer — the maximum possible sum of the taste values of the chosen fruits.
Examples
Input
3 2
10 8 1
2 7 1
Output
18
Input
5 3
4 4 4 4 4
2 2 2 2 2
Output
-1
Note
In the first test sample we can get the total taste of the fruits equal to 18 if we choose fruit number 1 and fruit number 2, then the total calories will equal 9. The condition <image> fulfills, that's exactly what Inna wants.
In the second test sample we cannot choose the fruits so as to follow Inna's principle.
Submitted Solution:
```
from collections import defaultdict
n, k = map(int, input().split())
a, b = list(map(int, input().split())), list(map(int, input().split()))
t, s = {0}, defaultdict(int)
for i in range(n):
u, v = a[i], b[i]
d = u - k * v
if d:
p = sorted(t, reverse = True)
q = [j + d for j in p]
for x, y in zip(*(p, q)): s[y] = max(s[y], s[x] + u)
t.update(q)
else:
for x in t: s[x] += u
print(s[0] if s[0] else -1)
```
No
| 88,765 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima, Inna and Seryozha have gathered in a room. That's right, someone's got to go. To cheer Seryozha up and inspire him to have a walk, Inna decided to cook something.
Dima and Seryozha have n fruits in the fridge. Each fruit has two parameters: the taste and the number of calories. Inna decided to make a fruit salad, so she wants to take some fruits from the fridge for it. Inna follows a certain principle as she chooses the fruits: the total taste to the total calories ratio of the chosen fruits must equal k. In other words, <image> , where aj is the taste of the j-th chosen fruit and bj is its calories.
Inna hasn't chosen the fruits yet, she is thinking: what is the maximum taste of the chosen fruits if she strictly follows her principle? Help Inna solve this culinary problem — now the happiness of a young couple is in your hands!
Inna loves Dima very much so she wants to make the salad from at least one fruit.
Input
The first line of the input contains two integers n, k (1 ≤ n ≤ 100, 1 ≤ k ≤ 10). The second line of the input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the fruits' tastes. The third line of the input contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 100) — the fruits' calories. Fruit number i has taste ai and calories bi.
Output
If there is no way Inna can choose the fruits for the salad, print in the single line number -1. Otherwise, print a single integer — the maximum possible sum of the taste values of the chosen fruits.
Examples
Input
3 2
10 8 1
2 7 1
Output
18
Input
5 3
4 4 4 4 4
2 2 2 2 2
Output
-1
Note
In the first test sample we can get the total taste of the fruits equal to 18 if we choose fruit number 1 and fruit number 2, then the total calories will equal 9. The condition <image> fulfills, that's exactly what Inna wants.
In the second test sample we cannot choose the fruits so as to follow Inna's principle.
Submitted Solution:
```
[n,k] = [int(x) for x in input().split()]
[a,b] = [[int(x) for x in input().split()] for i in range(0,2)]
f = [[0 for j in range(0,n+1)]for i in range(0,n+1)]
g = [[0 for j in range(0,n+1)]for i in range(0,n+1)]
for i in range(1,n+1):
f[i][i] = a[i-1]
g[i][i] = b[i-1]
q = 0
for i in range(1,n+1):
for j in range(i,n+1):
f[i][j] = f[i][j-1] + f[j][j]
g[i][j] = g[i][j-1] + g[j][j]
if float(int(f[i][j]) / int(g[i][j])) == float(k):
p = int(f[i][j])
q = max(q,p)
if q == 0:
print(-1)
else:
print(q)
```
No
| 88,766 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Two chess pieces, a rook and a knight, stand on a standard chessboard 8 × 8 in size. The positions in which they are situated are known. It is guaranteed that none of them beats the other one.
Your task is to find the number of ways to place another knight on the board so that none of the three pieces on the board beat another one. A new piece can only be placed on an empty square.
Input
The first input line contains the description of the rook's position on the board. This description is a line which is 2 in length. Its first symbol is a lower-case Latin letter from a to h, and its second symbol is a number from 1 to 8. The second line contains the description of the knight's position in a similar way. It is guaranteed that their positions do not coincide.
Output
Print a single number which is the required number of ways.
Examples
Input
a1
b2
Output
44
Input
a8
d4
Output
38
Tags: brute force, implementation, math
Correct Solution:
```
#!/usr/bin/env python3
def is_valid(r, k, new):
if r[0] == new[0]:
return False
if r[1] == new[1]:
return False
if abs(r[0] - new[0]) == 2 and abs(r[1] - new[1]) == 1:
return False
if abs(r[0] - new[0]) == 1 and abs(r[1] - new[1]) == 2:
return False
if abs(k[0] - new[0]) == 2 and abs(k[1] - new[1]) == 1:
return False
if abs(k[0] - new[0]) == 1 and abs(k[1] - new[1]) == 2:
return False
return True
rook = [ord(c) for c in input()]
knight = [ord(c) for c in input()]
ok = 0
for i in range(ord('a'), ord('i')):
for j in range(ord('1'), ord('9')):
if is_valid(rook, knight, [i, j]):
ok += 1
print(ok-1)
```
| 88,767 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Two chess pieces, a rook and a knight, stand on a standard chessboard 8 × 8 in size. The positions in which they are situated are known. It is guaranteed that none of them beats the other one.
Your task is to find the number of ways to place another knight on the board so that none of the three pieces on the board beat another one. A new piece can only be placed on an empty square.
Input
The first input line contains the description of the rook's position on the board. This description is a line which is 2 in length. Its first symbol is a lower-case Latin letter from a to h, and its second symbol is a number from 1 to 8. The second line contains the description of the knight's position in a similar way. It is guaranteed that their positions do not coincide.
Output
Print a single number which is the required number of ways.
Examples
Input
a1
b2
Output
44
Input
a8
d4
Output
38
Tags: brute force, implementation, math
Correct Solution:
```
def knightFields(i,j):
result, pos =[], [(i+2, j+1), (i+2, j-1), (i-2, j+1), (i-2, j-1), (i+1, j+2), (i-1, j+2), (i+1, j-2), (i-1, j-2)]
for k in range(8):
if pos[k][0] >= 0 and pos[k][1] >= 0 and pos[k][0] < 8 and pos[k][1] < 8: result.append(pos[k])
#print(result)
return result;
rook,knight,textToInt = input(),input(),{'a':0,'b':1,'c':2,'d':3,'e':4,'f':5,'g':6,'h':7}
rook = (textToInt[rook[0]], int(rook[1])-1)
knight = (textToInt[knight[0]], int(knight[1])-1)
fields = [[True for _ in range(8)] for __ in range(8)]
fields[knight[0]][knight[1]] =False
for i in range(8):
for j in range(8):
if i == rook[0]: fields[i][j] = False
elif j == rook[1]: fields[i][j] = False
for field in knightFields(knight[0],knight[1]):
fields[field[0]][field[1]] = False
for field in knightFields(rook[0],rook[1]):
fields[field[0]][field[1]] = False
count = 0
for field in fields:
# print(field)
for f in field:
if f: count +=1
print(count)
```
| 88,768 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Two chess pieces, a rook and a knight, stand on a standard chessboard 8 × 8 in size. The positions in which they are situated are known. It is guaranteed that none of them beats the other one.
Your task is to find the number of ways to place another knight on the board so that none of the three pieces on the board beat another one. A new piece can only be placed on an empty square.
Input
The first input line contains the description of the rook's position on the board. This description is a line which is 2 in length. Its first symbol is a lower-case Latin letter from a to h, and its second symbol is a number from 1 to 8. The second line contains the description of the knight's position in a similar way. It is guaranteed that their positions do not coincide.
Output
Print a single number which is the required number of ways.
Examples
Input
a1
b2
Output
44
Input
a8
d4
Output
38
Tags: brute force, implementation, math
Correct Solution:
```
rook, horse = input(), input()
beat = {i: {j: False for j in range(1, 9)} for i in range(1, 9)}
key = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7, 'h': 8}
r = (key[rook[0]], int(rook[1]))
h = (key[horse[0]], int(horse[1]))
dx = (2, 1, -1, -2, -2, -1, 1, 2)
dy = (1, 2, 2, 1, -1, -2, -2, -1)
for i in range(1, 9):
beat[i][r[1]] = True
beat[r[0]][i] = True
for i in range(8):
x, y = r[0] + dx[i], r[1] + dy[i]
if 1 <= x <= 8 and 1 <= y <= 8:
beat[x][y] = True
x, y = h[0] + dx[i], h[1] + dy[i]
if 1 <= x <= 8 and 1 <= y <= 8:
beat[x][y] = True
beat[h[0]][h[1]] = True
ans = 0
for i in range(1, 9):
for j in range(1, 9):
if beat[i][j] == False:
ans += 1
print(ans)
```
| 88,769 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Two chess pieces, a rook and a knight, stand on a standard chessboard 8 × 8 in size. The positions in which they are situated are known. It is guaranteed that none of them beats the other one.
Your task is to find the number of ways to place another knight on the board so that none of the three pieces on the board beat another one. A new piece can only be placed on an empty square.
Input
The first input line contains the description of the rook's position on the board. This description is a line which is 2 in length. Its first symbol is a lower-case Latin letter from a to h, and its second symbol is a number from 1 to 8. The second line contains the description of the knight's position in a similar way. It is guaranteed that their positions do not coincide.
Output
Print a single number which is the required number of ways.
Examples
Input
a1
b2
Output
44
Input
a8
d4
Output
38
Tags: brute force, implementation, math
Correct Solution:
```
def chk(x,y,x1,y1,x2,y2):
if x==x1 or y==y1:
return False
if x==x2 and y==y2:
return False
if abs(x-x1)*abs(y-y1)==2:
return False
if abs(x-x2)*abs(y-y2)==2:
return False
return True
s=input()
x1=ord(s[0])-ord('a')
y1=int(s[1])-1
s=input()
x2=ord(s[0])-ord('a')
y2=int(s[1])-1
ans=0
for i in range(8):
for j in range(8):
if chk(i,j,x1,y1,x2,y2):
ans+=1
print(ans)
```
| 88,770 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Two chess pieces, a rook and a knight, stand on a standard chessboard 8 × 8 in size. The positions in which they are situated are known. It is guaranteed that none of them beats the other one.
Your task is to find the number of ways to place another knight on the board so that none of the three pieces on the board beat another one. A new piece can only be placed on an empty square.
Input
The first input line contains the description of the rook's position on the board. This description is a line which is 2 in length. Its first symbol is a lower-case Latin letter from a to h, and its second symbol is a number from 1 to 8. The second line contains the description of the knight's position in a similar way. It is guaranteed that their positions do not coincide.
Output
Print a single number which is the required number of ways.
Examples
Input
a1
b2
Output
44
Input
a8
d4
Output
38
Tags: brute force, implementation, math
Correct Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Jan 17 15:11:07 2020
@author: thom
"""
pos_rook = input()
pos_knight = input()
#pos_rook = "a1"
#pos_knight = "b2"
import string
letter_rook = string.ascii_lowercase.index(pos_rook[0])
number_rook = int(pos_rook[1]) - 1
letter_knight = string.ascii_lowercase.index(pos_knight[0])
number_knight = int(pos_knight[1]) - 1
#rook = [[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],
# [0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0]]
rook = [[0 for i in range(8)] for j in range(8)]
knight = [[0 for i in range(8)] for j in range(8)]
def prohibit_knight (board, letter, number):
for i in range(8):
for j in range(8):
if ((i - letter)**2 + (j-number)**2) == 5:
board[i][j] = 1
if (i ==letter and j == number):
board[i][j] = 1
return(board)
def prohibit_rook (board, letter, number):
prohibit_knight(board, letter, number)
for i in range(8):
board[letter][i] = 1
for i in range(8):
board[i][number] = 1
return(board)
v1 = prohibit_knight(knight, letter_knight, number_knight)
v2 = prohibit_rook(rook, letter_rook, number_rook)
v3 = [[0 for i in range(8)] for j in range(8)]
count = 0
for i in range(8):
for j in range(8):
v3[i][j] = v1[i][j] or v2[i][j]
count = count + v3[i][j]
print(64 - count)
```
| 88,771 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Two chess pieces, a rook and a knight, stand on a standard chessboard 8 × 8 in size. The positions in which they are situated are known. It is guaranteed that none of them beats the other one.
Your task is to find the number of ways to place another knight on the board so that none of the three pieces on the board beat another one. A new piece can only be placed on an empty square.
Input
The first input line contains the description of the rook's position on the board. This description is a line which is 2 in length. Its first symbol is a lower-case Latin letter from a to h, and its second symbol is a number from 1 to 8. The second line contains the description of the knight's position in a similar way. It is guaranteed that their positions do not coincide.
Output
Print a single number which is the required number of ways.
Examples
Input
a1
b2
Output
44
Input
a8
d4
Output
38
Tags: brute force, implementation, math
Correct Solution:
```
import sys
import math
import bisect
def is_knight_attack(a, b):
if abs(a[0] - b[0]) == 1 and abs(a[1] - b[1]) == 2:
return True
if abs(a[0] - b[0]) == 2 and abs(a[1] - b[1]) == 1:
return True
return False
def solve(a, b):
ans = 0
for i in range(8):
for j in range(8):
c = (i, j)
if c != a and c != b:
ok = True
#print('a: %s, b: %s, c: %s' % (str(a), str(b), str(c)))
if c[0] == a[0]:
ok = False
if c[1] == a[1]:
ok = False
if is_knight_attack(a, c):
ok = False
if is_knight_attack(b, c):
ok = False
if ok:
ans += 1
return ans
def main():
s = input()
A = (ord(s[0]) - ord('a'), int(s[1]) - 1)
s = input()
B = (ord(s[0]) - ord('a'), int(s[1]) - 1)
print(solve(A, B))
if __name__ == "__main__":
main()
```
| 88,772 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Two chess pieces, a rook and a knight, stand on a standard chessboard 8 × 8 in size. The positions in which they are situated are known. It is guaranteed that none of them beats the other one.
Your task is to find the number of ways to place another knight on the board so that none of the three pieces on the board beat another one. A new piece can only be placed on an empty square.
Input
The first input line contains the description of the rook's position on the board. This description is a line which is 2 in length. Its first symbol is a lower-case Latin letter from a to h, and its second symbol is a number from 1 to 8. The second line contains the description of the knight's position in a similar way. It is guaranteed that their positions do not coincide.
Output
Print a single number which is the required number of ways.
Examples
Input
a1
b2
Output
44
Input
a8
d4
Output
38
Tags: brute force, implementation, math
Correct Solution:
```
import string
import re
pattern = re.compile('^[abcdefgh][12345678]$')
r = input()
k = input()
r_d = [string.ascii_lowercase.index(r[0]), int(r[1])]
k_d = [string.ascii_lowercase.index(k[0]), int(k[1])]
bad1 = [r[0]+str(i) for i in range(1,9)] # rook can take knight 2
bad2 = [j+r[1] for j in 'abcdefgh'] # rook can take knight 2
bad3a = [string.ascii_lowercase[k_d[0] + l] + str(k_d[1] + n) for l in [-2, 2] for n in [-1,1]] # knight 1 can take knight 2
bad3b = [string.ascii_lowercase[k_d[0] + l] + str(k_d[1] + n) for l in [-1, 1] for n in [-2,2]] # knight 1 can take knight 2
bad4a = [string.ascii_lowercase[r_d[0] + l] + str(r_d[1] + n) for l in [-2, 2] for n in [-1,1]] # knight 2 can take knight 1
bad4b = [string.ascii_lowercase[r_d[0] + l] + str(r_d[1] + n) for l in [-1, 1] for n in [-2,2]] # knight 2 can take knight 1
bad = set(bad1+bad2+bad3a+bad3b+bad4a+bad4b+[k])
print(64 - sum([bool(pattern.match(i)) for i in bad]))
```
| 88,773 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Two chess pieces, a rook and a knight, stand on a standard chessboard 8 × 8 in size. The positions in which they are situated are known. It is guaranteed that none of them beats the other one.
Your task is to find the number of ways to place another knight on the board so that none of the three pieces on the board beat another one. A new piece can only be placed on an empty square.
Input
The first input line contains the description of the rook's position on the board. This description is a line which is 2 in length. Its first symbol is a lower-case Latin letter from a to h, and its second symbol is a number from 1 to 8. The second line contains the description of the knight's position in a similar way. It is guaranteed that their positions do not coincide.
Output
Print a single number which is the required number of ways.
Examples
Input
a1
b2
Output
44
Input
a8
d4
Output
38
Tags: brute force, implementation, math
Correct Solution:
```
def is_valid(r, c): return (0 <= r <= 7) and (0 <= c <= 7)
rook = input()
knight = input()
r = 0
knight_moves = ((0, 0), (-2, -1), (-2, 1), (-1, -2), (-1, 2), (1, -2), (1, 2), (2, -1), (2, 1))
cols_dict = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7}
rook = (int(rook[1])-1, cols_dict[rook[0]])
knight = (int(knight[1])-1, cols_dict[knight[0]])
for i in range(8):
for j in range(8):
curr_pos = (i, j)
f = True
for k in range(-8, 8):
if (curr_pos[0]+k, curr_pos[1]) == rook: f = False; break
if (curr_pos[0], curr_pos[1]+k) == rook: f = False; break
if not f: continue
for m in knight_moves:
curr_possible_pos = (curr_pos[0]+m[0], curr_pos[1]+m[1])
if curr_possible_pos == knight or curr_possible_pos == rook: f = False; break
if f: r+= 1
print(r)
```
| 88,774 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two chess pieces, a rook and a knight, stand on a standard chessboard 8 × 8 in size. The positions in which they are situated are known. It is guaranteed that none of them beats the other one.
Your task is to find the number of ways to place another knight on the board so that none of the three pieces on the board beat another one. A new piece can only be placed on an empty square.
Input
The first input line contains the description of the rook's position on the board. This description is a line which is 2 in length. Its first symbol is a lower-case Latin letter from a to h, and its second symbol is a number from 1 to 8. The second line contains the description of the knight's position in a similar way. It is guaranteed that their positions do not coincide.
Output
Print a single number which is the required number of ways.
Examples
Input
a1
b2
Output
44
Input
a8
d4
Output
38
Submitted Solution:
```
import string
class Position:
def __init__(self, notation):
self.column = string.ascii_letters.index(notation[0])
self.row = int(notation[1]) - 1
def __str__(self):
return '%d %d' % (self.row, self.column)
rook = Position(input().strip())
knight = Position(input().strip())
moves = [(-2, -1), (-2, 1), (-1, -2), (-1, 2),
(2, -1), (2, 1), (1, -2), (1, 2)]
result = 0
for r in range(8):
for c in range(8):
if rook.row == r or rook.column == c:
continue
feasible = True
for piece in [rook, knight]:
if r == piece.row and c == piece.column:
feasible = False
break
for (dr, dc) in moves:
if r + dr == piece.row and c + dc == piece.column:
feasible = False
break
if feasible:
result += 1
print(result)
```
Yes
| 88,775 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two chess pieces, a rook and a knight, stand on a standard chessboard 8 × 8 in size. The positions in which they are situated are known. It is guaranteed that none of them beats the other one.
Your task is to find the number of ways to place another knight on the board so that none of the three pieces on the board beat another one. A new piece can only be placed on an empty square.
Input
The first input line contains the description of the rook's position on the board. This description is a line which is 2 in length. Its first symbol is a lower-case Latin letter from a to h, and its second symbol is a number from 1 to 8. The second line contains the description of the knight's position in a similar way. It is guaranteed that their positions do not coincide.
Output
Print a single number which is the required number of ways.
Examples
Input
a1
b2
Output
44
Input
a8
d4
Output
38
Submitted Solution:
```
ab = lambda x: -x if x<0 else x
def f(l):
s = "abcdefgh"
r,k = l
rx,kx = s.index(r[0]), s.index(k[0])
ry,ky = int(r[1])-1, int(k[1])-1
b = [1]*64 #1=valid; 0=invalid
for i in range(64):
ix,iy = i//8,i%8
dx,dy = ab(ix-kx),ab(iy-ky)
ex,ey = ab(ix-rx),ab(iy-ry)
if ix==rx or iy==ry or dx+dy==0 or (dx<3 and dy<3 and dx+dy==3) or (ex<3 and ey<3 and ex+ey==3):
b[i]=0
return sum(b)
l = [input() for _ in range(2)]
print(f(l))
```
Yes
| 88,776 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two chess pieces, a rook and a knight, stand on a standard chessboard 8 × 8 in size. The positions in which they are situated are known. It is guaranteed that none of them beats the other one.
Your task is to find the number of ways to place another knight on the board so that none of the three pieces on the board beat another one. A new piece can only be placed on an empty square.
Input
The first input line contains the description of the rook's position on the board. This description is a line which is 2 in length. Its first symbol is a lower-case Latin letter from a to h, and its second symbol is a number from 1 to 8. The second line contains the description of the knight's position in a similar way. It is guaranteed that their positions do not coincide.
Output
Print a single number which is the required number of ways.
Examples
Input
a1
b2
Output
44
Input
a8
d4
Output
38
Submitted Solution:
```
def notation(s):
if s == 'a':
return 1
if s == 'b':
return 2
if s == 'c':
return 3
if s == 'd':
return 4
if s == 'e':
return 5
if s == 'f':
return 6
if s == 'g':
return 7
if s == 'h':
return 8
def take(x1, y1, x2, y2):
if abs(x1 - x2) == 1 and abs(y1 - y2) == 2:
return True
elif abs(y1 - y2) == 1 and abs(x1 - x2) == 2:
return True
elif x1 == x2 and y1 == y2:
return True
else:
return False
rookList = list(input())
knightList = list(input())
rList = notation(rookList[0]), int(rookList[1])
kList = notation(knightList[0]), int(knightList[1])
sm = 0
for i in range(8):
if i + 1 == rList[0]:
continue
for j in range(8):
if j + 1 == rList[1]:
continue
if take(i + 1, j + 1, rList[0], rList[1]):
continue
if take(i + 1, j + 1, kList[0], kList[1]):
continue
sm += 1
print(sm)
```
Yes
| 88,777 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two chess pieces, a rook and a knight, stand on a standard chessboard 8 × 8 in size. The positions in which they are situated are known. It is guaranteed that none of them beats the other one.
Your task is to find the number of ways to place another knight on the board so that none of the three pieces on the board beat another one. A new piece can only be placed on an empty square.
Input
The first input line contains the description of the rook's position on the board. This description is a line which is 2 in length. Its first symbol is a lower-case Latin letter from a to h, and its second symbol is a number from 1 to 8. The second line contains the description of the knight's position in a similar way. It is guaranteed that their positions do not coincide.
Output
Print a single number which is the required number of ways.
Examples
Input
a1
b2
Output
44
Input
a8
d4
Output
38
Submitted Solution:
```
def c(M,x,y):
p=[-2,+2]
q=[-1,+1]
l=[M[x+p[i]][y+q[j]]!=0 for i in range(len(p)) for j in range(len(q)) if(0<=x+p[i]<8 and 0<=y+q[j]<8)]
l+=[M[x+q[i]][y+p[j]]!=0 for i in range(len(q)) for j in range(len(p)) if(0<=x+q[i]<8 and 0<=y+p[j]<8)]
return 1 in l
mp=['a','b','c','d','e','f','g','h']
i=input
n=i()
m=i()
M=[[0 for x in range(8)]for y in range(8)]
l=[[mp.index(n[0]),int(n[1])-1],[mp.index(m[0]),int(m[1])-1]]
M[l[0][0]][l[0][1]]=2
M[l[1][0]][l[1][1]]=1
r=0
for x in range(8):
for y in range(8):
if(0==M[x][y]):
if(x==l[0][0]or y==l[0][1]):continue
if(c(M,x,y)==False):r+=1
print(r)
```
Yes
| 88,778 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two chess pieces, a rook and a knight, stand on a standard chessboard 8 × 8 in size. The positions in which they are situated are known. It is guaranteed that none of them beats the other one.
Your task is to find the number of ways to place another knight on the board so that none of the three pieces on the board beat another one. A new piece can only be placed on an empty square.
Input
The first input line contains the description of the rook's position on the board. This description is a line which is 2 in length. Its first symbol is a lower-case Latin letter from a to h, and its second symbol is a number from 1 to 8. The second line contains the description of the knight's position in a similar way. It is guaranteed that their positions do not coincide.
Output
Print a single number which is the required number of ways.
Examples
Input
a1
b2
Output
44
Input
a8
d4
Output
38
Submitted Solution:
```
def rmvKn(mgc, x, y):
mgc.add((x,y))
if not x - 1 < 0 and not y + 2 > 7: mgc.add((x-1, y+2))
if not x - 2 < 0 and not y - 1 < 0: mgc.add((x-2, y-1))
if not x - 2 < 0 and not y + 1 > 7: mgc.add((x-2, y+1))
if not x - 1 < 0 and not y - 2 < 0: mgc.add((x-1, y-2))
if not x + 1 > 7 and not y - 2 < 0: mgc.add((x+1, y-2))
if not x + 2 > 7 and not y - 1 < 0: mgc.add((x+2, y-1))
if not x + 2 > 7 and not y + 1 > 7: mgc.add((x+2, y+1))
if not x + 1 > 7 and not y + 2 > 7: mgc.add((x+1, y+2))
def rmvR(mgc, x, y):
for i in range(8):
mgc.add((i, y))
mgc.add((x, i))
r=input()
kn=input()
R=[ord(r[0])-97, int(r[1])-1]
Kn=[ord(kn[0])-97, int(kn[1])-1]
mgc=set()
rmvR(mgc,R[0],R[1])
rmvKn(mgc,Kn[0],Kn[1])
count = 0
for x in mgc:
count += 1
print(64-count-2)
```
No
| 88,779 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two chess pieces, a rook and a knight, stand on a standard chessboard 8 × 8 in size. The positions in which they are situated are known. It is guaranteed that none of them beats the other one.
Your task is to find the number of ways to place another knight on the board so that none of the three pieces on the board beat another one. A new piece can only be placed on an empty square.
Input
The first input line contains the description of the rook's position on the board. This description is a line which is 2 in length. Its first symbol is a lower-case Latin letter from a to h, and its second symbol is a number from 1 to 8. The second line contains the description of the knight's position in a similar way. It is guaranteed that their positions do not coincide.
Output
Print a single number which is the required number of ways.
Examples
Input
a1
b2
Output
44
Input
a8
d4
Output
38
Submitted Solution:
```
f={'a':1,'b':2,'c':3,'d':4,'e':5,'f':6,'g':7,'h':8}
a = input()
b =input()
A = [f[a[0]],int(a[-1])]
B = [f[b[0]],int(b[-1]) ]
u=[]
if 1<=A[0]-1 <=8 and 1<=A[1]-2<=8:
u.append([A[0]-1,A[1]-2])
if 1<=A[0]+1 <=8 and 1<=A[1]-2<=8:
u.append([A[0]+1,A[1]-2])
if 1<=A[0]+2 <=8 and 1<=A[1]-1<=8:
u.append([A[0]+2,A[1]-1])
if 1<=A[0]+2 <=8 and 1<=A[1]+1<=8:
u.append([A[0]+1,A[1]+1])
if 1<=A[0]+1 <=8 and 1<=A[1]+2<=8:
u.append([A[0]+1,A[1]+2])
if 1<=A[0]-1 <=8 and 1<=A[1]+2<=8:
u.append([A[0]-1,A[1]+2])
if 1<=A[0]-2 <=8 and 1<=A[1]+1<=8:
u.append([A[0]-2,A[1]+1])
if 1<=A[0]-2 <=8 and 1<=A[1]-1<=8:
u.append([A[0]-2,A[1]-1])
#hghj
if 1<=B[0]-1 <=8 and 1<=B[1]-2<=8:
u.append([B[0]-1,B[1]-2])
if 1<=B[0]+1 <=8 and 1<=B[1]-2<=8:
u.append([B[0]+1,B[1]-2])
if 1<=B[0]+2 <=8 and 1<=B[1]-1<=8:
u.append([B[0]+2,B[1]-1])
if 1<=B[0]+2 <=8 and 1<=B[1]+1<=8:
u.append([B[0]+1,B[1]+1])
if 1<=B[0]+1 <=8 and 1<=B[1]+2<=8:
u.append([B[0]+1,B[1]+2])
if 1<=B[0]-1 <=8 and 1<=B[1]+2<=8:
u.append([B[0]-1,B[1]+2])
if 1<=B[0]-2 <=8 and 1<=B[1]+1<=8:
u.append([B[0]-2,B[1]+1])
if 1<=B[0]-2 <=8 and 1<=B[1]-1<=8:
u.append([B[0]-2,B[1]-1])
for k in range(1,9):
if [k,B[1]] not in u:
u.append([k,B[1]])
for j in range(1,9):
if [B[0],j] not in u:
u.append([B[0],j])
f=[]
p=0
for j in u:
if j not in f:
p+=1
f.append(j)
if B not in f:
p+=1
if A not in f:
p+=1
print(64-(p))
```
No
| 88,780 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two chess pieces, a rook and a knight, stand on a standard chessboard 8 × 8 in size. The positions in which they are situated are known. It is guaranteed that none of them beats the other one.
Your task is to find the number of ways to place another knight on the board so that none of the three pieces on the board beat another one. A new piece can only be placed on an empty square.
Input
The first input line contains the description of the rook's position on the board. This description is a line which is 2 in length. Its first symbol is a lower-case Latin letter from a to h, and its second symbol is a number from 1 to 8. The second line contains the description of the knight's position in a similar way. It is guaranteed that their positions do not coincide.
Output
Print a single number which is the required number of ways.
Examples
Input
a1
b2
Output
44
Input
a8
d4
Output
38
Submitted Solution:
```
p = []
for i in range(12):
p.append([1] * 12)
for i in range(2, 10):
for t in range(2, 10):
p[i][t] = 0
dic = 'abcdefgh'
a = input()
b = input()
p1x = dic.index(a[0]) + 2
p1y = int(a[1]) + 1
p2x = dic.index(b[0]) + 2
p2y = int(b[1]) + 1
for i in range(12):
p[i][p1y] = 1
p[p1x][i] = 1
x = p2x
y = p2y
p[x + 1][y + 2] = 1
p[x + 2][y + 1] = 1
p[x + 2][y - 1] = 1
p[x + 1][y - 2] = 1
p[x - 1][y - 2] = 1
p[x - 2][y - 1] = 1
p[x - 2][y + 1] = 1
p[x - 1][y + 2] = 1
sum = 0
for i in range(12):
sum += p[i].count(0)
print(sum - 3)
```
No
| 88,781 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two chess pieces, a rook and a knight, stand on a standard chessboard 8 × 8 in size. The positions in which they are situated are known. It is guaranteed that none of them beats the other one.
Your task is to find the number of ways to place another knight on the board so that none of the three pieces on the board beat another one. A new piece can only be placed on an empty square.
Input
The first input line contains the description of the rook's position on the board. This description is a line which is 2 in length. Its first symbol is a lower-case Latin letter from a to h, and its second symbol is a number from 1 to 8. The second line contains the description of the knight's position in a similar way. It is guaranteed that their positions do not coincide.
Output
Print a single number which is the required number of ways.
Examples
Input
a1
b2
Output
44
Input
a8
d4
Output
38
Submitted Solution:
```
rook = input()
knight = input()
rook = list(rook)
knight = list(knight)
rook[0] = ord(rook[0])-96
knight[0] = ord(knight[0])-96
s = set()
s.add((int(rook[0]),int(rook[1])))
s.add((int(knight[0]),int(knight[1])))
# print(s)
for i in range(1,9):
s.add((int(rook[0]),i))
for i in range(1,9):
s.add((i,int(rook[1])))
knight[1] = int(knight[1])
rook[1] = int(rook[1])
# print(s)
if knight[0]-1 > 0 and knight[1]-2 > 0:
s.add((knight[0]-1,knight[1]-2))
if knight[0]-1 > 0 and knight[1]+2 <= 8:
s.add((knight[0]-1,knight[1]+2))
if knight[0]+1 <= 8 and knight[1]-2 > 0:
s.add((knight[0]+1,knight[1]-2))
if knight[0]+1 <= 8 and knight[1]+2 <= 8:
s.add((knight[0]+1,knight[1]+2))
if knight[0]+2 <= 8 and knight[1]-1 > 0:
s.add((knight[0]+2,knight[1]-1))
if knight[0]+2 <= 8 and knight[1]+1 <= 8:
s.add((knight[0]+2,knight[1]+1))
if knight[0]-2 > 0 and knight[1]+1 <= 8:
s.add((knight[0]-2,knight[1]+1))
if knight[0]-2 > 0 and knight[1]-1 > 0:
s.add((knight[0]-2,knight[1]-1))
if rook[0]-1 > 0 and rook[1]-2 > 0:
s.add((rook[0]-1,rook[1]-2))
if rook[0]-1 > 0 and rook[1]+2 <= 8:
s.add((rook[0]-1,rook[1]-2))
if rook[0]+1 <= 8 and rook[1]+2 <= 8:
s.add((rook[0]+1,rook[1]+2))
if rook[0]+1 <= 8 and rook[1]-2 > 0:
s.add((rook[0]+1,rook[1]+2))
if rook[0]-2 > 0 and rook[1]+1 <= 8:
s.add((rook[0]-2,rook[1]+1))
if rook[0]-2 > 0 and rook[1]-1 > 0:
s.add((rook[0]-2,rook[1]-1))
if rook[0]+2 <= 8 and rook[1]+1 <= 8:
s.add((rook[0]+2,rook[1]+1))
if rook[0]+2 <= 8 and rook[1]-1 > 0:
s.add((rook[0]+2,rook[1]-1))
print(64-len(s))
```
No
| 88,782 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago as a result of combat operations the main Berland place of interest — the magic clock — was damaged. The cannon's balls made several holes in the clock, that's why the residents are concerned about the repair. The magic clock can be represented as an infinite Cartesian plane, where the origin corresponds to the clock center. The clock was painted two colors as is shown in the picture:
<image>
The picture shows only the central part of the clock. This coloring naturally extends to infinity.
The balls can be taken to be points on the plane. Your task is to find the color of the area, damaged by the given ball.
All the points located on the border of one of the areas have to be considered painted black.
Input
The first and single line contains two integers x and y — the coordinates of the hole made in the clock by the ball. Each of the numbers x and y has an absolute value that does not exceed 1000.
Output
Find the required color.
All the points between which and the origin of coordinates the distance is integral-value are painted black.
Examples
Input
-2 1
Output
white
Input
2 1
Output
black
Input
4 3
Output
black
Tags: constructive algorithms, geometry, implementation, math
Correct Solution:
```
from math import sqrt,ceil
x,y=map(int,input().split())
if x==0 or y==0:
print("black")
else:
if ( x>0 and y>0 ) or ( x<0 and y<0 ) :
d = sqrt( (x**2) + (y**2) )
if int(d)==ceil(d):
print('black')
else:
if int(d)%2==0:
print("black")
else:
print("white")
elif ( x<0 and y>0 ) or ( x>0 and y<0 ) :
d = sqrt( (x**2) + (y**2) )
if int(d)==ceil(d):
print('black')
else:
if int(d)%2==0:
print("white")
else:
print("black")
```
| 88,783 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago as a result of combat operations the main Berland place of interest — the magic clock — was damaged. The cannon's balls made several holes in the clock, that's why the residents are concerned about the repair. The magic clock can be represented as an infinite Cartesian plane, where the origin corresponds to the clock center. The clock was painted two colors as is shown in the picture:
<image>
The picture shows only the central part of the clock. This coloring naturally extends to infinity.
The balls can be taken to be points on the plane. Your task is to find the color of the area, damaged by the given ball.
All the points located on the border of one of the areas have to be considered painted black.
Input
The first and single line contains two integers x and y — the coordinates of the hole made in the clock by the ball. Each of the numbers x and y has an absolute value that does not exceed 1000.
Output
Find the required color.
All the points between which and the origin of coordinates the distance is integral-value are painted black.
Examples
Input
-2 1
Output
white
Input
2 1
Output
black
Input
4 3
Output
black
Tags: constructive algorithms, geometry, implementation, math
Correct Solution:
```
a,b=map(int,input().split())
i=0
while i*i<a*a+b*b:i+=1
black=0
if (i*i==a*a+b*b) or (a*b>=0)!=(i%2==0):black=1
if black:print("black")
else:print("white")
```
| 88,784 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago as a result of combat operations the main Berland place of interest — the magic clock — was damaged. The cannon's balls made several holes in the clock, that's why the residents are concerned about the repair. The magic clock can be represented as an infinite Cartesian plane, where the origin corresponds to the clock center. The clock was painted two colors as is shown in the picture:
<image>
The picture shows only the central part of the clock. This coloring naturally extends to infinity.
The balls can be taken to be points on the plane. Your task is to find the color of the area, damaged by the given ball.
All the points located on the border of one of the areas have to be considered painted black.
Input
The first and single line contains two integers x and y — the coordinates of the hole made in the clock by the ball. Each of the numbers x and y has an absolute value that does not exceed 1000.
Output
Find the required color.
All the points between which and the origin of coordinates the distance is integral-value are painted black.
Examples
Input
-2 1
Output
white
Input
2 1
Output
black
Input
4 3
Output
black
Tags: constructive algorithms, geometry, implementation, math
Correct Solution:
```
# url: https://codeforces.com/contest/40/problem/a
# tag:
# difficulty:
from typing import List
INF = float("inf")
NINF = float("-inf")
def read_string():
return input()
def read_string_line():
return [x for x in input().split(" ")]
def read_int_line():
return [int(x) for x in input().split(" ")]
def read_int():
return int(input())
def get_int_arr(s):
return [int(x) for x in s.split()]
def get_sum(acc, l, r):
"""
l, r are original index
"""
return acc[r] - acc[l]
P = int(1e9 + 7)
def exgcd(x, y):
if y == 0:
return x, 1, 0
g, a, b = exgcd(y, x % y)
t = x // y
return g, b, a - t * b
def inv(x):
g, a, b = exgcd(x, P)
return a
def calc_acc(arr):
ans = [0]
for a in arr:
ans.append(a + ans[-1])
return ans
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __sub__(self, other):
return Point(self.x - other.x, self.y - other.y)
def dot(self, other):
return self.x * other.x + self.y * other.y
def cross(self, other):
return self.x * other.y - self.y * other.x
def __str__(self):
return "Point(%s, %s)" % (self.x, self.y)
def abs(self):
return self.abs2() ** 0.5
def abs2(self):
return self.dot(self)
def get_point(line):
x, y = get_int_arr(line)
return Point(x, y)
eps = 1e-8
lines: List[str] = [*open(0)]
pt = get_point(lines[0])
r = pt.abs()
if pt.x == 0 or pt.y == 0 or abs(r - int(r)) <= eps or abs(r - int(r + 0.5)) <= eps:
print("black")
else:
r = int(r)
if (r % 2 == 0 and pt.x * pt.y > 0) or (r % 2 == 1 and pt.x * pt.y < 0):
print("black")
else:
print("white")
```
| 88,785 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago as a result of combat operations the main Berland place of interest — the magic clock — was damaged. The cannon's balls made several holes in the clock, that's why the residents are concerned about the repair. The magic clock can be represented as an infinite Cartesian plane, where the origin corresponds to the clock center. The clock was painted two colors as is shown in the picture:
<image>
The picture shows only the central part of the clock. This coloring naturally extends to infinity.
The balls can be taken to be points on the plane. Your task is to find the color of the area, damaged by the given ball.
All the points located on the border of one of the areas have to be considered painted black.
Input
The first and single line contains two integers x and y — the coordinates of the hole made in the clock by the ball. Each of the numbers x and y has an absolute value that does not exceed 1000.
Output
Find the required color.
All the points between which and the origin of coordinates the distance is integral-value are painted black.
Examples
Input
-2 1
Output
white
Input
2 1
Output
black
Input
4 3
Output
black
Tags: constructive algorithms, geometry, implementation, math
Correct Solution:
```
import math
import sys
x,y=map(int,input().split())
is_right=(x*y>=0)
r=(x**2+y**2)**0.5
if r%1==0:
print("black")
else:
if is_right:
if r%2>1:
print("white")
else:
print("black")
else:
if r%2>1:
print("black")
else:
print("white")
```
| 88,786 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago as a result of combat operations the main Berland place of interest — the magic clock — was damaged. The cannon's balls made several holes in the clock, that's why the residents are concerned about the repair. The magic clock can be represented as an infinite Cartesian plane, where the origin corresponds to the clock center. The clock was painted two colors as is shown in the picture:
<image>
The picture shows only the central part of the clock. This coloring naturally extends to infinity.
The balls can be taken to be points on the plane. Your task is to find the color of the area, damaged by the given ball.
All the points located on the border of one of the areas have to be considered painted black.
Input
The first and single line contains two integers x and y — the coordinates of the hole made in the clock by the ball. Each of the numbers x and y has an absolute value that does not exceed 1000.
Output
Find the required color.
All the points between which and the origin of coordinates the distance is integral-value are painted black.
Examples
Input
-2 1
Output
white
Input
2 1
Output
black
Input
4 3
Output
black
Tags: constructive algorithms, geometry, implementation, math
Correct Solution:
```
a, b = list(map(int, input().split(' ')))
d=((a**2+b**2)**0.5)
if d%1==0:
print("black")
else:
if (a > 0 and b > 0) or (a<0 and b<0):
if int((a**2+b**2)**0.5)%2 == 0:
print("black")
else:
print("white")
else:
if int((a**2+b**2)**0.5)%2==0:
print("white")
else:
print("black")
```
| 88,787 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago as a result of combat operations the main Berland place of interest — the magic clock — was damaged. The cannon's balls made several holes in the clock, that's why the residents are concerned about the repair. The magic clock can be represented as an infinite Cartesian plane, where the origin corresponds to the clock center. The clock was painted two colors as is shown in the picture:
<image>
The picture shows only the central part of the clock. This coloring naturally extends to infinity.
The balls can be taken to be points on the plane. Your task is to find the color of the area, damaged by the given ball.
All the points located on the border of one of the areas have to be considered painted black.
Input
The first and single line contains two integers x and y — the coordinates of the hole made in the clock by the ball. Each of the numbers x and y has an absolute value that does not exceed 1000.
Output
Find the required color.
All the points between which and the origin of coordinates the distance is integral-value are painted black.
Examples
Input
-2 1
Output
white
Input
2 1
Output
black
Input
4 3
Output
black
Tags: constructive algorithms, geometry, implementation, math
Correct Solution:
```
def define(x, y):
dist = 0
while dist * dist < x * x + y * y:
dist += 1
flag = (dist * dist == x * x + y * y) or ((dist % 2 == 0) != (x * y >= 0))
if flag == 1:
return "black"
return "white"
X, Y = [int(i) for i in input().split()]
print(define(X, Y))
```
| 88,788 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago as a result of combat operations the main Berland place of interest — the magic clock — was damaged. The cannon's balls made several holes in the clock, that's why the residents are concerned about the repair. The magic clock can be represented as an infinite Cartesian plane, where the origin corresponds to the clock center. The clock was painted two colors as is shown in the picture:
<image>
The picture shows only the central part of the clock. This coloring naturally extends to infinity.
The balls can be taken to be points on the plane. Your task is to find the color of the area, damaged by the given ball.
All the points located on the border of one of the areas have to be considered painted black.
Input
The first and single line contains two integers x and y — the coordinates of the hole made in the clock by the ball. Each of the numbers x and y has an absolute value that does not exceed 1000.
Output
Find the required color.
All the points between which and the origin of coordinates the distance is integral-value are painted black.
Examples
Input
-2 1
Output
white
Input
2 1
Output
black
Input
4 3
Output
black
Tags: constructive algorithms, geometry, implementation, math
Correct Solution:
```
import math
x, y = map(int, input().split())
dd = x*x + y*y
d = math.floor(dd ** 0.5)
black = False
if d*d == dd:
black = True
elif x/abs(x) == y/abs(y):
black = d%2 == 0
else:
black = d%2 == 1
if black:
print('black')
else:
print('white')
```
| 88,789 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago as a result of combat operations the main Berland place of interest — the magic clock — was damaged. The cannon's balls made several holes in the clock, that's why the residents are concerned about the repair. The magic clock can be represented as an infinite Cartesian plane, where the origin corresponds to the clock center. The clock was painted two colors as is shown in the picture:
<image>
The picture shows only the central part of the clock. This coloring naturally extends to infinity.
The balls can be taken to be points on the plane. Your task is to find the color of the area, damaged by the given ball.
All the points located on the border of one of the areas have to be considered painted black.
Input
The first and single line contains two integers x and y — the coordinates of the hole made in the clock by the ball. Each of the numbers x and y has an absolute value that does not exceed 1000.
Output
Find the required color.
All the points between which and the origin of coordinates the distance is integral-value are painted black.
Examples
Input
-2 1
Output
white
Input
2 1
Output
black
Input
4 3
Output
black
Tags: constructive algorithms, geometry, implementation, math
Correct Solution:
```
x, y = map(int, input().split())
p = x * x + y * y
d = int(p ** 0.5)
if d * d == p: print('black')
else:
if x * y < 0: print('black' if d % 2 else 'white')
else: print('white' if d % 2 else 'black')
```
| 88,790 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago as a result of combat operations the main Berland place of interest — the magic clock — was damaged. The cannon's balls made several holes in the clock, that's why the residents are concerned about the repair. The magic clock can be represented as an infinite Cartesian plane, where the origin corresponds to the clock center. The clock was painted two colors as is shown in the picture:
<image>
The picture shows only the central part of the clock. This coloring naturally extends to infinity.
The balls can be taken to be points on the plane. Your task is to find the color of the area, damaged by the given ball.
All the points located on the border of one of the areas have to be considered painted black.
Input
The first and single line contains two integers x and y — the coordinates of the hole made in the clock by the ball. Each of the numbers x and y has an absolute value that does not exceed 1000.
Output
Find the required color.
All the points between which and the origin of coordinates the distance is integral-value are painted black.
Examples
Input
-2 1
Output
white
Input
2 1
Output
black
Input
4 3
Output
black
Submitted Solution:
```
import sys
import math
import itertools
import collections
def getdict(n):
d = {}
if type(n) is list or type(n) is str:
for i in n:
if i in d:
d[i] += 1
else:
d[i] = 1
else:
for i in range(n):
t = ii()
if t in d:
d[t] += 1
else:
d[t] = 1
return d
def cdiv(n, k): return n // k + (n % k != 0)
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(map(int, input().split()))
def lcm(a, b): return abs(a*b) // math.gcd(a, b)
def wr(arr): return ' '.join(map(str, arr))
def revn(n): return int(str(n)[::-1])
def prime(n):
if n == 2: return True
if n % 2 == 0 or n <= 1: return False
sqr = int(math.sqrt(n)) + 1
for d in range(3, sqr, 2):
if n % d == 0: return False
return True
x, y = mi()
r = math.sqrt(x ** 2 + y ** 2)
if x * y > 0 and int(r) % 2 == 1 and int(r) < r and r < int(r) + 1\
or x * y < 0 and int(r) % 2 == 0 and int(r) < r and r < int(r) + 1:
print('white')
else:
print('black')
```
Yes
| 88,791 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago as a result of combat operations the main Berland place of interest — the magic clock — was damaged. The cannon's balls made several holes in the clock, that's why the residents are concerned about the repair. The magic clock can be represented as an infinite Cartesian plane, where the origin corresponds to the clock center. The clock was painted two colors as is shown in the picture:
<image>
The picture shows only the central part of the clock. This coloring naturally extends to infinity.
The balls can be taken to be points on the plane. Your task is to find the color of the area, damaged by the given ball.
All the points located on the border of one of the areas have to be considered painted black.
Input
The first and single line contains two integers x and y — the coordinates of the hole made in the clock by the ball. Each of the numbers x and y has an absolute value that does not exceed 1000.
Output
Find the required color.
All the points between which and the origin of coordinates the distance is integral-value are painted black.
Examples
Input
-2 1
Output
white
Input
2 1
Output
black
Input
4 3
Output
black
Submitted Solution:
```
# _
#####################################################################################################################
from math import sqrt, ceil
def colorOfDamagedArea(coordinate):
x, y = coordinate.split()
x, y = int(x), int(y)
location = sqrt(x*x+y*y)
area_sBorder = ceil(location)
if location == area_sBorder:
return 'black'
area_sAddress = x*y
area_sColorCode = area_sBorder%2
if area_sAddress > 0 and area_sColorCode or area_sAddress < 0 and not area_sColorCode:
return 'black'
return 'white'
print(colorOfDamagedArea(input()))
```
Yes
| 88,792 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago as a result of combat operations the main Berland place of interest — the magic clock — was damaged. The cannon's balls made several holes in the clock, that's why the residents are concerned about the repair. The magic clock can be represented as an infinite Cartesian plane, where the origin corresponds to the clock center. The clock was painted two colors as is shown in the picture:
<image>
The picture shows only the central part of the clock. This coloring naturally extends to infinity.
The balls can be taken to be points on the plane. Your task is to find the color of the area, damaged by the given ball.
All the points located on the border of one of the areas have to be considered painted black.
Input
The first and single line contains two integers x and y — the coordinates of the hole made in the clock by the ball. Each of the numbers x and y has an absolute value that does not exceed 1000.
Output
Find the required color.
All the points between which and the origin of coordinates the distance is integral-value are painted black.
Examples
Input
-2 1
Output
white
Input
2 1
Output
black
Input
4 3
Output
black
Submitted Solution:
```
# # 20200103 00:54 ~ 01:01
x, y = map(int, input().split())
dist = pow(x**2 + y**2, 0.5)
if dist%1 == 0:
print("black")
else:
dist = int(dist)
is_odd = (dist%2 == 1)
if is_odd != (x*y>0):
print("black")
else:
print("white")
```
Yes
| 88,793 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago as a result of combat operations the main Berland place of interest — the magic clock — was damaged. The cannon's balls made several holes in the clock, that's why the residents are concerned about the repair. The magic clock can be represented as an infinite Cartesian plane, where the origin corresponds to the clock center. The clock was painted two colors as is shown in the picture:
<image>
The picture shows only the central part of the clock. This coloring naturally extends to infinity.
The balls can be taken to be points on the plane. Your task is to find the color of the area, damaged by the given ball.
All the points located on the border of one of the areas have to be considered painted black.
Input
The first and single line contains two integers x and y — the coordinates of the hole made in the clock by the ball. Each of the numbers x and y has an absolute value that does not exceed 1000.
Output
Find the required color.
All the points between which and the origin of coordinates the distance is integral-value are painted black.
Examples
Input
-2 1
Output
white
Input
2 1
Output
black
Input
4 3
Output
black
Submitted Solution:
```
from math import sqrt
x,y = list(map(int,input().split())) #1000
r = sqrt(x*x+y*y)
print('black' if ((int(r)%2>0) ^ (x*y>0)) or r==int(r) else 'white')
```
Yes
| 88,794 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago as a result of combat operations the main Berland place of interest — the magic clock — was damaged. The cannon's balls made several holes in the clock, that's why the residents are concerned about the repair. The magic clock can be represented as an infinite Cartesian plane, where the origin corresponds to the clock center. The clock was painted two colors as is shown in the picture:
<image>
The picture shows only the central part of the clock. This coloring naturally extends to infinity.
The balls can be taken to be points on the plane. Your task is to find the color of the area, damaged by the given ball.
All the points located on the border of one of the areas have to be considered painted black.
Input
The first and single line contains two integers x and y — the coordinates of the hole made in the clock by the ball. Each of the numbers x and y has an absolute value that does not exceed 1000.
Output
Find the required color.
All the points between which and the origin of coordinates the distance is integral-value are painted black.
Examples
Input
-2 1
Output
white
Input
2 1
Output
black
Input
4 3
Output
black
Submitted Solution:
```
x,y=map(int,input().split())
if x==0 or y==0:
print("black")
exit()
x,y=min(y,x),max(y,x)
if x<0:
if y<0:
x=abs(x)
if x%2:
y=abs(y)
if not y%2:
print("black")
else:
print("white")
else:
y=abs(y)
if not y%2:
print("white")
else:
print("black")
else:
if x%2:
y=abs(y)
if not y%2:
print("white")
else:
print("black")
else:
y=abs(y)
if not y%2:
print("black")
else:
print("white")
else:
if not y%2:
print("black")
else:
print("white")
```
No
| 88,795 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago as a result of combat operations the main Berland place of interest — the magic clock — was damaged. The cannon's balls made several holes in the clock, that's why the residents are concerned about the repair. The magic clock can be represented as an infinite Cartesian plane, where the origin corresponds to the clock center. The clock was painted two colors as is shown in the picture:
<image>
The picture shows only the central part of the clock. This coloring naturally extends to infinity.
The balls can be taken to be points on the plane. Your task is to find the color of the area, damaged by the given ball.
All the points located on the border of one of the areas have to be considered painted black.
Input
The first and single line contains two integers x and y — the coordinates of the hole made in the clock by the ball. Each of the numbers x and y has an absolute value that does not exceed 1000.
Output
Find the required color.
All the points between which and the origin of coordinates the distance is integral-value are painted black.
Examples
Input
-2 1
Output
white
Input
2 1
Output
black
Input
4 3
Output
black
Submitted Solution:
```
import math
n = list(map(int,input().split()))
x = n[0]
y = n[1]
k = int(math.sqrt(x*x + y*y))
if x*y < 0 :
if x*x +y*y == k*k :
if k % 2 == 0:
print('black')
else :
print('white')
else :
if k % 2 == 0:
print('white')
else :
print('black')
else :
if x*x +y*y == k*k :
if k % 2 == 0:
print('white')
else :
print('black')
else :
if k % 2 == 0:
print('black')
else :
print('white')
```
No
| 88,796 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago as a result of combat operations the main Berland place of interest — the magic clock — was damaged. The cannon's balls made several holes in the clock, that's why the residents are concerned about the repair. The magic clock can be represented as an infinite Cartesian plane, where the origin corresponds to the clock center. The clock was painted two colors as is shown in the picture:
<image>
The picture shows only the central part of the clock. This coloring naturally extends to infinity.
The balls can be taken to be points on the plane. Your task is to find the color of the area, damaged by the given ball.
All the points located on the border of one of the areas have to be considered painted black.
Input
The first and single line contains two integers x and y — the coordinates of the hole made in the clock by the ball. Each of the numbers x and y has an absolute value that does not exceed 1000.
Output
Find the required color.
All the points between which and the origin of coordinates the distance is integral-value are painted black.
Examples
Input
-2 1
Output
white
Input
2 1
Output
black
Input
4 3
Output
black
Submitted Solution:
```
x,y=map(float,input().split())
r=(x**2+y**2)**0.5
c=int(r)
if r==c:
print('black')
elif x*y==0:
print('black')
elif x*y>0:
if r%2==0:
print('white')
else:
print('black')
else:
if r%2==0:
print('black')
else:
print('white')
```
No
| 88,797 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago as a result of combat operations the main Berland place of interest — the magic clock — was damaged. The cannon's balls made several holes in the clock, that's why the residents are concerned about the repair. The magic clock can be represented as an infinite Cartesian plane, where the origin corresponds to the clock center. The clock was painted two colors as is shown in the picture:
<image>
The picture shows only the central part of the clock. This coloring naturally extends to infinity.
The balls can be taken to be points on the plane. Your task is to find the color of the area, damaged by the given ball.
All the points located on the border of one of the areas have to be considered painted black.
Input
The first and single line contains two integers x and y — the coordinates of the hole made in the clock by the ball. Each of the numbers x and y has an absolute value that does not exceed 1000.
Output
Find the required color.
All the points between which and the origin of coordinates the distance is integral-value are painted black.
Examples
Input
-2 1
Output
white
Input
2 1
Output
black
Input
4 3
Output
black
Submitted Solution:
```
a,b=map(int,input().split())
if (a<0 and b<0) or (a>0 and b>0):
if a==b:print(['black','white'][a%2==0]);exit()
print(['black','white'][max(abs(a),abs(b))&1])
else:
if a == b: print(['black', 'white'][a % 2]);exit()
print(['white','black'][max(abs(a),abs(b))&1 and abs(a)!=abs(b)])
```
No
| 88,798 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This time our child has a simple polygon. He has to find the number of ways to split the polygon into non-degenerate triangles, each way must satisfy the following requirements:
* each vertex of each triangle is one of the polygon vertex;
* each side of the polygon must be the side of exactly one triangle;
* the area of intersection of every two triangles equals to zero, and the sum of all areas of triangles equals to the area of the polygon;
* each triangle must be completely inside the polygon;
* each side of each triangle must contain exactly two vertices of the polygon.
The picture below depicts an example of a correct splitting.
<image>
Please, help the child. Calculate the described number of ways modulo 1000000007 (109 + 7) for him.
Input
The first line contains one integer n (3 ≤ n ≤ 200) — the number of vertices of the polygon. Then follow n lines, each line containing two integers. The i-th line contains xi, yi (|xi|, |yi| ≤ 107) — the i-th vertex of the polygon in clockwise or counterclockwise order.
It's guaranteed that the polygon is simple.
Output
Output the number of ways modulo 1000000007 (109 + 7).
Examples
Input
4
0 0
0 1
1 1
1 0
Output
2
Input
4
0 0
1 0
0 1
-1 0
Output
1
Input
5
0 0
1 0
1 1
0 1
-2 -1
Output
3
Note
In the first sample, there are two possible splittings:
<image>
In the second sample, there are only one possible splitting:
<image>
Submitted Solution:
```
print("hello world")
```
No
| 88,799 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.